diff options
Diffstat (limited to 'lib/clang/liblldb/LLDBWrapLua.cpp')
| -rw-r--r-- | lib/clang/liblldb/LLDBWrapLua.cpp | 83511 |
1 files changed, 83511 insertions, 0 deletions
diff --git a/lib/clang/liblldb/LLDBWrapLua.cpp b/lib/clang/liblldb/LLDBWrapLua.cpp new file mode 100644 index 000000000000..823354827790 --- /dev/null +++ b/lib/clang/liblldb/LLDBWrapLua.cpp @@ -0,0 +1,83511 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (https://www.swig.org). + * Version 4.2.1 + * + * Do not make changes to this file unless you know what you are doing - modify + * the SWIG interface file instead. + * ----------------------------------------------------------------------------- */ + + +#define SWIG_VERSION 0x040201 +#define SWIGLUA +#define SWIG_LUA_TARGET SWIG_LUA_FLAVOR_LUA +#define SWIG_LUA_MODULE_GLOBAL + +/* ----------------------------------------------------------------------------- + * 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_NULLPTR nullptr +#else +# define SWIG_NULLPTR NULL +#endif + +/* ----------------------------------------------------------------------------- + * swigcompat.swg + * + * Macros to provide support compatibility with older C and C++ standards. + * ----------------------------------------------------------------------------- */ + +/* 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 + +/* ----------------------------------------------------------------------------- + * 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 "4" + +/* 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 cast in linked list */ + struct swig_cast_info *prev; /* pointer to the previous cast */ +} 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; +} + +/* + Check the typename +*/ +SWIGRUNTIME swig_cast_info * +SWIG_TypeCheck(const char *c, swig_type_info *ty) { + if (ty) { + swig_cast_info *iter = ty->cast; + while (iter) { + if (strcmp(iter->type->name, c) == 0) { + if (iter == ty->cast) + return iter; + /* Move iter to the top of the linked list */ + iter->prev->next = iter->next; + if (iter->next) + iter->next->prev = iter->prev; + iter->next = ty->cast; + iter->prev = 0; + if (ty->cast) ty->cast->prev = iter; + ty->cast = iter; + return iter; + } + iter = iter->next; + } + } + return 0; +} + +/* + Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison +*/ +SWIGRUNTIME swig_cast_info * +SWIG_TypeCheckStruct(const swig_type_info *from, swig_type_info *ty) { + if (ty) { + swig_cast_info *iter = ty->cast; + while (iter) { + if (iter->type == from) { + if (iter == ty->cast) + return iter; + /* Move iter to the top of the linked list */ + iter->prev->next = iter->next; + if (iter->next) + iter->next->prev = iter->prev; + iter->next = ty->cast; + iter->prev = 0; + if (ty->cast) ty->cast->prev = iter; + ty->cast = iter; + return iter; + } + iter = iter->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 *cast = ti->cast; + /* if (ti->clientdata == clientdata) return; */ + ti->clientdata = clientdata; + + while (cast) { + if (!cast->converter) { + swig_type_info *tc = cast->type; + if (!tc->clientdata) { + SWIG_TypeClientData(tc, clientdata); + } + } + cast = cast->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 + + +/* ----------------------------------------------------------------------------- + * luarun.swg + * + * This file contains the runtime support for Lua modules + * and includes code for managing global variables and pointer + * type checking. + * ----------------------------------------------------------------------------- */ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "lua.h" +#include "lauxlib.h" +#include <stdlib.h> /* for malloc */ +#include <assert.h> /* for a few sanity tests */ + +/* ----------------------------------------------------------------------------- + * Lua flavors + * ----------------------------------------------------------------------------- */ + +#define SWIG_LUA_FLAVOR_LUA 1 +#define SWIG_LUA_FLAVOR_ELUA 2 +#define SWIG_LUA_FLAVOR_ELUAC 3 + +#if !defined(SWIG_LUA_TARGET) +# error SWIG_LUA_TARGET not defined +#endif + +#if defined(SWIG_LUA_ELUA_EMULATE) + +struct swig_elua_entry; + +typedef struct swig_elua_key { + int type; + union { + const char* strkey; + lua_Number numkey; + } key; +} swig_elua_key; + +typedef struct swig_elua_val { + int type; + union { + lua_Number number; + const struct swig_elua_entry *table; + const char *string; + lua_CFunction function; + struct { + char member; + long lvalue; + void *pvalue; + swig_type_info **ptype; + } userdata; + } value; +} swig_elua_val; + +typedef struct swig_elua_entry { + swig_elua_key key; + swig_elua_val value; +} swig_elua_entry; + +#define LSTRKEY(x) {LUA_TSTRING, {.strkey = x} } +#define LNUMKEY(x) {LUA_TNUMBER, {.numkey = x} } +#define LNILKEY {LUA_TNIL, {.strkey = 0} } + +#define LNUMVAL(x) {LUA_TNUMBER, {.number = x} } +#define LFUNCVAL(x) {LUA_TFUNCTION, {.function = x} } +#define LROVAL(x) {LUA_TTABLE, {.table = x} } +#define LNILVAL {LUA_TNIL, {.string = 0} } +#define LSTRVAL(x) {LUA_TSTRING, {.string = x} } + +#define LUA_REG_TYPE swig_elua_entry + +#define SWIG_LUA_ELUA_EMUL_METATABLE_KEY "__metatable" + +#define lua_pushrotable(L,p)\ + lua_newtable(L);\ + assert(p);\ + SWIG_Lua_elua_emulate_register(L,(swig_elua_entry*)(p)); + +#define SWIG_LUA_CONSTTAB_POINTER(B,C,D)\ + LSTRKEY(B), {LUA_TUSERDATA, { .userdata={0,0,(void*)(C),&D} } } + +#define SWIG_LUA_CONSTTAB_BINARY(B,S,C,D)\ + LSTRKEY(B), {LUA_TUSERDATA, { .userdata={1,S,(void*)(C),&D} } } +#endif + +#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) +# define SWIG_LUA_CONSTTAB_INT(B, C) LSTRKEY(B), LNUMVAL(C) +# define SWIG_LUA_CONSTTAB_FLOAT(B, C) LSTRKEY(B), LNUMVAL(C) +# define SWIG_LUA_CONSTTAB_STRING(B, C) LSTRKEY(B), LSTRVAL(C) +# define SWIG_LUA_CONSTTAB_CHAR(B, C) LSTRKEY(B), LNUMVAL(C) + /* Those two types of constants are not supported in elua */ + +#ifndef SWIG_LUA_CONSTTAB_POINTER +#warning eLua does not support pointers as constants. By default, nil will be used as value +#define SWIG_LUA_CONSTTAB_POINTER(B,C,D) LSTRKEY(B), LNILVAL +#endif + +#ifndef SWIG_LUA_CONSTTAB_BINARY +#warning eLua does not support pointers to member as constants. By default, nil will be used as value +#define SWIG_LUA_CONSTTAB_BINARY(B, S, C, D) LSTRKEY(B), LNILVAL +#endif +#else /* SWIG_LUA_FLAVOR_LUA */ +# define SWIG_LUA_CONSTTAB_INT(B, C) SWIG_LUA_INT, (char *)B, (long)C, 0, 0, 0 +# define SWIG_LUA_CONSTTAB_FLOAT(B, C) SWIG_LUA_FLOAT, (char *)B, 0, (double)C, 0, 0 +# define SWIG_LUA_CONSTTAB_STRING(B, C) SWIG_LUA_STRING, (char *)B, 0, 0, (void *)C, 0 +# define SWIG_LUA_CONSTTAB_CHAR(B, C) SWIG_LUA_CHAR, (char *)B, (long)C, 0, 0, 0 +# define SWIG_LUA_CONSTTAB_POINTER(B,C,D)\ + SWIG_LUA_POINTER, (char *)B, 0, 0, (void *)C, &D +# define SWIG_LUA_CONSTTAB_BINARY(B, S, C, D)\ + SWIG_LUA_BINARY, (char *)B, S, 0, (void *)C, &D +#endif + +#ifndef SWIG_LUA_ELUA_EMULATE +#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) +# define LRO_STRVAL(v) {{.p = (char *) v}, LUA_TSTRING} +# define LSTRVAL LRO_STRVAL +#endif +#endif /* SWIG_LUA_ELUA_EMULATE*/ + +#ifndef SWIG_LUA_ELUA_EMULATE +#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) + +#ifndef MIN_OPT_LEVEL +#define MIN_OPT_LEVEL 2 +#endif + +#include "lrodefs.h" +#include "lrotable.h" +#endif +#endif /* SWIG_LUA_ELUA_EMULATE*/ +/* ----------------------------------------------------------------------------- + * compatibility defines + * ----------------------------------------------------------------------------- */ + +/* History of Lua C API length functions: In Lua 5.0 (and before?) + there was "lua_strlen". In Lua 5.1, this was renamed "lua_objlen", + but a compatibility define of "lua_strlen" was added. In Lua 5.2, + this function was again renamed, to "lua_rawlen" (to emphasize that + it doesn't call the "__len" metamethod), and the compatibility + define of lua_strlen was removed. All SWIG uses have been updated + to "lua_rawlen", and we add our own defines of that here for older + versions of Lua. */ +#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 501 +# define lua_rawlen lua_strlen +#elif LUA_VERSION_NUM == 501 +# define lua_rawlen lua_objlen +#endif + +/* lua_tolstring() was added in Lua 5.1. It should be a little more + efficient than making two separate calls and it avoids problems with order + of evaluation so SWIG calls lua_tolstring() when it wants the length and + we provide a compatibility implementation for Lua 5.0. */ +#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 501 +static const char *(lua_tolstring)(lua_State *L, int idx, size_t *len) { + /* Call lua_tostring() first as it may convert the value from number to + string. */ + const char *result = lua_tostring(L, idx); + if (len) *len = lua_strlen(L, idx); + return result; +} +#endif + + +/* lua_pushglobaltable is the recommended "future-proof" way to get + the global table for Lua 5.2 and later. Here we define + lua_pushglobaltable ourselves for Lua versions before 5.2. */ +#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502 +# define lua_pushglobaltable(L) lua_pushvalue(L, LUA_GLOBALSINDEX) +#endif + +/* lua_absindex was introduced in Lua 5.2 */ +#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502 +# define lua_absindex(L,i) ((i)>0 || (i) <= LUA_REGISTRYINDEX ? (i) : lua_gettop(L) + (i) + 1) +#endif + +/* lua_rawsetp was introduced in Lua 5.2 */ +#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502 +#define lua_rawsetp(L,index,ptr)\ + lua_pushlightuserdata(L,(void*)(ptr));\ + lua_insert(L,-2);\ + lua_rawset(L,index); + +#define lua_rawgetp(L,index,ptr)\ + lua_pushlightuserdata(L,(void*)(ptr));\ + lua_rawget(L,index); + +#endif + +/* -------------------------------------------------------------------------- + * Helper functions for error handling + * -------------------------------------------------------------------------- */ + +/* Push the string STR on the Lua stack, like lua_pushstring, but + prefixed with the location of the innermost Lua call-point + (as formatted by luaL_where). */ +SWIGRUNTIME void +SWIG_Lua_pusherrstring (lua_State *L, const char *str) +{ + luaL_where (L, 1); + lua_pushstring (L, str); + lua_concat (L, 2); +} + +/* Push a formatted string generated from FMT and following args on + the Lua stack, like lua_pushfstring, but prefixed with the + location of the innermost Lua call-point (as formatted by luaL_where). */ +SWIGRUNTIME void +SWIG_Lua_pushferrstring (lua_State *L, const char *fmt, ...) +{ + va_list argp; + va_start(argp, fmt); + luaL_where(L, 1); + lua_pushvfstring(L, fmt, argp); + va_end(argp); + lua_concat(L, 2); +} + + +/* ----------------------------------------------------------------------------- + * global swig types + * ----------------------------------------------------------------------------- */ +/* Constant table */ +#define SWIG_LUA_INT 1 +#define SWIG_LUA_FLOAT 2 +#define SWIG_LUA_STRING 3 +#define SWIG_LUA_POINTER 4 +#define SWIG_LUA_BINARY 5 +#define SWIG_LUA_CHAR 6 + +/* Structure for variable linking table */ +typedef struct { + const char *name; + lua_CFunction get; + lua_CFunction set; +} swig_lua_var_info; + +#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) +typedef const LUA_REG_TYPE swig_lua_method; +typedef const LUA_REG_TYPE swig_lua_const_info; +#else /* Normal lua */ +typedef luaL_Reg swig_lua_method; + +/* Constant information structure */ +typedef struct { + int type; + char *name; + long lvalue; + double dvalue; + void *pvalue; + swig_type_info **ptype; +} swig_lua_const_info; + +#endif + +typedef struct { + const char *name; + lua_CFunction getmethod; + lua_CFunction setmethod; +} swig_lua_attribute; + + +struct swig_lua_class; +/* Can be used to create namespaces. Currently used to wrap class static methods/variables/constants */ +typedef struct swig_lua_namespace { + const char *name; + swig_lua_method *ns_methods; + swig_lua_attribute *ns_attributes; + swig_lua_const_info *ns_constants; + struct swig_lua_class **ns_classes; + struct swig_lua_namespace **ns_namespaces; +} swig_lua_namespace; + +typedef struct swig_lua_class { + const char *name; /* Name that this class has in Lua */ + const char *fqname; /* Fully qualified name - Scope + class name */ + swig_type_info **type; + lua_CFunction constructor; + void (*destructor)(void *); + swig_lua_method *methods; + swig_lua_attribute *attributes; + swig_lua_namespace *cls_static; + swig_lua_method *metatable; /* 0 for -eluac */ + struct swig_lua_class **bases; + const char **base_names; +} swig_lua_class; + +/* this is the struct for wrapping all pointers in SwigLua +*/ +typedef struct { + swig_type_info *type; + int own; /* 1 if owned & must be destroyed */ + void *ptr; +} swig_lua_userdata; + +/* this is the struct for wrapping arbitrary packed binary data +(currently it is only used for member function pointers) +the data ordering is similar to swig_lua_userdata, but it is currently not possible +to tell the two structures apart within SWIG, other than by looking at the type +*/ +typedef struct { + swig_type_info *type; + int own; /* 1 if owned & must be destroyed */ + char data[1]; /* arbitrary amount of data */ +} swig_lua_rawdata; + +/* Common SWIG API */ +#define SWIG_NewPointerObj(L, ptr, type, owner) SWIG_Lua_NewPointerObj(L, (void *)ptr, type, owner) +#define SWIG_ConvertPtr(L,idx, ptr, type, flags) SWIG_Lua_ConvertPtr(L,idx,ptr,type,flags) +#define SWIG_MustGetPtr(L,idx, type,flags, argnum,fnname) SWIG_Lua_MustGetPtr(L,idx, type,flags, argnum,fnname) +/* for C++ member pointers, ie, member methods */ +#define SWIG_ConvertMember(L, idx, ptr, sz, ty) SWIG_Lua_ConvertPacked(L, idx, ptr, sz, ty) +#define SWIG_NewMemberObj(L, ptr, sz, type) SWIG_Lua_NewPackedObj(L, ptr, sz, type) + +/* Runtime API */ +#define SWIG_GetModule(clientdata) SWIG_Lua_GetModule((lua_State*)(clientdata)) +#define SWIG_SetModule(clientdata, pointer) SWIG_Lua_SetModule((lua_State*) (clientdata), pointer) +#define SWIG_MODULE_CLIENTDATA_TYPE lua_State* + +/* Contract support */ +#define SWIG_contract_assert(expr, msg) \ + do { if (!(expr)) { SWIG_Lua_pusherrstring(L, (char *) msg); goto fail; } } while (0) + + +/* helper #defines */ +#define SWIG_fail {goto fail;} +#define SWIG_fail_arg(func_name,argnum,type) \ + {SWIG_Lua_pushferrstring(L,"Error in %s (arg %d), expected '%s' got '%s'",\ + func_name,argnum,type,SWIG_Lua_typename(L,argnum));\ + goto fail;} +#define SWIG_fail_ptr(func_name,argnum,type) \ + SWIG_fail_arg(func_name,argnum,(type && type->str)?type->str:"void*") +#define SWIG_check_num_args(func_name,a,b) \ + if (lua_gettop(L)<a || lua_gettop(L)>b) \ + {SWIG_Lua_pushferrstring(L,"Error in %s expected %d..%d args, got %d",func_name,a,b,lua_gettop(L));\ + goto fail;} + + +#define SWIG_Lua_get_table(L,n) \ + (lua_pushstring(L, n), lua_rawget(L,-2)) + +#define SWIG_Lua_add_function(L,n,f) \ + (lua_pushstring(L, n), \ + lua_pushcfunction(L, f), \ + lua_rawset(L,-3)) + +#define SWIG_Lua_add_boolean(L,n,b) \ + (lua_pushstring(L, n), \ + lua_pushboolean(L, b), \ + lua_rawset(L,-3)) + +/* special helper for allowing 'nil' for usertypes */ +#define SWIG_isptrtype(L,I) (lua_isuserdata(L,I) || lua_isnil(L,I)) + +#ifdef __cplusplus +/* Special helper for member function pointers +it gets the address, casts it, then dereferences it */ +/*#define SWIG_mem_fn_as_voidptr(a) (*((char**)&(a))) */ +#endif + +/* storing/access of swig_module_info */ +SWIGRUNTIME swig_module_info * +SWIG_Lua_GetModule(lua_State *L) { + swig_module_info *ret = 0; + lua_pushstring(L,"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME); + lua_rawget(L,LUA_REGISTRYINDEX); + if (lua_islightuserdata(L,-1)) + ret=(swig_module_info*)lua_touserdata(L,-1); + lua_pop(L,1); /* tidy */ + return ret; +} + +SWIGRUNTIME void +SWIG_Lua_SetModule(lua_State *L, swig_module_info *module) { + /* add this all into the Lua registry: */ + lua_pushstring(L,"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME); + lua_pushlightuserdata(L,(void*)module); + lua_rawset(L,LUA_REGISTRYINDEX); +} + +/* ----------------------------------------------------------------------------- + * global variable support code: modules + * ----------------------------------------------------------------------------- */ + +/* this function is called when trying to set an immutable. +default action is to print an error. +This can removed with a compile flag SWIGLUA_IGNORE_SET_IMMUTABLE */ +SWIGINTERN int SWIG_Lua_set_immutable(lua_State *L) +{ +/* there should be 1 param passed in: the new value */ +#ifndef SWIGLUA_IGNORE_SET_IMMUTABLE + lua_pop(L,1); /* remove it */ + luaL_error(L,"This variable is immutable"); +#endif + return 0; /* should not return anything */ +} + +#ifdef SWIG_LUA_ELUA_EMULATE + +SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State *L,void *ptr,swig_type_info *type, int own); +SWIGRUNTIME void SWIG_Lua_NewPackedObj(lua_State *L,void *ptr,size_t size,swig_type_info *type); +static int swig_lua_elua_emulate_unique_key; + +/* This function emulates eLua rotables behaviour. It loads a rotable definition into the usual lua table. */ +SWIGINTERN void SWIG_Lua_elua_emulate_register(lua_State *L, const swig_elua_entry *table) +{ + int i, table_parsed, parsed_tables_array, target_table; + assert(lua_istable(L,-1)); + target_table = lua_gettop(L); + /* Get the registry where we put all parsed tables to avoid loops */ + lua_rawgetp(L, LUA_REGISTRYINDEX, &swig_lua_elua_emulate_unique_key); + if(lua_isnil(L,-1)) { + lua_pop(L,1); + lua_newtable(L); + lua_pushvalue(L,-1); + lua_rawsetp(L,LUA_REGISTRYINDEX,(void*)(&swig_lua_elua_emulate_unique_key)); + } + parsed_tables_array = lua_gettop(L); + lua_pushvalue(L,target_table); + lua_rawsetp(L, parsed_tables_array, table); + table_parsed = 0; + const int SWIGUNUSED pairs_start = lua_gettop(L); + for(i = 0;table[i].key.type != LUA_TNIL || table[i].value.type != LUA_TNIL;i++) + { + const swig_elua_entry *entry = table + i; + int is_metatable = 0; + switch(entry->key.type) { + case LUA_TSTRING: + lua_pushstring(L,entry->key.key.strkey); + if(strcmp(entry->key.key.strkey, SWIG_LUA_ELUA_EMUL_METATABLE_KEY) == 0) + is_metatable = 1; + break; + case LUA_TNUMBER: + lua_pushnumber(L,entry->key.key.numkey); + break; + case LUA_TNIL: + lua_pushnil(L); + break; + default: + assert(0); + } + switch(entry->value.type) { + case LUA_TSTRING: + lua_pushstring(L,entry->value.value.string); + break; + case LUA_TNUMBER: + lua_pushnumber(L,entry->value.value.number); + break; + case LUA_TFUNCTION: + lua_pushcfunction(L,entry->value.value.function); + break; + case LUA_TTABLE: + lua_rawgetp(L,parsed_tables_array, entry->value.value.table); + table_parsed = !lua_isnil(L,-1); + if(!table_parsed) { + lua_pop(L,1); /*remove nil */ + lua_newtable(L); + SWIG_Lua_elua_emulate_register(L,entry->value.value.table); + } + if(is_metatable) { + assert(lua_istable(L,-1)); + lua_pushvalue(L,-1); + lua_setmetatable(L,target_table); + } + + break; + case LUA_TUSERDATA: + if(entry->value.value.userdata.member) + SWIG_NewMemberObj(L,entry->value.value.userdata.pvalue, + entry->value.value.userdata.lvalue, + *(entry->value.value.userdata.ptype)); + else + SWIG_NewPointerObj(L,entry->value.value.userdata.pvalue, + *(entry->value.value.userdata.ptype),0); + break; + case LUA_TNIL: + lua_pushnil(L); + break; + default: + assert(0); + } + assert(lua_gettop(L) == pairs_start + 2); + lua_rawset(L,target_table); + } + lua_pop(L,1); /* Removing parsed tables storage */ + assert(lua_gettop(L) == target_table); +} + +SWIGINTERN void SWIG_Lua_elua_emulate_register_clear(lua_State *L) +{ + lua_pushnil(L); + lua_rawsetp(L, LUA_REGISTRYINDEX, &swig_lua_elua_emulate_unique_key); +} + +SWIGINTERN void SWIG_Lua_get_class_registry(lua_State *L); + +SWIGINTERN int SWIG_Lua_emulate_elua_getmetatable(lua_State *L) +{ + SWIG_check_num_args("getmetatable(SWIG eLua emulation)", 1, 1); + SWIG_Lua_get_class_registry(L); + lua_getfield(L,-1,"lua_getmetatable"); + lua_remove(L,-2); /* remove the registry*/ + assert(!lua_isnil(L,-1)); + lua_pushvalue(L,1); + assert(lua_gettop(L) == 3); /* object | function | object again */ + lua_call(L,1,1); + if(!lua_isnil(L,-1)) /*There is an ordinary metatable */ + return 1; + /*if it is a table, then emulate elua behaviour - check for __metatable attribute of a table*/ + assert(lua_gettop(L) == 2); + if(lua_istable(L,-2)) { + lua_pop(L,1); /*remove the nil*/ + lua_getfield(L,-1, SWIG_LUA_ELUA_EMUL_METATABLE_KEY); + } + assert(lua_gettop(L) == 2); + return 1; + +fail: + lua_error(L); + return 0; +} + +SWIGINTERN void SWIG_Lua_emulate_elua_swap_getmetatable(lua_State *L) +{ + SWIG_Lua_get_class_registry(L); + lua_pushglobaltable(L); + lua_pushstring(L,"lua_getmetatable"); + lua_getfield(L,-2,"getmetatable"); + assert(!lua_isnil(L,-1)); + lua_rawset(L,-4); + lua_pushstring(L, "getmetatable"); + lua_pushcfunction(L, SWIG_Lua_emulate_elua_getmetatable); + lua_rawset(L,-3); + lua_pop(L,2); + +} +/* END OF REMOVE */ + +#endif +/* ----------------------------------------------------------------------------- + * global variable support code: namespaces and modules (which are the same thing) + * ----------------------------------------------------------------------------- */ + +SWIGINTERN int SWIG_Lua_namespace_get(lua_State *L) +{ +/* there should be 2 params passed in + (1) table (not the meta table) + (2) string name of the attribute +*/ + assert(lua_istable(L,-2)); /* just in case */ + lua_getmetatable(L,-2); + assert(lua_istable(L,-1)); + SWIG_Lua_get_table(L,".get"); /* find the .get table */ + assert(lua_istable(L,-1)); + /* look for the key in the .get table */ + lua_pushvalue(L,2); /* key */ + lua_rawget(L,-2); + lua_remove(L,-2); /* stack tidy, remove .get table */ + if (lua_iscfunction(L,-1)) + { /* found it so call the fn & return its value */ + lua_call(L,0,1); /* 1 value in (userdata),1 out (result) */ + lua_remove(L,-2); /* stack tidy, remove metatable */ + return 1; + } + lua_pop(L,1); /* remove whatever was there */ + /* ok, so try the .fn table */ + SWIG_Lua_get_table(L,".fn"); /* find the .get table */ + assert(lua_istable(L,-1)); /* just in case */ + lua_pushvalue(L,2); /* key */ + lua_rawget(L,-2); /* look for the fn */ + lua_remove(L,-2); /* stack tidy, remove .fn table */ + if (lua_isfunction(L,-1)) /* note: whether it's a C function or lua function */ + { /* found it so return the fn & let lua call it */ + lua_remove(L,-2); /* stack tidy, remove metatable */ + return 1; + } + lua_pop(L,1); /* remove whatever was there */ + return 0; +} + +SWIGINTERN int SWIG_Lua_namespace_set(lua_State *L) +{ +/* there should be 3 params passed in + (1) table (not the meta table) + (2) string name of the attribute + (3) any for the new value +*/ + + assert(lua_istable(L,1)); + lua_getmetatable(L,1); /* get the meta table */ + assert(lua_istable(L,-1)); + + SWIG_Lua_get_table(L,".set"); /* find the .set table */ + if (lua_istable(L,-1)) + { + /* look for the key in the .set table */ + lua_pushvalue(L,2); /* key */ + lua_rawget(L,-2); + if (lua_iscfunction(L,-1)) + { /* found it so call the fn & return its value */ + lua_pushvalue(L,3); /* value */ + lua_call(L,1,0); + return 0; + } + lua_pop(L,1); /* remove the value */ + } + lua_pop(L,1); /* remove the value .set table */ + lua_pop(L,1); /* remote metatable */ + lua_rawset(L,-3); + return 0; +} + +#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) /* In elua this is useless */ +SWIGINTERN void SWIG_Lua_InstallConstants(lua_State *L, swig_lua_const_info constants[]); /* forward declaration */ +SWIGINTERN void SWIG_Lua_add_variable(lua_State *L,const char *name,lua_CFunction getFn,lua_CFunction setFn); /* forward declaration */ +SWIGINTERN void SWIG_Lua_class_register(lua_State *L,swig_lua_class *clss); + +/* helper function - register namespace methods and attributes into namespace */ +SWIGINTERN int SWIG_Lua_add_namespace_details(lua_State *L, swig_lua_namespace *ns) +{ + int i; + /* There must be namespace table (not metatable) at the top of the stack */ + assert(lua_istable(L,-1)); + SWIG_Lua_InstallConstants(L, ns->ns_constants); + + /* add methods to the namespace/module table */ + for(i=0;ns->ns_methods[i].name;i++){ + SWIG_Lua_add_function(L,ns->ns_methods[i].name,ns->ns_methods[i].func); + } + lua_getmetatable(L,-1); + + /* add fns */ + for(i=0;ns->ns_attributes[i].name;i++){ + SWIG_Lua_add_variable(L,ns->ns_attributes[i].name,ns->ns_attributes[i].getmethod,ns->ns_attributes[i].setmethod); + } + + /* clear stack - remove metatble */ + lua_pop(L,1); + return 0; +} + +/* Register all classes in the namespace */ +SWIGINTERN void SWIG_Lua_add_namespace_classes(lua_State *L, swig_lua_namespace *ns) +{ + swig_lua_class **classes; + + /* There must be a module/namespace table at the top of the stack */ + assert(lua_istable(L,-1)); + + classes = ns->ns_classes; + + if( classes != 0 ) { + while(*classes != 0) { + SWIG_Lua_class_register(L, *classes); + classes++; + } + } +} + +/* Helper function. Creates namespace table and adds it to module table + if 'reg' is true, then will register namespace table to parent one (must be on top of the stack + when function is called). + Function always returns newly registered table on top of the stack. +*/ +SWIGINTERN void SWIG_Lua_namespace_register(lua_State *L, swig_lua_namespace *ns, int reg) +{ + swig_lua_namespace **sub_namespace; + /* 1 argument - table on the top of the stack */ + const int SWIGUNUSED begin = lua_gettop(L); + assert(lua_istable(L,-1)); /* just in case. This is supposed to be module table or parent namespace table */ + lua_checkstack(L,5); + lua_newtable(L); /* namespace itself */ + lua_newtable(L); /* metatable for namespace */ + + /* add a table called ".get" */ + lua_pushstring(L,".get"); + lua_newtable(L); + lua_rawset(L,-3); + /* add a table called ".set" */ + lua_pushstring(L,".set"); + lua_newtable(L); + lua_rawset(L,-3); + /* add a table called ".fn" */ + lua_pushstring(L,".fn"); + lua_newtable(L); + lua_rawset(L,-3); + + /* add accessor fns for using the .get,.set&.fn */ + SWIG_Lua_add_function(L,"__index",SWIG_Lua_namespace_get); + SWIG_Lua_add_function(L,"__newindex",SWIG_Lua_namespace_set); + + lua_setmetatable(L,-2); /* set metatable */ + + /* Register all functions, variables etc */ + SWIG_Lua_add_namespace_details(L,ns); + /* Register classes */ + SWIG_Lua_add_namespace_classes(L,ns); + + sub_namespace = ns->ns_namespaces; + if( sub_namespace != 0) { + while(*sub_namespace != 0) { + SWIG_Lua_namespace_register(L, *sub_namespace, 1); + lua_pop(L,1); /* removing sub-namespace table */ + sub_namespace++; + } + } + + if (reg) { + lua_pushstring(L,ns->name); + lua_pushvalue(L,-2); + lua_rawset(L,-4); /* add namespace to module table */ + } + assert(lua_gettop(L) == begin+1); +} +#endif /* SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA */ + +/* ----------------------------------------------------------------------------- + * global variable support code: classes + * ----------------------------------------------------------------------------- */ + +SWIGINTERN void SWIG_Lua_get_class_metatable(lua_State *L,const char *cname); + +typedef int (*swig_lua_base_iterator_func)(lua_State*,swig_type_info*, int, int *ret); + +SWIGINTERN int SWIG_Lua_iterate_bases(lua_State *L, swig_type_info * SWIGUNUSED swig_type, + int first_arg, swig_lua_base_iterator_func func, int *const ret) +{ + /* first_arg - position of the object in stack. Everything that is above are arguments + * and is passed to every evocation of the func */ + int last_arg = lua_gettop(L);/* position of last argument */ + int original_metatable = last_arg + 1; + size_t bases_count; + int result = SWIG_ERROR; + int bases_table; + (void)swig_type; + lua_getmetatable(L,first_arg); + + /* initialise base search */ +#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) + SWIG_Lua_get_table(L,".bases"); + assert(lua_istable(L,-1)); + bases_count = lua_rawlen(L,-1); + bases_table = lua_gettop(L); +#else + /* In elua .bases table doesn't exist. Use table from swig_lua_class */ + (void)bases_table; + assert(swig_type!=0); + swig_module_info *module=SWIG_GetModule(L); + swig_lua_class **bases= ((swig_lua_class*)(swig_type->clientdata))->bases; + const char **base_names= ((swig_lua_class*)(swig_type->clientdata))->base_names; + bases_count = 0; + for(;base_names[bases_count]; + bases_count++);/* get length of bases */ +#endif + + if(ret) + *ret = 0; + if(bases_count>0) + { + int to_remove; + size_t i; + int j; + int subcall_last_arg; + int subcall_first_arg = lua_gettop(L) + 1;/* Here a copy of first_arg and arguments begin */ + int valid = 1; + swig_type_info *base_swig_type = 0; + for(j=first_arg;j<=last_arg;j++) + lua_pushvalue(L,j); + subcall_last_arg = lua_gettop(L); + + /* Trick: temporarily replacing original metatable with metatable for base class and call getter */ + for(i=0;i<bases_count;i++) { + /* Iteration through class bases */ +#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) + lua_rawgeti(L,bases_table,i+1); + base_swig_type = 0; + if(lua_isnil(L,-1)) { + valid = 0; + lua_pop(L,1); + } else { + valid = 1; + } +#else /* In elua .bases table doesn't exist. Use table from swig_lua_class */ + swig_lua_class *base_class = bases[i]; + if(!base_class) { + valid = 0; + } else { + valid = 1; + SWIG_Lua_get_class_metatable(L,base_class->fqname); + base_swig_type = SWIG_TypeQueryModule(module,module,base_names[i]); + assert(base_swig_type != 0); + } +#endif + + if(!valid) + continue; + assert(lua_isuserdata(L, subcall_first_arg)); + assert(lua_istable(L,-1)); + lua_setmetatable(L,subcall_first_arg); /* Set new metatable */ + assert(lua_gettop(L) == subcall_last_arg); + result = func(L, base_swig_type,subcall_first_arg, ret); /* Forward call */ + if(result != SWIG_ERROR) { + break; + } + } + /* Restore original metatable */ + lua_pushvalue(L,original_metatable); + lua_setmetatable(L,first_arg); + /* Clear - remove everything between last_arg and subcall_last_arg including */ + to_remove = subcall_last_arg - last_arg; + for(j=0;j<to_remove;j++) + lua_remove(L,last_arg+1); + } else { + /* Remove everything after last_arg */ + lua_pop(L, lua_gettop(L) - last_arg); + } + if(ret) assert(lua_gettop(L) == last_arg + *ret); + return result; +} + +/* The class.get method helper, performs the lookup of class attributes. + * It returns an error code. Number of function return values is passed inside 'ret'. + * first_arg is not used in this function because function always has 2 arguments. + */ +SWIGINTERN int SWIG_Lua_class_do_get_item(lua_State *L, swig_type_info *type, int SWIGUNUSED first_arg, int *ret) +{ +/* there should be 2 params passed in + (1) userdata (not the meta table) + (2) string name of the attribute +*/ + int bases_search_result; + int substack_start = lua_gettop(L)-2; + assert(first_arg == substack_start+1); + (void)first_arg; + lua_checkstack(L,5); + assert(lua_isuserdata(L,-2)); /* just in case */ + lua_getmetatable(L,-2); /* get the meta table */ + assert(lua_istable(L,-1)); /* just in case */ + /* NEW: looks for the __getitem() fn + this is a user provided get fn */ + SWIG_Lua_get_table(L,"__getitem"); /* find the __getitem fn */ + if (lua_iscfunction(L,-1)) /* if it's there */ + { /* found it so call the fn & return its value */ + lua_pushvalue(L,substack_start+1); /* the userdata */ + lua_pushvalue(L,substack_start+2); /* the parameter */ + lua_call(L,2,1); /* 2 value in (userdata),1 out (result) */ + lua_remove(L,-2); /* stack tidy, remove metatable */ + if(ret) *ret = 1; + return SWIG_OK; + } + lua_pop(L,1); + /* Remove the metatable */ + lua_pop(L,1); + /* Search in base classes */ + bases_search_result = SWIG_Lua_iterate_bases(L,type,substack_start+1,SWIG_Lua_class_do_get_item,ret); + return bases_search_result; /* sorry not known */ +} + + +/* The class.get method helper, performs the lookup of class attributes. + * It returns an error code. Number of function return values is passed inside 'ret'. + * first_arg is not used in this function because function always has 2 arguments. + */ +SWIGINTERN int SWIG_Lua_class_do_get(lua_State *L, swig_type_info *type, int SWIGUNUSED first_arg, int *ret) +{ +/* there should be 2 params passed in + (1) userdata (not the meta table) + (2) string name of the attribute +*/ + int bases_search_result; + int substack_start = lua_gettop(L)-2; + assert(first_arg == substack_start+1); + (void)first_arg; + lua_checkstack(L,5); + assert(lua_isuserdata(L,-2)); /* just in case */ + lua_getmetatable(L,-2); /* get the meta table */ + assert(lua_istable(L,-1)); /* just in case */ + SWIG_Lua_get_table(L,".get"); /* find the .get table */ + assert(lua_istable(L,-1)); /* just in case */ + /* look for the key in the .get table */ + lua_pushvalue(L,substack_start+2); /* key */ + lua_rawget(L,-2); + lua_remove(L,-2); /* stack tidy, remove .get table */ + if (lua_iscfunction(L,-1)) + { /* found it so call the fn & return its value */ + lua_pushvalue(L,substack_start+1); /* the userdata */ + lua_call(L,1,1); /* 1 value in (userdata),1 out (result) */ + lua_remove(L,-2); /* stack tidy, remove metatable */ + if(ret) + *ret = 1; + return SWIG_OK; + } + lua_pop(L,1); /* remove whatever was there */ + /* ok, so try the .fn table */ + SWIG_Lua_get_table(L,".fn"); /* find the .fn table */ + assert(lua_istable(L,-1)); /* just in case */ + lua_pushvalue(L,substack_start+2); /* key */ + lua_rawget(L,-2); /* look for the fn */ + lua_remove(L,-2); /* stack tidy, remove .fn table */ + if (lua_isfunction(L,-1)) /* note: if it's a C function or lua function */ + { /* found it so return the fn & let lua call it */ + lua_remove(L,-2); /* stack tidy, remove metatable */ + if(ret) + *ret = 1; + return SWIG_OK; + } + lua_pop(L,1); /* remove whatever was there */ + /* Remove the metatable */ + lua_pop(L,1); + /* Search in base classes */ + bases_search_result = SWIG_Lua_iterate_bases(L,type,substack_start+1,SWIG_Lua_class_do_get,ret); + return bases_search_result; /* sorry not known */ +} + +/* the class.get method, performs the lookup of class attributes + */ +SWIGINTERN int SWIG_Lua_class_get(lua_State *L) +{ +/* there should be 2 params passed in + (1) userdata (not the meta table) + (2) string name of the attribute +*/ + int result; + swig_lua_userdata *usr; + swig_type_info *type; + int ret = 0; + assert(lua_isuserdata(L,1)); + usr=(swig_lua_userdata*)lua_touserdata(L,1); /* get data */ + type = usr->type; + result = SWIG_Lua_class_do_get(L,type,1,&ret); + if(result == SWIG_OK) + return ret; + + result = SWIG_Lua_class_do_get_item(L,type,1,&ret); + if(result == SWIG_OK) + return ret; + + return 0; +} + +/* helper for the class.set method, performs the lookup of class attributes + * It returns error code. Number of function return values is passed inside 'ret' + */ +SWIGINTERN int SWIG_Lua_class_do_set(lua_State *L, swig_type_info *type, int first_arg, int *ret) +{ +/* there should be 3 params passed in + (1) table (not the meta table) + (2) string name of the attribute + (3) any for the new value + */ + + int bases_search_result; + int substack_start = lua_gettop(L) - 3; + lua_checkstack(L,5); + assert(lua_isuserdata(L,substack_start+1)); /* just in case */ + lua_getmetatable(L,substack_start+1); /* get the meta table */ + assert(lua_istable(L,-1)); /* just in case */ + if(ret) + *ret = 0; /* it is setter - number of return values is always 0 */ + + SWIG_Lua_get_table(L,".set"); /* find the .set table */ + if (lua_istable(L,-1)) + { + /* look for the key in the .set table */ + lua_pushvalue(L,substack_start+2); /* key */ + lua_rawget(L,-2); + lua_remove(L,-2); /* tidy stack, remove .set table */ + if (lua_iscfunction(L,-1)) + { /* found it so call the fn & return its value */ + lua_pushvalue(L,substack_start+1); /* userdata */ + lua_pushvalue(L,substack_start+3); /* value */ + lua_call(L,2,0); + lua_remove(L,substack_start+4); /*remove metatable*/ + return SWIG_OK; + } + lua_pop(L,1); /* remove the value */ + } else { + lua_pop(L,1); /* remove the answer for .set table request*/ + } + /* NEW: looks for the __setitem() fn + this is a user provided set fn */ + SWIG_Lua_get_table(L,"__setitem"); /* find the fn */ + if (lua_iscfunction(L,-1)) /* if it's there */ + { /* found it so call the fn & return its value */ + lua_pushvalue(L,substack_start+1); /* the userdata */ + lua_pushvalue(L,substack_start+2); /* the parameter */ + lua_pushvalue(L,substack_start+3); /* the value */ + lua_call(L,3,0); /* 3 values in ,0 out */ + lua_remove(L,-2); /* stack tidy, remove metatable */ + return SWIG_OK; + } + lua_pop(L,1); /* remove value */ + + lua_pop(L,1); /* remove metatable */ + /* Search among bases */ + bases_search_result = SWIG_Lua_iterate_bases(L,type,first_arg,SWIG_Lua_class_do_set,ret); + if(ret) + assert(*ret == 0); + assert(lua_gettop(L) == substack_start + 3); + return bases_search_result; +} + +/* This is the actual method exported to Lua. It calls SWIG_Lua_class_do_set and correctly + * handles return values. + */ +SWIGINTERN int SWIG_Lua_class_set(lua_State *L) +{ +/* There should be 3 params passed in + (1) table (not the meta table) + (2) string name of the attribute + (3) any for the new value + */ + int ret = 0; + int result; + swig_lua_userdata *usr; + swig_type_info *type; + assert(lua_isuserdata(L,1)); + usr=(swig_lua_userdata*)lua_touserdata(L,1); /* get data */ + type = usr->type; + result = SWIG_Lua_class_do_set(L,type,1,&ret); + if(result != SWIG_OK) { + SWIG_Lua_pushferrstring(L,"Assignment not possible. No setter/member with this name. For custom assignments implement __setitem method."); + lua_error(L); + } else { + assert(ret==0); + } + return 0; +} + +/* the class.destruct method called by the interpreter */ +SWIGINTERN int SWIG_Lua_class_destruct(lua_State *L) +{ +/* there should be 1 params passed in + (1) userdata (not the meta table) */ + swig_lua_userdata *usr; + swig_lua_class *clss; + assert(lua_isuserdata(L,-1)); /* just in case */ + usr=(swig_lua_userdata*)lua_touserdata(L,-1); /* get it */ + /* if must be destroyed & has a destructor */ + if (usr->own) /* if must be destroyed */ + { + clss=(swig_lua_class*)usr->type->clientdata; /* get the class */ + if (clss && clss->destructor) /* there is a destroy fn */ + { + clss->destructor(usr->ptr); /* bye bye */ + } + } + return 0; +} + +/* the class.__tostring method called by the interpreter and print */ +SWIGINTERN int SWIG_Lua_class_tostring(lua_State *L) +{ +/* there should be 1 param passed in + (1) userdata (not the metatable) */ + swig_lua_userdata* userData; + assert(lua_isuserdata(L,1)); /* just in case */ + userData = (swig_lua_userdata*)lua_touserdata(L,1); /* get the userdata address */ + + lua_pushfstring(L, "<userdata of type '%s' at %p>", userData->type->str, userData->ptr); + return 1; +} + +/* to manually disown some userdata */ +SWIGINTERN int SWIG_Lua_class_disown(lua_State *L) +{ +/* there should be 1 params passed in + (1) userdata (not the meta table) */ + swig_lua_userdata *usr; + assert(lua_isuserdata(L,-1)); /* just in case */ + usr=(swig_lua_userdata*)lua_touserdata(L,-1); /* get it */ + + usr->own = 0; /* clear our ownership */ + return 0; +} + +/* lua callable function to compare userdata's value +the issue is that two userdata may point to the same thing +but to lua, they are different objects */ +SWIGRUNTIME int SWIG_Lua_class_equal(lua_State *L) +{ + int result; + swig_lua_userdata *usr1,*usr2; + if (!lua_isuserdata(L,1) || !lua_isuserdata(L,2)) /* just in case */ + return 0; /* nil reply */ + usr1=(swig_lua_userdata*)lua_touserdata(L,1); /* get data */ + usr2=(swig_lua_userdata*)lua_touserdata(L,2); /* get data */ + /*result=(usr1->ptr==usr2->ptr && usr1->type==usr2->type); only works if type is the same*/ + result=(usr1->ptr==usr2->ptr); + lua_pushboolean(L,result); + return 1; +} + +/* populate table at the top of the stack with metamethods that ought to be inherited */ +SWIGINTERN void SWIG_Lua_populate_inheritable_metamethods(lua_State *L) +{ + SWIG_Lua_add_boolean(L, "__add", 1); + SWIG_Lua_add_boolean(L, "__sub", 1); + SWIG_Lua_add_boolean(L, "__mul", 1); + SWIG_Lua_add_boolean(L, "__div", 1); + SWIG_Lua_add_boolean(L, "__mod", 1); + SWIG_Lua_add_boolean(L, "__pow", 1); + SWIG_Lua_add_boolean(L, "__unm", 1); + SWIG_Lua_add_boolean(L, "__len", 1 ); + SWIG_Lua_add_boolean(L, "__concat", 1 ); + SWIG_Lua_add_boolean(L, "__eq", 1); + SWIG_Lua_add_boolean(L, "__lt", 1); + SWIG_Lua_add_boolean(L, "__le", 1); + SWIG_Lua_add_boolean(L, "__call", 1); + SWIG_Lua_add_boolean(L, "__tostring", 1); + SWIG_Lua_add_boolean(L, "__gc", 0); +} + +/* creates the swig registry */ +SWIGINTERN void SWIG_Lua_create_class_registry(lua_State *L) +{ + /* create main SWIG registry table */ + lua_pushstring(L,"SWIG"); + lua_newtable(L); + /* populate it with some predefined data */ + + /* .library table. Placeholder */ + lua_pushstring(L,".library"); + lua_newtable(L); + { + /* list of metamethods that class inherits from its bases */ + lua_pushstring(L,"inheritable_metamethods"); + lua_newtable(L); + /* populate with list of metamethods */ + SWIG_Lua_populate_inheritable_metamethods(L); + lua_rawset(L,-3); + } + lua_rawset(L,-3); + + lua_rawset(L,LUA_REGISTRYINDEX); +} + +/* gets the swig registry (or creates it) */ +SWIGINTERN void SWIG_Lua_get_class_registry(lua_State *L) +{ + /* add this all into the swig registry: */ + lua_pushstring(L,"SWIG"); + lua_rawget(L,LUA_REGISTRYINDEX); /* get the registry */ + if (!lua_istable(L,-1)) /* not there */ + { /* must be first time, so add it */ + lua_pop(L,1); /* remove the result */ + SWIG_Lua_create_class_registry(L); + /* then get it */ + lua_pushstring(L,"SWIG"); + lua_rawget(L,LUA_REGISTRYINDEX); + } +} + +SWIGINTERN void SWIG_Lua_get_inheritable_metamethods(lua_State *L) +{ + SWIG_Lua_get_class_registry(L); + lua_pushstring(L, ".library"); + lua_rawget(L,-2); + assert( !lua_isnil(L,-1) ); + lua_pushstring(L, "inheritable_metamethods"); + lua_rawget(L,-2); + + /* Remove class registry and library table */ + lua_remove(L,-2); + lua_remove(L,-2); +} + +/* Helper function to get the classes metatable from the register */ +SWIGINTERN void SWIG_Lua_get_class_metatable(lua_State *L,const char *cname) +{ + SWIG_Lua_get_class_registry(L); /* get the registry */ + lua_pushstring(L,cname); /* get the name */ + lua_rawget(L,-2); /* get it */ + lua_remove(L,-2); /* tidy up (remove registry) */ +} + +/* Set up the base classes pointers. +Each class structure has a list of pointers to the base class structures. +This function fills them. +It cannot be done at compile time, as this will not work with hireachies +spread over more than one swig file. +Therefore it must be done at runtime, querying the SWIG type system. +*/ +SWIGINTERN void SWIG_Lua_init_base_class(lua_State *L,swig_lua_class *clss) +{ + int i=0; + swig_module_info *module=SWIG_GetModule(L); + for(i=0;clss->base_names[i];i++) + { + if (clss->bases[i]==0) /* not found yet */ + { + /* lookup and cache the base class */ + swig_type_info *info = SWIG_TypeQueryModule(module,module,clss->base_names[i]); + if (info) clss->bases[i] = (swig_lua_class *) info->clientdata; + } + } +} + +#if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) +/* Merges two tables */ +SWIGINTERN void SWIG_Lua_merge_tables_by_index(lua_State *L, int target, int source) +{ + /* iterating */ + lua_pushnil(L); + while (lua_next(L,source) != 0) { + /* -1 - value, -2 - index */ + /* have to copy to assign */ + lua_pushvalue(L,-2); /* copy of index */ + lua_pushvalue(L,-2); /* copy of value */ + lua_rawset(L, target); + lua_pop(L,1); + /* only key is left */ + } +} + +/* Merges two tables with given name. original - index of target metatable, base - index of source metatable */ +SWIGINTERN void SWIG_Lua_merge_tables(lua_State *L, const char* name, int original, int base) +{ + /* push original[name], then base[name] */ + lua_pushstring(L,name); + lua_rawget(L,original); + int original_table = lua_gettop(L); + lua_pushstring(L,name); + lua_rawget(L,base); + int base_table = lua_gettop(L); + SWIG_Lua_merge_tables_by_index(L, original_table, base_table); + /* clearing stack */ + lua_pop(L,2); +} + +/* Function takes all symbols from base and adds it to derived class. It's just a helper. */ +SWIGINTERN void SWIG_Lua_class_squash_base(lua_State *L, swig_lua_class *base_cls) +{ + /* There is one parameter - original, i.e. 'derived' class metatable */ + assert(lua_istable(L,-1)); + int original = lua_gettop(L); + SWIG_Lua_get_class_metatable(L,base_cls->fqname); + int base = lua_gettop(L); + SWIG_Lua_merge_tables(L, ".fn", original, base ); + SWIG_Lua_merge_tables(L, ".set", original, base ); + SWIG_Lua_merge_tables(L, ".get", original, base ); + lua_pop(L,1); +} + +/* Function squashes all symbols from 'clss' bases into itself */ +SWIGINTERN void SWIG_Lua_class_squash_bases(lua_State *L, swig_lua_class *clss) +{ + int i; + SWIG_Lua_get_class_metatable(L,clss->fqname); + for(i=0;clss->base_names[i];i++) + { + if (clss->bases[i]==0) /* Somehow it's not found. Skip it */ + continue; + /* Thing is: all bases are already registered. Thus they have already executed + * this function. So we just need to squash them into us, because their bases + * are already squashed into them. No need for recursion here! + */ + SWIG_Lua_class_squash_base(L, clss->bases[i]); + } + lua_pop(L,1); /*tidy stack*/ +} +#endif + +#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) /* In elua this is useless */ +/* helper add a variable to a registered class */ +SWIGINTERN void SWIG_Lua_add_variable(lua_State *L,const char *name,lua_CFunction getFn,lua_CFunction setFn) +{ + assert(lua_istable(L,-1)); /* just in case */ + SWIG_Lua_get_table(L,".get"); /* find the .get table */ + assert(lua_istable(L,-1)); /* just in case */ + SWIG_Lua_add_function(L,name,getFn); + lua_pop(L,1); /* tidy stack (remove table) */ + if (setFn) + { + SWIG_Lua_get_table(L,".set"); /* find the .set table */ + assert(lua_istable(L,-1)); /* just in case */ + SWIG_Lua_add_function(L,name,setFn); + lua_pop(L,1); /* tidy stack (remove table) */ + } +} + +/* helper to recursively add class static details (static attributes, operations and constants) */ +SWIGINTERN void SWIG_Lua_add_class_static_details(lua_State *L, swig_lua_class *clss) +{ + int i = 0; + /* The class namespace table must be on the top of the stack */ + assert(lua_istable(L,-1)); + /* call all the base classes first: we can then override these later: */ + for(i=0;clss->bases[i];i++) + { + SWIG_Lua_add_class_static_details(L,clss->bases[i]); + } + + SWIG_Lua_add_namespace_details(L, clss->cls_static); +} + +SWIGINTERN void SWIG_Lua_add_class_user_metamethods(lua_State *L, swig_lua_class *clss); /* forward declaration */ + +/* helper to recursively add class details (attributes & operations) */ +SWIGINTERN void SWIG_Lua_add_class_instance_details(lua_State *L, swig_lua_class *clss) +{ + int i; + size_t bases_count = 0; + /* Add bases to .bases table */ + SWIG_Lua_get_table(L,".bases"); + assert(lua_istable(L,-1)); /* just in case */ + for(i=0;clss->bases[i];i++) + { + SWIG_Lua_get_class_metatable(L,clss->bases[i]->fqname); + /* Base class must be already registered */ + assert(lua_istable(L,-1)); + lua_rawseti(L,-2,i+1); /* In lua indexing starts from 1 */ + bases_count++; + } + assert(lua_rawlen(L,-1) == bases_count); + lua_pop(L,1); /* remove .bases table */ + /* add attributes */ + for(i=0;clss->attributes[i].name;i++){ + SWIG_Lua_add_variable(L,clss->attributes[i].name,clss->attributes[i].getmethod,clss->attributes[i].setmethod); + } + /* add methods to the metatable */ + SWIG_Lua_get_table(L,".fn"); /* find the .fn table */ + assert(lua_istable(L,-1)); /* just in case */ + for(i=0;clss->methods[i].name;i++){ + SWIG_Lua_add_function(L,clss->methods[i].name,clss->methods[i].func); + } + lua_pop(L,1); /* tidy stack (remove table) */ + /* add operator overloads + This adds methods from metatable array to metatable. Can mess up garbage + collectind if someone defines __gc method + */ + if(clss->metatable) { + for(i=0;clss->metatable[i].name;i++) { + SWIG_Lua_add_function(L,clss->metatable[i].name,clss->metatable[i].func); + } + } + +#if !defined(SWIG_LUA_SQUASH_BASES) + /* Adding metamethods that are defined in base classes. If bases were squashed + * then it is obviously unnecessary + */ + SWIG_Lua_add_class_user_metamethods(L, clss); +#endif +} + +/* Helpers to add user defined class metamedhods - __add, __sub etc. The helpers are needed + for the following issue: Lua runtime checks for metamethod existence with rawget function + ignoring our SWIG-provided __index and __newindex functions. Thus our inheritance-aware method + search algorithm doesn't work in such case. (Not to say that Lua runtime queries metamethod directly + in metatable and not in object). + Current solution is this: if somewhere in hierarchy metamethod __x is defined, then all descendants + are automatically given a special proxy __x that calls the real __x method. + Obvious idea - to copy __x instead of creating __x-proxy is wrong because if someone changes __x in runtime, + those changes must be reflected in all descendants. +*/ + +SWIGRUNTIME int SWIG_Lua_resolve_metamethod(lua_State *L); /*forward declaration*/ + +/* The real function that resolves a metamethod. + * Function searches given class and all its bases (recursively) for first instance of something that is + * not equal to SWIG_Lua_resolve_metamethod. (Almost always this 'something' is actual metamethod implementation + * and it is a SWIG-generated C function.). It returns value on the top of the L and there is no garbage below the + * answer. + * Returns 1 if found, 0 otherwise. + * clss is class which metatable we will search for method + * metamethod_name_idx is index in L where metamethod name (as string) lies + * skip_check allows skipping searching metamethod in the given class and immediately going to searching in bases. skip_check + * is not carried to subsequent recursive calls - false is always passed. It is set to true only at first call from + * SWIG_Lua_resolve_metamethod + * */ +SWIGINTERN int SWIG_Lua_do_resolve_metamethod(lua_State *L, const swig_lua_class *clss, int metamethod_name_idx, + int skip_check) +{ + /* This function is called recursively */ + int result = 0; + int i = 0; + + if (!skip_check) { + SWIG_Lua_get_class_metatable(L, clss->fqname); + lua_pushvalue(L, metamethod_name_idx); + lua_rawget(L,-2); + /* If this is cfunction and it is equal to SWIG_Lua_resolve_metamethod then + * this isn't the function we are looking for :) + * lua_tocfunction will return NULL if not cfunction + */ + if (!lua_isnil(L,-1) && lua_tocfunction(L,-1) != SWIG_Lua_resolve_metamethod ) { + lua_remove(L,-2); /* removing class metatable */ + return 1; + } + lua_pop(L,2); /* remove class metatable and query result */ + } + + /* Forwarding calls to bases */ + for(i=0;clss->bases[i];i++) + { + result = SWIG_Lua_do_resolve_metamethod(L, clss->bases[i], metamethod_name_idx, 0); + if (result) + break; + } + + return result; +} + +/* The proxy function for metamethod. All parameters are passed as cclosure. Searches for actual method + * and calls it */ +SWIGRUNTIME int SWIG_Lua_resolve_metamethod(lua_State *L) +{ + int numargs; + int metamethod_name_idx; + const swig_lua_class* clss; + int result; + + lua_checkstack(L,5); + numargs = lua_gettop(L); /* number of arguments to pass to actual metamethod */ + + /* Get upvalues from closure */ + lua_pushvalue(L, lua_upvalueindex(1)); /*Get function name*/ + metamethod_name_idx = lua_gettop(L); + + lua_pushvalue(L, lua_upvalueindex(2)); + clss = (const swig_lua_class*)(lua_touserdata(L,-1)); + lua_pop(L,1); /* remove lightuserdata with clss from stack */ + + /* Actual work */ + result = SWIG_Lua_do_resolve_metamethod(L, clss, metamethod_name_idx, 1); + if (!result) { + SWIG_Lua_pushferrstring(L,"The metamethod proxy is set, but it failed to find actual metamethod. Memory corruption is most likely explanation."); + lua_error(L); + return 0; + } + + lua_remove(L,-2); /* remove metamethod key */ + lua_insert(L,1); /* move function to correct position */ + lua_call(L, numargs, LUA_MULTRET); + return lua_gettop(L); /* return all results */ +} + + +/* If given metamethod must be present in given class, then creates appropriate proxy + * Returns 1 if successfully added, 0 if not added because no base class has it, -1 + * if method is defined in the class metatable itself + */ +SWIGINTERN int SWIG_Lua_add_class_user_metamethod(lua_State *L, swig_lua_class *clss, const int metatable_index) +{ + int key_index; + int success = 0; + int i = 0; + + /* metamethod name - on the top of the stack */ + assert(lua_isstring(L,-1)); + + key_index = lua_gettop(L); + + /* Check whether method is already defined in metatable */ + lua_pushvalue(L,key_index); /* copy of the key */ + lua_gettable(L,metatable_index); + if( !lua_isnil(L,-1) ) { + lua_pop(L,1); + return -1; + } + lua_pop(L,1); + + /* Iterating over immediate bases */ + for(i=0;clss->bases[i];i++) + { + const swig_lua_class *base = clss->bases[i]; + SWIG_Lua_get_class_metatable(L, base->fqname); + lua_pushvalue(L, key_index); + lua_rawget(L, -2); + if( !lua_isnil(L,-1) ) { + lua_pushvalue(L, key_index); + + /* Add proxy function */ + lua_pushvalue(L, key_index); /* first closure value is function name */ + lua_pushlightuserdata(L, clss); /* second closure value is swig_lua_class structure */ + lua_pushcclosure(L, SWIG_Lua_resolve_metamethod, 2); + + lua_rawset(L, metatable_index); + success = 1; + } + lua_pop(L,1); /* remove function or nil */ + lua_pop(L,1); /* remove base class metatable */ + + if( success ) + break; + } + + return success; +} + +SWIGINTERN void SWIG_Lua_add_class_user_metamethods(lua_State *L, swig_lua_class *clss) +{ + int metatable_index; + int metamethods_info_index; + int tostring_undefined; + int eq_undefined = 0; + + SWIG_Lua_get_class_metatable(L, clss->fqname); + metatable_index = lua_gettop(L); + SWIG_Lua_get_inheritable_metamethods(L); + assert(lua_istable(L,-1)); + metamethods_info_index = lua_gettop(L); + lua_pushnil(L); /* first key */ + while(lua_next(L, metamethods_info_index) != 0 ) { + /* key at index -2, value at index -1 */ + const int is_inheritable = lua_toboolean(L,-2); + lua_pop(L,1); /* remove value - we don't need it anymore */ + + if(is_inheritable) { /* if metamethod is inheritable */ + SWIG_Lua_add_class_user_metamethod(L,clss,metatable_index); + } + } + + lua_pop(L,1); /* remove inheritable metamethods table */ + + /* Special handling for __tostring method */ + lua_pushstring(L, "__tostring"); + lua_pushvalue(L,-1); + lua_rawget(L,metatable_index); + tostring_undefined = lua_isnil(L,-1); + lua_pop(L,1); + if( tostring_undefined ) { + lua_pushcfunction(L, SWIG_Lua_class_tostring); + lua_rawset(L, metatable_index); + } else { + lua_pop(L,1); /* remove copy of the key */ + } + + /* Special handling for __eq method */ + lua_pushstring(L, "__eq"); + lua_pushvalue(L,-1); + lua_rawget(L,metatable_index); + eq_undefined = lua_isnil(L,-1); + lua_pop(L,1); + if( eq_undefined ) { + lua_pushcfunction(L, SWIG_Lua_class_equal); + lua_rawset(L, metatable_index); + } else { + lua_pop(L,1); /* remove copy of the key */ + } + /* Warning: __index and __newindex are SWIG-defined. For user-defined operator[] + * a __getitem/__setitem method should be defined + */ + lua_pop(L,1); /* pop class metatable */ +} + +/* Register class static methods,attributes etc as well as constructor proxy */ +SWIGINTERN void SWIG_Lua_class_register_static(lua_State *L, swig_lua_class *clss) +{ + const int SWIGUNUSED begin = lua_gettop(L); + lua_checkstack(L,5); /* just in case */ + assert(lua_istable(L,-1)); /* just in case */ + assert(strcmp(clss->name, clss->cls_static->name) == 0); /* in class those 2 must be equal */ + + SWIG_Lua_namespace_register(L,clss->cls_static, 1); + + assert(lua_istable(L,-1)); /* just in case */ + + /* add its constructor to module with the name of the class + so you can do MyClass(...) as well as new_MyClass(...) + BUT only if a constructor is defined + (this overcomes the problem of pure virtual classes without constructors)*/ + if (clss->constructor) + { + lua_getmetatable(L,-1); + assert(lua_istable(L,-1)); /* just in case */ + SWIG_Lua_add_function(L,"__call", clss->constructor); + lua_pop(L,1); + } + + assert(lua_istable(L,-1)); /* just in case */ + SWIG_Lua_add_class_static_details(L, clss); + + /* clear stack */ + lua_pop(L,1); + assert( lua_gettop(L) == begin ); +} + +/* Performs the instance (non-static) class registration process. Metatable for class is created + * and added to the class registry. + */ +SWIGINTERN void SWIG_Lua_class_register_instance(lua_State *L,swig_lua_class *clss) +{ + const int SWIGUNUSED begin = lua_gettop(L); + int i; + /* if name already there (class is already registered) then do nothing */ + SWIG_Lua_get_class_registry(L); /* get the registry */ + lua_pushstring(L,clss->fqname); /* get the name */ + lua_rawget(L,-2); + if(!lua_isnil(L,-1)) { + lua_pop(L,2); + assert(lua_gettop(L)==begin); + return; + } + lua_pop(L,2); /* tidy stack */ + /* Recursively initialize all bases */ + for(i=0;clss->bases[i];i++) + { + SWIG_Lua_class_register_instance(L,clss->bases[i]); + } + /* Again, get registry and push name */ + SWIG_Lua_get_class_registry(L); /* get the registry */ + lua_pushstring(L,clss->fqname); /* get the name */ + lua_newtable(L); /* create the metatable */ +#if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) + /* If squashing is requested, then merges all bases metatable into this one. + * It would get us all special methods: __getitem, __add etc. + * This would set .fn, .type, and other .xxx incorrectly, but we will overwrite it right away + */ + { + int new_metatable_index = lua_absindex(L,-1); + for(i=0;clss->bases[i];i++) + { + int base_metatable; + SWIG_Lua_get_class_metatable(L,clss->bases[i]->fqname); + base_metatable = lua_absindex(L,-1); + SWIG_Lua_merge_tables_by_index(L,new_metatable_index, base_metatable); + lua_pop(L,1); + } + } + /* And now we will overwrite all incorrectly set data */ +#endif + /* add string of class name called ".type" */ + lua_pushstring(L,".type"); + lua_pushstring(L,clss->fqname); + lua_rawset(L,-3); + /* add a table called bases */ + lua_pushstring(L,".bases"); + lua_newtable(L); + lua_rawset(L,-3); + /* add a table called ".get" */ + lua_pushstring(L,".get"); + lua_newtable(L); + lua_rawset(L,-3); + /* add a table called ".set" */ + lua_pushstring(L,".set"); + lua_newtable(L); + lua_rawset(L,-3); + /* add a table called ".fn" */ + lua_pushstring(L,".fn"); + lua_newtable(L); + /* add manual disown method */ + SWIG_Lua_add_function(L,"__disown",SWIG_Lua_class_disown); + lua_rawset(L,-3); + /* add accessor fns for using the .get,.set&.fn */ + SWIG_Lua_add_function(L,"__index",SWIG_Lua_class_get); + SWIG_Lua_add_function(L,"__newindex",SWIG_Lua_class_set); + SWIG_Lua_add_function(L,"__gc",SWIG_Lua_class_destruct); + /* add it */ + lua_rawset(L,-3); /* metatable into registry */ + lua_pop(L,1); /* tidy stack (remove registry) */ + assert(lua_gettop(L) == begin); + +#if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) + /* Now merge all symbols from .fn, .set, .get etc from bases to our tables */ + SWIG_Lua_class_squash_bases(L,clss); +#endif + SWIG_Lua_get_class_metatable(L,clss->fqname); + SWIG_Lua_add_class_instance_details(L,clss); /* recursive adding of details (atts & ops) */ + lua_pop(L,1); /* tidy stack (remove class metatable) */ + assert( lua_gettop(L) == begin ); +} + +SWIGINTERN void SWIG_Lua_class_register(lua_State *L,swig_lua_class *clss) +{ + int SWIGUNUSED begin; + assert(lua_istable(L,-1)); /* This is a table (module or namespace) where classes will be added */ + SWIG_Lua_class_register_instance(L,clss); + SWIG_Lua_class_register_static(L,clss); + + /* Add links from static part to instance part and vice versa */ + /* [SWIG registry] [Module] + * "MyClass" ----> [MyClass metatable] <===== "MyClass" -+> [static part] + * ".get" ----> ... | | getmetatable()----| + * ".set" ----> ... | | | + * ".static" --------------)----------------/ [static part metatable] + * | ".get" --> ... + * | ".set" --> .... + * |=============================== ".instance" + */ + begin = lua_gettop(L); + lua_pushstring(L,clss->cls_static->name); + lua_rawget(L,-2); /* get class static table */ + assert(lua_istable(L,-1)); + lua_getmetatable(L,-1); + assert(lua_istable(L,-1)); /* get class static metatable */ + lua_pushstring(L,".instance"); /* prepare key */ + + SWIG_Lua_get_class_metatable(L,clss->fqname); /* get class metatable */ + assert(lua_istable(L,-1)); + lua_pushstring(L,".static"); /* prepare key */ + lua_pushvalue(L, -4); /* push static class TABLE */ + assert(lua_istable(L,-1)); + lua_rawset(L,-3); /* assign static class table(!NOT metatable) as ".static" member of class metatable */ + lua_rawset(L,-3); /* assign class metatable as ".instance" member of class static METATABLE */ + lua_pop(L,2); + assert(lua_gettop(L) == begin); +} +#endif /* SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA */ + +#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) +SWIGINTERN void SWIG_Lua_elua_class_register_instance(lua_State *L, swig_lua_class *clss) +{ + const int SWIGUNUSED begin = lua_gettop(L); + int i; + /* if name already there (class is already registered) then do nothing */ + SWIG_Lua_get_class_registry(L); /* get the registry */ + lua_pushstring(L,clss->fqname); /* get the name */ + lua_rawget(L,-2); + if(!lua_isnil(L,-1)) { + lua_pop(L,2); + assert(lua_gettop(L)==begin); + return; + } + lua_pop(L,2); /* tidy stack */ + /* Recursively initialize all bases */ + for(i=0;clss->bases[i];i++) + { + SWIG_Lua_elua_class_register_instance(L,clss->bases[i]); + } + /* Again, get registry and push name */ + SWIG_Lua_get_class_registry(L); /* get the registry */ + lua_pushstring(L,clss->fqname); /* get the name */ + assert(clss->metatable); + lua_pushrotable(L, (void*)(clss->metatable)); /* create the metatable */ + lua_rawset(L,-3); + lua_pop(L,1); + assert(lua_gettop(L) == begin); +} +#endif /* elua && eluac */ + +/* ----------------------------------------------------------------------------- + * Class/structure conversion fns + * ----------------------------------------------------------------------------- */ + +/* helper to add metatable to new lua object */ +SWIGINTERN void SWIG_Lua_AddMetatable(lua_State *L,swig_type_info *type) +{ + if (type->clientdata) /* there is clientdata: so add the metatable */ + { + SWIG_Lua_get_class_metatable(L,((swig_lua_class*)(type->clientdata))->fqname); + if (lua_istable(L,-1)) + { + lua_setmetatable(L,-2); + } + else + { + lua_pop(L,1); + } + } +} + +/* pushes a new object into the lua stack */ +SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State *L,void *ptr,swig_type_info *type, int own) +{ + swig_lua_userdata *usr; + if (!ptr){ + lua_pushnil(L); + return; + } + usr=(swig_lua_userdata*)lua_newuserdata(L,sizeof(swig_lua_userdata)); /* get data */ + usr->ptr=ptr; /* set the ptr */ + usr->type=type; + usr->own=own; +#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC) + SWIG_Lua_AddMetatable(L,type); /* add metatable */ +#endif +} + +/* takes a object from the lua stack & converts it into an object of the correct type + (if possible) */ +SWIGRUNTIME int SWIG_Lua_ConvertPtr(lua_State *L,int index,void **ptr,swig_type_info *type,int flags) +{ + int ret = SWIG_ERROR; + swig_lua_userdata *usr; + swig_cast_info *cast; + /* special case: lua nil => NULL pointer */ + if (lua_isnil(L,index)) + { + *ptr=0; + return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK; + } + if (lua_islightuserdata(L,index)) + { + *ptr=lua_touserdata(L,index); + return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK; + } + usr=(swig_lua_userdata*)lua_touserdata(L,index); /* get data */ + if (usr) + { + if (((flags & SWIG_POINTER_RELEASE) == SWIG_POINTER_RELEASE) && !usr->own) + { + return SWIG_ERROR_RELEASE_NOT_OWNED; + } + if (flags & SWIG_POINTER_DISOWN) /* must disown the object */ + { + usr->own = 0; + } + if (!type) /* special cast void*, no casting fn */ + { + *ptr=usr->ptr; + ret = SWIG_OK; + } + else + { + cast=SWIG_TypeCheck(usr->type->name,type); /* performs normal type checking */ + if (cast) + { + int newmemory = 0; + *ptr=SWIG_TypeCast(cast,usr->ptr,&newmemory); + assert(!newmemory); /* newmemory handling not yet implemented */ + ret = SWIG_OK; + } + } + if ((ret == SWIG_OK) && (flags & SWIG_POINTER_CLEAR)) + { + usr->ptr = 0; + } + } + return ret; +} + +SWIGRUNTIME void* SWIG_Lua_MustGetPtr(lua_State *L,int index,swig_type_info *type,int flags, + int argnum,const char *func_name){ + void *result = 0; + if (!SWIG_IsOK(SWIG_ConvertPtr(L,index,&result,type,flags))){ + luaL_error (L,"Error in %s, expected a %s at argument number %d\n", + func_name,(type && type->str)?type->str:"void*",argnum); + } + return result; +} + +/* pushes a packed userdata. user for member fn pointers only */ +SWIGRUNTIME void SWIG_Lua_NewPackedObj(lua_State *L,void *ptr,size_t size,swig_type_info *type) +{ + swig_lua_rawdata *raw; + assert(ptr); /* not acceptable to pass in a NULL value */ + raw=(swig_lua_rawdata*)lua_newuserdata(L,sizeof(swig_lua_rawdata)-1+size); /* alloc data */ + raw->type=type; + raw->own=0; + memcpy(raw->data,ptr,size); /* copy the data */ + SWIG_Lua_AddMetatable(L,type); /* add metatable */ +} + +/* converts a packed userdata. user for member fn pointers only */ +SWIGRUNTIME int SWIG_Lua_ConvertPacked(lua_State *L,int index,void *ptr,size_t size,swig_type_info *type) +{ + swig_lua_rawdata *raw; + raw=(swig_lua_rawdata*)lua_touserdata(L,index); /* get data */ + if (!raw) return SWIG_ERROR; /* error */ + if (type==0 || type==raw->type) /* void* or identical type */ + { + memcpy(ptr,raw->data,size); /* copy it */ + return SWIG_OK; /* ok */ + } + return SWIG_ERROR; /* error */ +} + +/* a function to get the typestring of a piece of data */ +SWIGRUNTIME const char *SWIG_Lua_typename(lua_State *L, int tp) +{ + swig_lua_userdata *usr; + if (lua_isuserdata(L,tp)) + { + usr=(swig_lua_userdata*)lua_touserdata(L,tp); /* get data */ + if (usr && usr->type && usr->type->str) + return usr->type->str; + return "userdata (unknown type)"; + } + return lua_typename(L,lua_type(L,tp)); +} + +/* lua callable function to get the userdata's type */ +SWIGRUNTIME int SWIG_Lua_type(lua_State *L) +{ + lua_pushstring(L,SWIG_Lua_typename(L,1)); + return 1; +} + +/* ----------------------------------------------------------------------------- + * global variable support code: class/struct typemap functions + * ----------------------------------------------------------------------------- */ + +#if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)) +/* Install Constants */ +SWIGINTERN void +SWIG_Lua_InstallConstants(lua_State *L, swig_lua_const_info constants[]) { + int i; + for (i = 0; constants[i].type; i++) { + switch(constants[i].type) { + case SWIG_LUA_INT: + lua_pushstring(L,constants[i].name); + lua_pushinteger(L,(lua_Integer)constants[i].lvalue); + lua_rawset(L,-3); + break; + case SWIG_LUA_FLOAT: + lua_pushstring(L,constants[i].name); + lua_pushnumber(L,(lua_Number)constants[i].dvalue); + lua_rawset(L,-3); + break; + case SWIG_LUA_CHAR: + lua_pushstring(L,constants[i].name); + { + char c = (char)constants[i].lvalue; + lua_pushlstring(L,&c,1); + } + lua_rawset(L,-3); + break; + case SWIG_LUA_STRING: + lua_pushstring(L,constants[i].name); + lua_pushstring(L,(char *) constants[i].pvalue); + lua_rawset(L,-3); + break; + case SWIG_LUA_POINTER: + lua_pushstring(L,constants[i].name); + SWIG_NewPointerObj(L,constants[i].pvalue, *(constants[i]).ptype,0); + lua_rawset(L,-3); + break; + case SWIG_LUA_BINARY: + lua_pushstring(L,constants[i].name); + SWIG_NewMemberObj(L,constants[i].pvalue,constants[i].lvalue,*(constants[i]).ptype); + lua_rawset(L,-3); + break; + default: + break; + } + } +} +#endif + +/* ----------------------------------------------------------------------------- + * executing lua code from within the wrapper + * ----------------------------------------------------------------------------- */ + +#ifndef SWIG_DOSTRING_FAIL /* Allows redefining of error function */ +#define SWIG_DOSTRING_FAIL(S) fprintf(stderr,"%s\n",S) +#endif +/* Executes a C string in Lua which is a really simple way of calling lua from C +Unfortunately lua keeps changing its APIs, so we need a conditional compile +In lua 5.0.X it's lua_dostring() +In lua 5.1.X it's luaL_dostring() +*/ +SWIGINTERN int +SWIG_Lua_dostring(lua_State *L, const char *str) { + int ok,top; + if (str==0 || str[0]==0) return 0; /* nothing to do */ + top=lua_gettop(L); /* save stack */ +#if (defined(LUA_VERSION_NUM) && (LUA_VERSION_NUM>=501)) + ok=luaL_dostring(L,str); /* looks like this is lua 5.1.X or later, good */ +#else + ok=lua_dostring(L,str); /* might be lua 5.0.x, using lua_dostring */ +#endif + if (ok!=0) { + SWIG_DOSTRING_FAIL(lua_tostring(L,-1)); + } + lua_settop(L,top); /* restore the stack */ + return ok; +} + +#ifdef __cplusplus +} +#endif + +/* ------------------------------ end luarun.swg ------------------------------ */ + + +/* -------- TYPES TABLE (BEGIN) -------- */ + +#define SWIGTYPE_p_bool swig_types[0] +#define SWIGTYPE_p_double swig_types[1] +#define SWIGTYPE_p_f_p_q_const__char_p_void__void swig_types[2] +#define SWIGTYPE_p_f_p_void__p_void swig_types[3] +#define SWIGTYPE_p_f_p_void_p_p_q_const__char__bool swig_types[4] +#define SWIGTYPE_p_f_p_void_p_q_const__void_size_t__void swig_types[5] +#define SWIGTYPE_p_f_p_void_r_q_const__lldb__SBModuleSpec_r_lldb__SBFileSpec_r_lldb__SBFileSpec__lldb__SBError swig_types[6] +#define SWIGTYPE_p_f_unsigned_long_long_p_void__void swig_types[7] +#define SWIGTYPE_p_int swig_types[8] +#define SWIGTYPE_p_lldb__ConnectionStatus swig_types[9] +#define SWIGTYPE_p_lldb__SBAddress swig_types[10] +#define SWIGTYPE_p_lldb__SBAddressRange swig_types[11] +#define SWIGTYPE_p_lldb__SBAddressRangeList swig_types[12] +#define SWIGTYPE_p_lldb__SBAttachInfo swig_types[13] +#define SWIGTYPE_p_lldb__SBBlock swig_types[14] +#define SWIGTYPE_p_lldb__SBBreakpoint swig_types[15] +#define SWIGTYPE_p_lldb__SBBreakpointList swig_types[16] +#define SWIGTYPE_p_lldb__SBBreakpointLocation swig_types[17] +#define SWIGTYPE_p_lldb__SBBreakpointName swig_types[18] +#define SWIGTYPE_p_lldb__SBBroadcaster swig_types[19] +#define SWIGTYPE_p_lldb__SBCommandInterpreter swig_types[20] +#define SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions swig_types[21] +#define SWIGTYPE_p_lldb__SBCommandReturnObject swig_types[22] +#define SWIGTYPE_p_lldb__SBCommunication swig_types[23] +#define SWIGTYPE_p_lldb__SBCompileUnit swig_types[24] +#define SWIGTYPE_p_lldb__SBData swig_types[25] +#define SWIGTYPE_p_lldb__SBDebugger swig_types[26] +#define SWIGTYPE_p_lldb__SBDeclaration swig_types[27] +#define SWIGTYPE_p_lldb__SBEnvironment swig_types[28] +#define SWIGTYPE_p_lldb__SBError swig_types[29] +#define SWIGTYPE_p_lldb__SBEvent swig_types[30] +#define SWIGTYPE_p_lldb__SBExecutionContext swig_types[31] +#define SWIGTYPE_p_lldb__SBExpressionOptions swig_types[32] +#define SWIGTYPE_p_lldb__SBFile swig_types[33] +#define SWIGTYPE_p_lldb__SBFileSpec swig_types[34] +#define SWIGTYPE_p_lldb__SBFileSpecList swig_types[35] +#define SWIGTYPE_p_lldb__SBFormat swig_types[36] +#define SWIGTYPE_p_lldb__SBFrame swig_types[37] +#define SWIGTYPE_p_lldb__SBFunction swig_types[38] +#define SWIGTYPE_p_lldb__SBHostOS swig_types[39] +#define SWIGTYPE_p_lldb__SBInstruction swig_types[40] +#define SWIGTYPE_p_lldb__SBInstructionList swig_types[41] +#define SWIGTYPE_p_lldb__SBLanguageRuntime swig_types[42] +#define SWIGTYPE_p_lldb__SBLaunchInfo swig_types[43] +#define SWIGTYPE_p_lldb__SBLineEntry swig_types[44] +#define SWIGTYPE_p_lldb__SBListener swig_types[45] +#define SWIGTYPE_p_lldb__SBMemoryRegionInfo swig_types[46] +#define SWIGTYPE_p_lldb__SBMemoryRegionInfoList swig_types[47] +#define SWIGTYPE_p_lldb__SBModule swig_types[48] +#define SWIGTYPE_p_lldb__SBModuleSpec swig_types[49] +#define SWIGTYPE_p_lldb__SBModuleSpecList swig_types[50] +#define SWIGTYPE_p_lldb__SBPlatform swig_types[51] +#define SWIGTYPE_p_lldb__SBPlatformConnectOptions swig_types[52] +#define SWIGTYPE_p_lldb__SBPlatformShellCommand swig_types[53] +#define SWIGTYPE_p_lldb__SBProcess swig_types[54] +#define SWIGTYPE_p_lldb__SBProcessInfo swig_types[55] +#define SWIGTYPE_p_lldb__SBProcessInfoList 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__MemoryHistory_t swig_types[140] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__MemoryRegionInfo_t swig_types[141] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Module_t swig_types[142] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ObjectContainer_t swig_types[143] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ObjectFileJITDelegate_t swig_types[144] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ObjectFile_t swig_types[145] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__OperatingSystemInterface_t swig_types[146] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValueProperties_t swig_types[147] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__OptionValue_t swig_types[148] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Platform_t swig_types[149] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ProcessAttachInfo_t swig_types[150] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ProcessLaunchInfo_t swig_types[151] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Process_t swig_types[152] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__QueueItem_t swig_types[153] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Queue_t swig_types[154] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__REPL_t swig_types[155] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__RecognizedStackFrame_t swig_types[156] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__RegisterCheckpoint_t swig_types[157] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__RegisterContext_t swig_types[158] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__RegisterTypeBuilder_t swig_types[159] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__RegularExpression_t swig_types[160] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptInterpreter_t swig_types[161] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptSummaryFormat_t swig_types[162] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptedMetadata_t swig_types[163] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptedSyntheticChildren_t swig_types[164] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptedThreadInterface_t swig_types[165] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ScriptedThreadPlanInterface_t swig_types[166] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__SearchFilter_t swig_types[167] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__SectionLoadList_t swig_types[168] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Section_t swig_types[169] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__StackFrameList_t swig_types[170] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__StackFrameRecognizer_t swig_types[171] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__StackFrame_t swig_types[172] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__StopInfo_t swig_types[173] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__StreamFile_t swig_types[174] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Stream_t swig_types[175] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__StringSummaryFormat_t swig_types[176] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__StructuredDataPlugin_t swig_types[177] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__SupportFile_t swig_types[178] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__SymbolContextSpecifier_t swig_types[179] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__SymbolFileType_t swig_types[180] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__SyntheticChildrenFrontEnd_t swig_types[181] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__SyntheticChildren_t swig_types[182] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Target_t swig_types[183] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ThreadCollection_t swig_types[184] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ThreadPlanTracer_t swig_types[185] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ThreadPlan_t swig_types[186] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ThreadPostMortemTrace_t swig_types[187] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Thread_t swig_types[188] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TraceCursor_t swig_types[189] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Trace_t swig_types[190] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeCategoryImpl_t swig_types[191] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeEnumMemberImpl_t swig_types[192] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeFilterImpl_t swig_types[193] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeFormatImpl_t swig_types[194] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeImpl_t swig_types[195] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeMemberFunctionImpl_t swig_types[196] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeNameSpecifierImpl_t swig_types[197] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeSummaryImpl_t swig_types[198] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeSummaryOptions_t swig_types[199] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeSystemClang_t swig_types[200] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__TypeSystem_t swig_types[201] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Type_t swig_types[202] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__UnixSignals_t swig_types[203] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__UnwindAssembly_t swig_types[204] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__UnwindPlan_t swig_types[205] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__UserExpression_t swig_types[206] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ValueObjectList_t swig_types[207] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__ValueObject_t swig_types[208] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Value_t swig_types[209] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__VariableList_t swig_types[210] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Variable_t swig_types[211] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__WatchpointResource_t swig_types[212] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__Watchpoint_t swig_types[213] +#define SWIGTYPE_p_std__shared_ptrT_lldb_private__WritableDataBuffer_t swig_types[214] +#define SWIGTYPE_p_std__string swig_types[215] +#define SWIGTYPE_p_std__unique_ptrT_lldb_private__AddressRange_t swig_types[216] +#define SWIGTYPE_p_std__unique_ptrT_lldb_private__DynamicCheckerFunctions_t swig_types[217] +#define SWIGTYPE_p_std__unique_ptrT_lldb_private__DynamicLoader_t swig_types[218] +#define SWIGTYPE_p_std__unique_ptrT_lldb_private__File_t swig_types[219] +#define SWIGTYPE_p_std__unique_ptrT_lldb_private__JITLoaderList_t swig_types[220] +#define SWIGTYPE_p_std__unique_ptrT_lldb_private__MemoryRegionInfo_t swig_types[221] +#define SWIGTYPE_p_std__unique_ptrT_lldb_private__OperatingSystem_t swig_types[222] +#define SWIGTYPE_p_std__unique_ptrT_lldb_private__ScriptedPlatformInterface_t swig_types[223] +#define SWIGTYPE_p_std__unique_ptrT_lldb_private__ScriptedProcessInterface_t swig_types[224] +#define SWIGTYPE_p_std__unique_ptrT_lldb_private__SectionList_t swig_types[225] +#define SWIGTYPE_p_std__unique_ptrT_lldb_private__SourceManager_t swig_types[226] +#define SWIGTYPE_p_std__unique_ptrT_lldb_private__StackFrameRecognizerManager_t swig_types[227] +#define SWIGTYPE_p_std__unique_ptrT_lldb_private__StructuredDataImpl_t swig_types[228] +#define SWIGTYPE_p_std__unique_ptrT_lldb_private__SymbolVendor_t swig_types[229] +#define SWIGTYPE_p_std__unique_ptrT_lldb_private__SystemRuntime_t swig_types[230] +#define SWIGTYPE_p_std__unique_ptrT_lldb_private__TraceExporter_t swig_types[231] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__BreakpointLocation_t swig_types[232] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Breakpoint_t swig_types[233] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__BroadcasterManager_t swig_types[234] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Debugger_t swig_types[235] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Listener_t swig_types[236] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Module_t swig_types[237] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__ObjectFileJITDelegate_t swig_types[238] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__OptionValue_t swig_types[239] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Process_t swig_types[240] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Queue_t swig_types[241] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Section_t swig_types[242] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__StackFrame_t swig_types[243] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__StructuredDataPlugin_t swig_types[244] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Target_t swig_types[245] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__ThreadPlan_t swig_types[246] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Thread_t swig_types[247] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__TypeSystem_t swig_types[248] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__Type_t swig_types[249] +#define SWIGTYPE_p_std__weak_ptrT_lldb_private__UnixSignals_t swig_types[250] +#define SWIGTYPE_p_unsigned_char swig_types[251] +#define SWIGTYPE_p_unsigned_int swig_types[252] +#define SWIGTYPE_p_unsigned_long_long swig_types[253] +#define SWIGTYPE_p_unsigned_short swig_types[254] +#define SWIGTYPE_p_void swig_types[255] +static swig_type_info *swig_types[257]; +static swig_module_info swig_module = {swig_types, 256, 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) -------- */ + +#define SWIG_name "lldb" +#define SWIG_init luaopen_lldb +#define SWIG_init_user luaopen_lldb_user + +#define SWIG_LUACODE luaopen_lldb_luacode + +#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 + + +namespace swig { +typedef struct{} LANGUAGE_OBJ; +} + + +#include <string> + + +SWIGINTERN int SWIG_lua_isnilstring(lua_State *L, int idx) { + int ret = lua_isstring(L, idx); + if (!ret) + ret = lua_isnil(L, idx); + return ret; +} + + +#ifdef __cplusplus /* generic alloc/dealloc fns*/ +#define SWIG_ALLOC_ARRAY(TYPE,LEN) new TYPE[LEN] +#define SWIG_FREE_ARRAY(PTR) delete[] PTR +#else +#define SWIG_ALLOC_ARRAY(TYPE,LEN) (TYPE *)malloc(LEN*sizeof(TYPE)) +#define SWIG_FREE_ARRAY(PTR) free(PTR) +#endif +/* counting the size of arrays:*/ +SWIGINTERN int SWIG_itable_size(lua_State* L, int index) +{ + int n=0; + while(1){ + lua_rawgeti(L,index,n+1); + if (lua_isnil(L,-1))break; + ++n; + lua_pop(L,1); + } + lua_pop(L,1); + return n; +} + +SWIGINTERN int SWIG_table_size(lua_State* L, int index) +{ + int n=0; + lua_pushnil(L); /* first key*/ + while (lua_next(L, index) != 0) { + ++n; + lua_pop(L, 1); /* removes `value'; keeps `key' for next iteration*/ + } + return n; +} + +/* super macro to declare array typemap helper fns */ +#define SWIG_DECLARE_TYPEMAP_ARR_FN(NAME,TYPE)\ + SWIGINTERN int SWIG_read_##NAME##_num_array(lua_State* L,int index,TYPE *array,int size){\ + int i;\ + for (i = 0; i < size; i++) {\ + lua_rawgeti(L,index,i+1);\ + if (lua_isnumber(L,-1)){\ + array[i] = (TYPE)lua_tonumber(L,-1);\ + } else {\ + lua_pop(L,1);\ + return 0;\ + }\ + lua_pop(L,1);\ + }\ + return 1;\ + }\ + SWIGINTERN TYPE* SWIG_get_##NAME##_num_array_fixed(lua_State* L, int index, int size){\ + TYPE *array;\ + if (!lua_istable(L,index) || SWIG_itable_size(L,index) != size) {\ + SWIG_Lua_pushferrstring(L,"expected a table of size %d",size);\ + return 0;\ + }\ + array=SWIG_ALLOC_ARRAY(TYPE,size);\ + if (!SWIG_read_##NAME##_num_array(L,index,array,size)){\ + SWIG_Lua_pusherrstring(L,"table must contain numbers");\ + SWIG_FREE_ARRAY(array);\ + return 0;\ + }\ + return array;\ + }\ + SWIGINTERN TYPE* SWIG_get_##NAME##_num_array_var(lua_State* L, int index, int* size)\ + {\ + TYPE *array;\ + if (!lua_istable(L,index)) {\ + SWIG_Lua_pusherrstring(L,"expected a table");\ + return 0;\ + }\ + *size=SWIG_itable_size(L,index);\ + if (*size<1){\ + SWIG_Lua_pusherrstring(L,"table appears to be empty");\ + return 0;\ + }\ + array=SWIG_ALLOC_ARRAY(TYPE,*size);\ + if (!SWIG_read_##NAME##_num_array(L,index,array,*size)){\ + SWIG_Lua_pusherrstring(L,"table must contain numbers");\ + SWIG_FREE_ARRAY(array);\ + return 0;\ + }\ + return array;\ + }\ + SWIGINTERN void SWIG_write_##NAME##_num_array(lua_State* L,TYPE *array,int size){\ + int i;\ + lua_newtable(L);\ + for (i = 0; i < size; i++){\ + lua_pushnumber(L,(lua_Number)array[i]);\ + lua_rawseti(L,-2,i+1);/* -1 is the number, -2 is the table*/ \ + }\ + } + +SWIG_DECLARE_TYPEMAP_ARR_FN(schar,signed char) +SWIG_DECLARE_TYPEMAP_ARR_FN(uchar,unsigned char) +SWIG_DECLARE_TYPEMAP_ARR_FN(int,int) +SWIG_DECLARE_TYPEMAP_ARR_FN(uint,unsigned int) +SWIG_DECLARE_TYPEMAP_ARR_FN(short,short) +SWIG_DECLARE_TYPEMAP_ARR_FN(ushort,unsigned short) +SWIG_DECLARE_TYPEMAP_ARR_FN(long,long) +SWIG_DECLARE_TYPEMAP_ARR_FN(ulong,unsigned long) +SWIG_DECLARE_TYPEMAP_ARR_FN(float,float) +SWIG_DECLARE_TYPEMAP_ARR_FN(double,double) + +SWIGINTERN int SWIG_read_ptr_array(lua_State* L,int index,void **array,int size,swig_type_info *type){ + int i; + for (i = 0; i < size; i++) { + lua_rawgeti(L,index,i+1); + if (!lua_isuserdata(L,-1) || SWIG_ConvertPtr(L,-1,&array[i],type,0)==-1){ + lua_pop(L,1); + return 0; + } + lua_pop(L,1); + } + return 1; +} +SWIGINTERN void** SWIG_get_ptr_array_fixed(lua_State* L, int index, int size,swig_type_info *type){ + void **array; + if (!lua_istable(L,index) || SWIG_itable_size(L,index) != size) { + SWIG_Lua_pushferrstring(L,"expected a table of size %d",size); + return 0; + } + array=SWIG_ALLOC_ARRAY(void*,size); + if (!SWIG_read_ptr_array(L,index,array,size,type)){ + SWIG_Lua_pushferrstring(L,"table must contain pointers of type %s",type->name); + SWIG_FREE_ARRAY(array); + return 0; + } + return array; +} +SWIGINTERN void** SWIG_get_ptr_array_var(lua_State* L, int index, int* size,swig_type_info *type){ + void **array; + if (!lua_istable(L,index)) { + SWIG_Lua_pusherrstring(L,"expected a table"); + return 0; + } + *size=SWIG_itable_size(L,index); + if (*size<1){ + SWIG_Lua_pusherrstring(L,"table appears to be empty"); + return 0; + } + array=SWIG_ALLOC_ARRAY(void*,*size); + if (!SWIG_read_ptr_array(L,index,array,*size,type)){ + SWIG_Lua_pushferrstring(L,"table must contain pointers of type %s",type->name); + SWIG_FREE_ARRAY(array); + return 0; + } + return array; +} +SWIGINTERN void SWIG_write_ptr_array(lua_State* L,void **array,int size,swig_type_info *type,int own){ + int i; + lua_newtable(L); + for (i = 0; i < size; i++){ + SWIG_NewPointerObj(L,array[i],type,own); + lua_rawseti(L,-2,i+1);/* -1 is the number, -2 is the table*/ + } +} + + +#include <algorithm> +#include <string> + + +#include "lldb/lldb-public.h" +#include "lldb/API/SBAddress.h" +#include "lldb/API/SBAddressRange.h" +#include "lldb/API/SBAddressRangeList.h" +#include "lldb/API/SBAttachInfo.h" +#include "lldb/API/SBBlock.h" +#include "lldb/API/SBBreakpoint.h" +#include "lldb/API/SBBreakpointLocation.h" +#include "lldb/API/SBBreakpointName.h" +#include "lldb/API/SBBroadcaster.h" +#include "lldb/API/SBCommandInterpreter.h" +#include "lldb/API/SBCommandInterpreterRunOptions.h" +#include "lldb/API/SBCommandReturnObject.h" +#include "lldb/API/SBCommunication.h" +#include "lldb/API/SBCompileUnit.h" +#include "lldb/API/SBSaveCoreOptions.h" +#include "lldb/API/SBData.h" +#include "lldb/API/SBDebugger.h" +#include "lldb/API/SBDeclaration.h" +#include "lldb/API/SBEnvironment.h" +#include "lldb/API/SBError.h" +#include "lldb/API/SBEvent.h" +#include "lldb/API/SBExecutionContext.h" +#include "lldb/API/SBExpressionOptions.h" +#include "lldb/API/SBFile.h" +#include "lldb/API/SBFileSpec.h" +#include "lldb/API/SBFileSpecList.h" +#include "lldb/API/SBFormat.h" +#include "lldb/API/SBFrame.h" +#include "lldb/API/SBFunction.h" +#include "lldb/API/SBHostOS.h" +#include "lldb/API/SBInstruction.h" +#include "lldb/API/SBInstructionList.h" +#include "lldb/API/SBLanguages.h" +#include "lldb/API/SBLanguageRuntime.h" +#include "lldb/API/SBLaunchInfo.h" +#include "lldb/API/SBLineEntry.h" +#include "lldb/API/SBListener.h" +#include "lldb/API/SBMemoryRegionInfo.h" +#include "lldb/API/SBMemoryRegionInfoList.h" +#include "lldb/API/SBModule.h" +#include "lldb/API/SBModuleSpec.h" +#include "lldb/API/SBPlatform.h" +#include "lldb/API/SBProcess.h" +#include "lldb/API/SBProcessInfo.h" +#include "lldb/API/SBProcessInfoList.h" +#include "lldb/API/SBQueue.h" +#include "lldb/API/SBQueueItem.h" +#include "lldb/API/SBReproducer.h" +#include "lldb/API/SBScriptObject.h" +#include "lldb/API/SBSection.h" +#include "lldb/API/SBSourceManager.h" +#include "lldb/API/SBStatisticsOptions.h" +#include "lldb/API/SBStream.h" +#include "lldb/API/SBStringList.h" +#include "lldb/API/SBStructuredData.h" +#include "lldb/API/SBSymbol.h" +#include "lldb/API/SBSymbolContext.h" +#include "lldb/API/SBSymbolContextList.h" +#include "lldb/API/SBTarget.h" +#include "lldb/API/SBThread.h" +#include "lldb/API/SBThreadCollection.h" +#include "lldb/API/SBThreadPlan.h" +#include "lldb/API/SBTrace.h" +#include "lldb/API/SBTraceCursor.h" +#include "lldb/API/SBType.h" +#include "lldb/API/SBTypeCategory.h" +#include "lldb/API/SBTypeEnumMember.h" +#include "lldb/API/SBTypeFilter.h" +#include "lldb/API/SBTypeFormat.h" +#include "lldb/API/SBTypeNameSpecifier.h" +#include "lldb/API/SBTypeSummary.h" +#include "lldb/API/SBTypeSynthetic.h" +#include "lldb/API/SBUnixSignals.h" +#include "lldb/API/SBValue.h" +#include "lldb/API/SBValueList.h" +#include "lldb/API/SBVariablesOptions.h" +#include "lldb/API/SBWatchpoint.h" +#include "lldb/API/SBWatchpointOptions.h" + + +#include "llvm/Support/Error.h" +#include "llvm/Support/FormatVariadic.h" +#include "../bindings/lua/lua-swigsafecast.swig" +#include "../source/Plugins/ScriptInterpreter/Lua/SWIGLuaBridge.h" + +// required headers for typemaps +#include "lldb/Host/File.h" + +using namespace lldb_private; +using namespace lldb; + + +#include <stdint.h> // Use the C99 official header + +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); + } +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); + } +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); + } +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 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 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); + } +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_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 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); + } + + +template <typename T> void PushSBClass(lua_State * L, T * obj); + +// This function is called from Lua::CallBreakpointCallback +llvm::Expected<bool> +lldb_private::lua::SWIGBridge::LLDBSwigLuaBreakpointCallbackFunction( + lua_State * L, lldb::StackFrameSP stop_frame_sp, + lldb::BreakpointLocationSP bp_loc_sp, + const StructuredDataImpl &extra_args_impl) { + lldb::SBFrame sb_frame(stop_frame_sp); + lldb::SBBreakpointLocation sb_bp_loc(bp_loc_sp); + int nargs = 2; + + lldb::SBStructuredData extra_args(extra_args_impl); + + // Push the Lua wrappers + PushSBClass(L, &sb_frame); + PushSBClass(L, &sb_bp_loc); + + if (extra_args.IsValid()) { + PushSBClass(L, &extra_args); + nargs++; + } + + // Call into the Lua callback passing 'sb_frame' and 'sb_bp_loc'. + // Expects a boolean return. + if (lua_pcall(L, nargs, 1, 0) != LUA_OK) { + llvm::Error E = llvm::make_error<llvm::StringError>( + llvm::formatv("{0}\n", lua_tostring(L, -1)), + llvm::inconvertibleErrorCode()); + // Pop error message from the stack. + lua_pop(L, 1); + return std::move(E); + } + + // Boolean return from the callback + bool stop = lua_toboolean(L, -1); + lua_pop(L, 1); + + return stop; +} + +// This function is called from Lua::CallWatchpointCallback +llvm::Expected<bool> +lldb_private::lua::SWIGBridge::LLDBSwigLuaWatchpointCallbackFunction( + lua_State * L, lldb::StackFrameSP stop_frame_sp, lldb::WatchpointSP wp_sp) { + lldb::SBFrame sb_frame(stop_frame_sp); + lldb::SBWatchpoint sb_wp(wp_sp); + int nargs = 2; + + // Push the Lua wrappers + PushSBClass(L, &sb_frame); + PushSBClass(L, &sb_wp); + + // Call into the Lua callback passing 'sb_frame' and 'sb_wp'. + // Expects a boolean return. + if (lua_pcall(L, nargs, 1, 0) != LUA_OK) { + llvm::Error E = llvm::make_error<llvm::StringError>( + llvm::formatv("{0}\n", lua_tostring(L, -1)), + llvm::inconvertibleErrorCode()); + // Pop error message from the stack. + lua_pop(L, 1); + return std::move(E); + } + + // Boolean return from the callback + bool stop = lua_toboolean(L, -1); + lua_pop(L, 1); + + return stop; +} + +static void LLDBSwigLuaCallLuaLogOutputCallback(const char *str, void *baton) { + lua_State *L = (lua_State *)baton; + + lua_pushlightuserdata(L, (void *)&LLDBSwigLuaCallLuaLogOutputCallback); + lua_gettable(L, LUA_REGISTRYINDEX); + + // FIXME: There's no way to report errors back to the user + lua_pushstring(L, str); + lua_pcall(L, 1, 0, 0); +} + +static int LLDBSwigLuaCloseFileHandle(lua_State * L) { + return luaL_error(L, "You cannot close a file handle used by lldb."); +} + + +#ifdef __cplusplus +extern "C" { +#endif +static int _wrap_new_string__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + std::string *result = 0 ; + + SWIG_check_num_args("std::string::string",0,0) + result = (std::string *)new std::string(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__string,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_string__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + std::string *result = 0 ; + + SWIG_check_num_args("std::string::string",1,1) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("std::string::string",1,"char const *"); + arg1 = (char *)lua_tostring(L, 1); + result = (std::string *)new std::string((char const *)arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__string,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_string(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_string__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + _v = SWIG_lua_isnilstring(L,argv[0]); + } + if (_v) { + return _wrap_new_string__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_string'\n" + " Possible C/C++ prototypes are:\n" + " std::string::string()\n" + " std::string::string(char const *)\n"); + lua_error(L);return 0; +} + + +static int _wrap_string_size(lua_State* L) { + { + int SWIG_arg = 0; + std::string *arg1 = (std::string *) 0 ; + unsigned int result; + + SWIG_check_num_args("std::string::size",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::size",1,"std::string const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ + SWIG_fail_ptr("string_size",1,SWIGTYPE_p_std__string); + } + + result = (unsigned int)((std::string const *)arg1)->size(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_string_length(lua_State* L) { + { + int SWIG_arg = 0; + std::string *arg1 = (std::string *) 0 ; + unsigned int result; + + SWIG_check_num_args("std::string::length",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::length",1,"std::string const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ + SWIG_fail_ptr("string_length",1,SWIGTYPE_p_std__string); + } + + result = (unsigned int)((std::string const *)arg1)->length(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_string_empty(lua_State* L) { + { + int SWIG_arg = 0; + std::string *arg1 = (std::string *) 0 ; + bool result; + + SWIG_check_num_args("std::string::empty",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::empty",1,"std::string const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ + SWIG_fail_ptr("string_empty",1,SWIGTYPE_p_std__string); + } + + result = (bool)((std::string const *)arg1)->empty(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_string_c_str(lua_State* L) { + { + int SWIG_arg = 0; + std::string *arg1 = (std::string *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("std::string::c_str",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::c_str",1,"std::string const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ + SWIG_fail_ptr("string_c_str",1,SWIGTYPE_p_std__string); + } + + result = (char *)((std::string const *)arg1)->c_str(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_string_data(lua_State* L) { + { + int SWIG_arg = 0; + std::string *arg1 = (std::string *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("std::string::data",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::data",1,"std::string const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ + SWIG_fail_ptr("string_data",1,SWIGTYPE_p_std__string); + } + + result = (char *)((std::string const *)arg1)->data(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_string_assign(lua_State* L) { + { + int SWIG_arg = 0; + std::string *arg1 = (std::string *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("std::string::assign",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::assign",1,"std::string *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("std::string::assign",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ + SWIG_fail_ptr("string_assign",1,SWIGTYPE_p_std__string); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->assign((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_string(void *obj) { +std::string *arg1 = (std::string *) obj; +delete arg1; +} +static int _proxy__wrap_new_string(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_string); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_string_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_string_methods[]= { + { "size", _wrap_string_size}, + { "length", _wrap_string_length}, + { "empty", _wrap_string_empty}, + { "c_str", _wrap_string_c_str}, + { "data", _wrap_string_data}, + { "assign", _wrap_string_assign}, + {0,0} +}; +static swig_lua_method swig_string_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_string_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_string_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_string_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_string_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_string_Sf_SwigStatic = { + "string", + swig_string_Sf_SwigStatic_methods, + swig_string_Sf_SwigStatic_attributes, + swig_string_Sf_SwigStatic_constants, + swig_string_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_string_bases[] = {0}; +static const char *swig_string_base_names[] = {0}; +static swig_lua_class _wrap_class_string = { "string", "string", &SWIGTYPE_p_std__string,_proxy__wrap_new_string, swig_delete_string, swig_string_methods, swig_string_attributes, &swig_string_Sf_SwigStatic, swig_string_meta, swig_string_bases, swig_string_base_names }; + +static int _wrap_new_SBAddress__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddress *result = 0 ; + + SWIG_check_num_args("lldb::SBAddress::SBAddress",0,0) + result = (lldb::SBAddress *)new lldb::SBAddress(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBAddress__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddress *arg1 = 0 ; + lldb::SBAddress *result = 0 ; + + SWIG_check_num_args("lldb::SBAddress::SBAddress",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBAddress::SBAddress",1,"lldb::SBAddress const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("new_SBAddress",1,SWIGTYPE_p_lldb__SBAddress); + } + + result = (lldb::SBAddress *)new lldb::SBAddress((lldb::SBAddress const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBAddress__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSection arg1 ; + lldb::addr_t arg2 ; + lldb::SBSection *argp1 ; + lldb::SBAddress *result = 0 ; + + SWIG_check_num_args("lldb::SBAddress::SBAddress",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBAddress::SBAddress",1,"lldb::SBSection"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBAddress::SBAddress",2,"lldb::addr_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&argp1,SWIGTYPE_p_lldb__SBSection,0))){ + SWIG_fail_ptr("new_SBAddress",1,SWIGTYPE_p_lldb__SBSection); + } + arg1 = *argp1; + + arg2 = (lldb::addr_t)lua_tointeger(L, 2); + result = (lldb::SBAddress *)new lldb::SBAddress(arg1,arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBAddress__SWIG_3(lua_State* L) { + { + int SWIG_arg = 0; + lldb::addr_t arg1 ; + lldb::SBTarget *arg2 = 0 ; + lldb::SBAddress *result = 0 ; + + SWIG_check_num_args("lldb::SBAddress::SBAddress",2,2) + if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBAddress::SBAddress",1,"lldb::addr_t"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBAddress::SBAddress",2,"lldb::SBTarget &"); + arg1 = (lldb::addr_t)lua_tointeger(L, 1); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("new_SBAddress",2,SWIGTYPE_p_lldb__SBTarget); + } + + result = (lldb::SBAddress *)new lldb::SBAddress(arg1,*arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBAddress(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBAddress__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBAddress__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBSection, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_new_SBAddress__SWIG_2(L); + } + } + } + if (argc == 2) { + int _v = 0; + { + _v = lua_isnumber(L,argv[0]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBAddress__SWIG_3(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBAddress_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBAddress::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::IsValid",1,"lldb::SBAddress const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBAddress_IsValid",1,SWIGTYPE_p_lldb__SBAddress); + } + + result = (bool)((lldb::SBAddress const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAddress_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + + SWIG_check_num_args("lldb::SBAddress::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::Clear",1,"lldb::SBAddress *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBAddress_Clear",1,SWIGTYPE_p_lldb__SBAddress); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAddress_GetFileAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + lldb::addr_t result; + + SWIG_check_num_args("lldb::SBAddress::GetFileAddress",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::GetFileAddress",1,"lldb::SBAddress const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBAddress_GetFileAddress",1,SWIGTYPE_p_lldb__SBAddress); + } + + result = (lldb::addr_t)((lldb::SBAddress const *)arg1)->GetFileAddress(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAddress_GetLoadAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + lldb::SBTarget *arg2 = 0 ; + lldb::addr_t result; + + SWIG_check_num_args("lldb::SBAddress::GetLoadAddress",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::GetLoadAddress",1,"lldb::SBAddress const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBAddress::GetLoadAddress",2,"lldb::SBTarget const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBAddress_GetLoadAddress",1,SWIGTYPE_p_lldb__SBAddress); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBAddress_GetLoadAddress",2,SWIGTYPE_p_lldb__SBTarget); + } + + result = (lldb::addr_t)((lldb::SBAddress const *)arg1)->GetLoadAddress((lldb::SBTarget const &)*arg2); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAddress_SetAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + lldb::SBSection arg2 ; + lldb::addr_t arg3 ; + lldb::SBSection *argp2 ; + + SWIG_check_num_args("lldb::SBAddress::SetAddress",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::SetAddress",1,"lldb::SBAddress *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBAddress::SetAddress",2,"lldb::SBSection"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBAddress::SetAddress",3,"lldb::addr_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBAddress_SetAddress",1,SWIGTYPE_p_lldb__SBAddress); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBSection,0))){ + SWIG_fail_ptr("SBAddress_SetAddress",2,SWIGTYPE_p_lldb__SBSection); + } + arg2 = *argp2; + + arg3 = (lldb::addr_t)lua_tointeger(L, 3); + (arg1)->SetAddress(arg2,arg3); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAddress_SetLoadAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + lldb::addr_t arg2 ; + lldb::SBTarget *arg3 = 0 ; + + SWIG_check_num_args("lldb::SBAddress::SetLoadAddress",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::SetLoadAddress",1,"lldb::SBAddress *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBAddress::SetLoadAddress",2,"lldb::addr_t"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBAddress::SetLoadAddress",3,"lldb::SBTarget &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBAddress_SetLoadAddress",1,SWIGTYPE_p_lldb__SBAddress); + } + + arg2 = (lldb::addr_t)lua_tointeger(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBAddress_SetLoadAddress",3,SWIGTYPE_p_lldb__SBTarget); + } + + (arg1)->SetLoadAddress(arg2,*arg3); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAddress_OffsetAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + lldb::addr_t arg2 ; + bool result; + + SWIG_check_num_args("lldb::SBAddress::OffsetAddress",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::OffsetAddress",1,"lldb::SBAddress *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBAddress::OffsetAddress",2,"lldb::addr_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBAddress_OffsetAddress",1,SWIGTYPE_p_lldb__SBAddress); + } + + arg2 = (lldb::addr_t)lua_tointeger(L, 2); + result = (bool)(arg1)->OffsetAddress(arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAddress_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBAddress::GetDescription",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::GetDescription",1,"lldb::SBAddress *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBAddress::GetDescription",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBAddress_GetDescription",1,SWIGTYPE_p_lldb__SBAddress); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBAddress_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)(arg1)->GetDescription(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAddress_GetSymbolContext(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + uint32_t arg2 ; + lldb::SBSymbolContext result; + + SWIG_check_num_args("lldb::SBAddress::GetSymbolContext",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::GetSymbolContext",1,"lldb::SBAddress *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBAddress::GetSymbolContext",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBAddress_GetSymbolContext",1,SWIGTYPE_p_lldb__SBAddress); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetSymbolContext(arg2); + { + lldb::SBSymbolContext * resultptr = new lldb::SBSymbolContext(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbolContext,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAddress_GetSection(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + lldb::SBSection result; + + SWIG_check_num_args("lldb::SBAddress::GetSection",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::GetSection",1,"lldb::SBAddress *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBAddress_GetSection",1,SWIGTYPE_p_lldb__SBAddress); + } + + result = (arg1)->GetSection(); + { + lldb::SBSection * resultptr = new lldb::SBSection(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSection,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAddress_GetOffset(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + lldb::addr_t result; + + SWIG_check_num_args("lldb::SBAddress::GetOffset",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::GetOffset",1,"lldb::SBAddress *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBAddress_GetOffset",1,SWIGTYPE_p_lldb__SBAddress); + } + + result = (lldb::addr_t)(arg1)->GetOffset(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAddress_GetModule(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + lldb::SBModule result; + + SWIG_check_num_args("lldb::SBAddress::GetModule",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::GetModule",1,"lldb::SBAddress *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBAddress_GetModule",1,SWIGTYPE_p_lldb__SBAddress); + } + + result = (arg1)->GetModule(); + { + lldb::SBModule * resultptr = new lldb::SBModule(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBModule,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAddress_GetCompileUnit(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + lldb::SBCompileUnit result; + + SWIG_check_num_args("lldb::SBAddress::GetCompileUnit",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::GetCompileUnit",1,"lldb::SBAddress *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBAddress_GetCompileUnit",1,SWIGTYPE_p_lldb__SBAddress); + } + + result = (arg1)->GetCompileUnit(); + { + lldb::SBCompileUnit * resultptr = new lldb::SBCompileUnit(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBCompileUnit,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAddress_GetFunction(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + lldb::SBFunction result; + + SWIG_check_num_args("lldb::SBAddress::GetFunction",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::GetFunction",1,"lldb::SBAddress *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBAddress_GetFunction",1,SWIGTYPE_p_lldb__SBAddress); + } + + result = (arg1)->GetFunction(); + { + lldb::SBFunction * resultptr = new lldb::SBFunction(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFunction,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAddress_GetBlock(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + lldb::SBBlock result; + + SWIG_check_num_args("lldb::SBAddress::GetBlock",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::GetBlock",1,"lldb::SBAddress *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBAddress_GetBlock",1,SWIGTYPE_p_lldb__SBAddress); + } + + result = (arg1)->GetBlock(); + { + lldb::SBBlock * resultptr = new lldb::SBBlock(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBlock,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAddress_GetSymbol(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + lldb::SBSymbol result; + + SWIG_check_num_args("lldb::SBAddress::GetSymbol",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::GetSymbol",1,"lldb::SBAddress *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBAddress_GetSymbol",1,SWIGTYPE_p_lldb__SBAddress); + } + + result = (arg1)->GetSymbol(); + { + lldb::SBSymbol * resultptr = new lldb::SBSymbol(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbol,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAddress_GetLineEntry(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + lldb::SBLineEntry result; + + SWIG_check_num_args("lldb::SBAddress::GetLineEntry",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::GetLineEntry",1,"lldb::SBAddress *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBAddress_GetLineEntry",1,SWIGTYPE_p_lldb__SBAddress); + } + + result = (arg1)->GetLineEntry(); + { + lldb::SBLineEntry * resultptr = new lldb::SBLineEntry(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBLineEntry,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAddress___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddress *arg1 = (lldb::SBAddress *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBAddress::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddress::__repr__",1,"lldb::SBAddress *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBAddress___tostring",1,SWIGTYPE_p_lldb__SBAddress); + } + + result = lldb_SBAddress___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBAddress(void *obj) { +lldb::SBAddress *arg1 = (lldb::SBAddress *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBAddress(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBAddress); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBAddress_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBAddress_methods[]= { + { "IsValid", _wrap_SBAddress_IsValid}, + { "Clear", _wrap_SBAddress_Clear}, + { "GetFileAddress", _wrap_SBAddress_GetFileAddress}, + { "GetLoadAddress", _wrap_SBAddress_GetLoadAddress}, + { "SetAddress", _wrap_SBAddress_SetAddress}, + { "SetLoadAddress", _wrap_SBAddress_SetLoadAddress}, + { "OffsetAddress", _wrap_SBAddress_OffsetAddress}, + { "GetDescription", _wrap_SBAddress_GetDescription}, + { "GetSymbolContext", _wrap_SBAddress_GetSymbolContext}, + { "GetSection", _wrap_SBAddress_GetSection}, + { "GetOffset", _wrap_SBAddress_GetOffset}, + { "GetModule", _wrap_SBAddress_GetModule}, + { "GetCompileUnit", _wrap_SBAddress_GetCompileUnit}, + { "GetFunction", _wrap_SBAddress_GetFunction}, + { "GetBlock", _wrap_SBAddress_GetBlock}, + { "GetSymbol", _wrap_SBAddress_GetSymbol}, + { "GetLineEntry", _wrap_SBAddress_GetLineEntry}, + { "__tostring", _wrap_SBAddress___tostring}, + {0,0} +}; +static swig_lua_method swig_SBAddress_meta[] = { + { "__tostring", _wrap_SBAddress___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBAddress_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBAddress_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBAddress_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBAddress_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBAddress_Sf_SwigStatic = { + "SBAddress", + swig_SBAddress_Sf_SwigStatic_methods, + swig_SBAddress_Sf_SwigStatic_attributes, + swig_SBAddress_Sf_SwigStatic_constants, + swig_SBAddress_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBAddress_bases[] = {0}; +static const char *swig_SBAddress_base_names[] = {0}; +static swig_lua_class _wrap_class_SBAddress = { "SBAddress", "SBAddress", &SWIGTYPE_p_lldb__SBAddress,_proxy__wrap_new_SBAddress, swig_delete_SBAddress, swig_SBAddress_methods, swig_SBAddress_attributes, &swig_SBAddress_Sf_SwigStatic, swig_SBAddress_meta, swig_SBAddress_bases, swig_SBAddress_base_names }; + +static int _wrap_new_SBAddressRange__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddressRange *result = 0 ; + + SWIG_check_num_args("lldb::SBAddressRange::SBAddressRange",0,0) + result = (lldb::SBAddressRange *)new lldb::SBAddressRange(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBAddressRange,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBAddressRange__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddressRange *arg1 = 0 ; + lldb::SBAddressRange *result = 0 ; + + SWIG_check_num_args("lldb::SBAddressRange::SBAddressRange",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBAddressRange::SBAddressRange",1,"lldb::SBAddressRange const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddressRange,0))){ + SWIG_fail_ptr("new_SBAddressRange",1,SWIGTYPE_p_lldb__SBAddressRange); + } + + result = (lldb::SBAddressRange *)new lldb::SBAddressRange((lldb::SBAddressRange const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBAddressRange,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBAddressRange__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddress arg1 ; + lldb::addr_t arg2 ; + lldb::SBAddress *argp1 ; + lldb::SBAddressRange *result = 0 ; + + SWIG_check_num_args("lldb::SBAddressRange::SBAddressRange",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBAddressRange::SBAddressRange",1,"lldb::SBAddress"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBAddressRange::SBAddressRange",2,"lldb::addr_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&argp1,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("new_SBAddressRange",1,SWIGTYPE_p_lldb__SBAddress); + } + arg1 = *argp1; + + arg2 = (lldb::addr_t)lua_tointeger(L, 2); + result = (lldb::SBAddressRange *)new lldb::SBAddressRange(arg1,arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBAddressRange,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBAddressRange(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBAddressRange__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBAddressRange, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBAddressRange__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_new_SBAddressRange__SWIG_2(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBAddressRange_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddressRange *arg1 = (lldb::SBAddressRange *) 0 ; + + SWIG_check_num_args("lldb::SBAddressRange::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddressRange::Clear",1,"lldb::SBAddressRange *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddressRange,0))){ + SWIG_fail_ptr("SBAddressRange_Clear",1,SWIGTYPE_p_lldb__SBAddressRange); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAddressRange_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddressRange *arg1 = (lldb::SBAddressRange *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBAddressRange::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddressRange::IsValid",1,"lldb::SBAddressRange const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddressRange,0))){ + SWIG_fail_ptr("SBAddressRange_IsValid",1,SWIGTYPE_p_lldb__SBAddressRange); + } + + result = (bool)((lldb::SBAddressRange const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAddressRange_GetBaseAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddressRange *arg1 = (lldb::SBAddressRange *) 0 ; + lldb::SBAddress result; + + SWIG_check_num_args("lldb::SBAddressRange::GetBaseAddress",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddressRange::GetBaseAddress",1,"lldb::SBAddressRange const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddressRange,0))){ + SWIG_fail_ptr("SBAddressRange_GetBaseAddress",1,SWIGTYPE_p_lldb__SBAddressRange); + } + + result = ((lldb::SBAddressRange const *)arg1)->GetBaseAddress(); + { + lldb::SBAddress * resultptr = new lldb::SBAddress(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAddressRange_GetByteSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddressRange *arg1 = (lldb::SBAddressRange *) 0 ; + lldb::addr_t result; + + SWIG_check_num_args("lldb::SBAddressRange::GetByteSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddressRange::GetByteSize",1,"lldb::SBAddressRange const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddressRange,0))){ + SWIG_fail_ptr("SBAddressRange_GetByteSize",1,SWIGTYPE_p_lldb__SBAddressRange); + } + + result = (lldb::addr_t)((lldb::SBAddressRange const *)arg1)->GetByteSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAddressRange___eq(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddressRange *arg1 = (lldb::SBAddressRange *) 0 ; + lldb::SBAddressRange *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBAddressRange::operator ==",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddressRange::operator ==",1,"lldb::SBAddressRange *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBAddressRange::operator ==",2,"lldb::SBAddressRange const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddressRange,0))){ + SWIG_fail_ptr("SBAddressRange___eq",1,SWIGTYPE_p_lldb__SBAddressRange); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBAddressRange,0))){ + SWIG_fail_ptr("SBAddressRange___eq",2,SWIGTYPE_p_lldb__SBAddressRange); + } + + result = (bool)(arg1)->operator ==((lldb::SBAddressRange const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAddressRange_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddressRange *arg1 = (lldb::SBAddressRange *) 0 ; + lldb::SBStream *arg2 = 0 ; + lldb::SBTarget arg3 ; + lldb::SBTarget *argp3 ; + bool result; + + SWIG_check_num_args("lldb::SBAddressRange::GetDescription",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddressRange::GetDescription",1,"lldb::SBAddressRange *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBAddressRange::GetDescription",2,"lldb::SBStream &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBAddressRange::GetDescription",3,"lldb::SBTarget const"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddressRange,0))){ + SWIG_fail_ptr("SBAddressRange_GetDescription",1,SWIGTYPE_p_lldb__SBAddressRange); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBAddressRange_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBAddressRange_GetDescription",3,SWIGTYPE_p_lldb__SBTarget); + } + arg3 = *argp3; + + result = (bool)(arg1)->GetDescription(*arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBAddressRange(void *obj) { +lldb::SBAddressRange *arg1 = (lldb::SBAddressRange *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBAddressRange(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBAddressRange); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBAddressRange_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBAddressRange_methods[]= { + { "Clear", _wrap_SBAddressRange_Clear}, + { "IsValid", _wrap_SBAddressRange_IsValid}, + { "GetBaseAddress", _wrap_SBAddressRange_GetBaseAddress}, + { "GetByteSize", _wrap_SBAddressRange_GetByteSize}, + { "__eq", _wrap_SBAddressRange___eq}, + { "GetDescription", _wrap_SBAddressRange_GetDescription}, + {0,0} +}; +static swig_lua_method swig_SBAddressRange_meta[] = { + { "__eq", _wrap_SBAddressRange___eq}, + {0,0} +}; + +static swig_lua_attribute swig_SBAddressRange_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBAddressRange_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBAddressRange_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBAddressRange_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBAddressRange_Sf_SwigStatic = { + "SBAddressRange", + swig_SBAddressRange_Sf_SwigStatic_methods, + swig_SBAddressRange_Sf_SwigStatic_attributes, + swig_SBAddressRange_Sf_SwigStatic_constants, + swig_SBAddressRange_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBAddressRange_bases[] = {0}; +static const char *swig_SBAddressRange_base_names[] = {0}; +static swig_lua_class _wrap_class_SBAddressRange = { "SBAddressRange", "SBAddressRange", &SWIGTYPE_p_lldb__SBAddressRange,_proxy__wrap_new_SBAddressRange, swig_delete_SBAddressRange, swig_SBAddressRange_methods, swig_SBAddressRange_attributes, &swig_SBAddressRange_Sf_SwigStatic, swig_SBAddressRange_meta, swig_SBAddressRange_bases, swig_SBAddressRange_base_names }; + +static int _wrap_new_SBAddressRangeList__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddressRangeList *result = 0 ; + + SWIG_check_num_args("lldb::SBAddressRangeList::SBAddressRangeList",0,0) + result = (lldb::SBAddressRangeList *)new lldb::SBAddressRangeList(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBAddressRangeList,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBAddressRangeList__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddressRangeList *arg1 = 0 ; + lldb::SBAddressRangeList *result = 0 ; + + SWIG_check_num_args("lldb::SBAddressRangeList::SBAddressRangeList",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBAddressRangeList::SBAddressRangeList",1,"lldb::SBAddressRangeList const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddressRangeList,0))){ + SWIG_fail_ptr("new_SBAddressRangeList",1,SWIGTYPE_p_lldb__SBAddressRangeList); + } + + result = (lldb::SBAddressRangeList *)new lldb::SBAddressRangeList((lldb::SBAddressRangeList const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBAddressRangeList,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBAddressRangeList(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBAddressRangeList__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBAddressRangeList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBAddressRangeList__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBAddressRangeList'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBAddressRangeList::SBAddressRangeList()\n" + " lldb::SBAddressRangeList::SBAddressRangeList(lldb::SBAddressRangeList const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBAddressRangeList_GetSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddressRangeList *arg1 = (lldb::SBAddressRangeList *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBAddressRangeList::GetSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddressRangeList::GetSize",1,"lldb::SBAddressRangeList const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddressRangeList,0))){ + SWIG_fail_ptr("SBAddressRangeList_GetSize",1,SWIGTYPE_p_lldb__SBAddressRangeList); + } + + result = (uint32_t)((lldb::SBAddressRangeList const *)arg1)->GetSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAddressRangeList_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddressRangeList *arg1 = (lldb::SBAddressRangeList *) 0 ; + + SWIG_check_num_args("lldb::SBAddressRangeList::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddressRangeList::Clear",1,"lldb::SBAddressRangeList *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddressRangeList,0))){ + SWIG_fail_ptr("SBAddressRangeList_Clear",1,SWIGTYPE_p_lldb__SBAddressRangeList); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAddressRangeList_GetAddressRangeAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddressRangeList *arg1 = (lldb::SBAddressRangeList *) 0 ; + uint64_t arg2 ; + lldb::SBAddressRange result; + + SWIG_check_num_args("lldb::SBAddressRangeList::GetAddressRangeAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddressRangeList::GetAddressRangeAtIndex",1,"lldb::SBAddressRangeList *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBAddressRangeList::GetAddressRangeAtIndex",2,"uint64_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddressRangeList,0))){ + SWIG_fail_ptr("SBAddressRangeList_GetAddressRangeAtIndex",1,SWIGTYPE_p_lldb__SBAddressRangeList); + } + + arg2 = (uint64_t)lua_tointeger(L, 2); + result = (arg1)->GetAddressRangeAtIndex(arg2); + { + lldb::SBAddressRange * resultptr = new lldb::SBAddressRange(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddressRange,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAddressRangeList_Append__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddressRangeList *arg1 = (lldb::SBAddressRangeList *) 0 ; + lldb::SBAddressRange *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBAddressRangeList::Append",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddressRangeList::Append",1,"lldb::SBAddressRangeList *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBAddressRangeList::Append",2,"lldb::SBAddressRange const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddressRangeList,0))){ + SWIG_fail_ptr("SBAddressRangeList_Append",1,SWIGTYPE_p_lldb__SBAddressRangeList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBAddressRange,0))){ + SWIG_fail_ptr("SBAddressRangeList_Append",2,SWIGTYPE_p_lldb__SBAddressRange); + } + + (arg1)->Append((lldb::SBAddressRange const &)*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAddressRangeList_Append__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddressRangeList *arg1 = (lldb::SBAddressRangeList *) 0 ; + lldb::SBAddressRangeList *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBAddressRangeList::Append",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddressRangeList::Append",1,"lldb::SBAddressRangeList *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBAddressRangeList::Append",2,"lldb::SBAddressRangeList const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddressRangeList,0))){ + SWIG_fail_ptr("SBAddressRangeList_Append",1,SWIGTYPE_p_lldb__SBAddressRangeList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBAddressRangeList,0))){ + SWIG_fail_ptr("SBAddressRangeList_Append",2,SWIGTYPE_p_lldb__SBAddressRangeList); + } + + (arg1)->Append((lldb::SBAddressRangeList const &)*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAddressRangeList_Append(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBAddressRangeList, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBAddressRange, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBAddressRangeList_Append__SWIG_0(L); + } + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBAddressRangeList, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBAddressRangeList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBAddressRangeList_Append__SWIG_1(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBAddressRangeList_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAddressRangeList *arg1 = (lldb::SBAddressRangeList *) 0 ; + lldb::SBStream *arg2 = 0 ; + lldb::SBTarget *arg3 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBAddressRangeList::GetDescription",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAddressRangeList::GetDescription",1,"lldb::SBAddressRangeList *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBAddressRangeList::GetDescription",2,"lldb::SBStream &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBAddressRangeList::GetDescription",3,"lldb::SBTarget const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAddressRangeList,0))){ + SWIG_fail_ptr("SBAddressRangeList_GetDescription",1,SWIGTYPE_p_lldb__SBAddressRangeList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBAddressRangeList_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBAddressRangeList_GetDescription",3,SWIGTYPE_p_lldb__SBTarget); + } + + result = (bool)(arg1)->GetDescription(*arg2,(lldb::SBTarget const &)*arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBAddressRangeList(void *obj) { +lldb::SBAddressRangeList *arg1 = (lldb::SBAddressRangeList *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBAddressRangeList(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBAddressRangeList); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBAddressRangeList_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBAddressRangeList_methods[]= { + { "GetSize", _wrap_SBAddressRangeList_GetSize}, + { "Clear", _wrap_SBAddressRangeList_Clear}, + { "GetAddressRangeAtIndex", _wrap_SBAddressRangeList_GetAddressRangeAtIndex}, + { "Append", _wrap_SBAddressRangeList_Append}, + { "GetDescription", _wrap_SBAddressRangeList_GetDescription}, + {0,0} +}; +static swig_lua_method swig_SBAddressRangeList_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBAddressRangeList_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBAddressRangeList_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBAddressRangeList_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBAddressRangeList_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBAddressRangeList_Sf_SwigStatic = { + "SBAddressRangeList", + swig_SBAddressRangeList_Sf_SwigStatic_methods, + swig_SBAddressRangeList_Sf_SwigStatic_attributes, + swig_SBAddressRangeList_Sf_SwigStatic_constants, + swig_SBAddressRangeList_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBAddressRangeList_bases[] = {0}; +static const char *swig_SBAddressRangeList_base_names[] = {0}; +static swig_lua_class _wrap_class_SBAddressRangeList = { "SBAddressRangeList", "SBAddressRangeList", &SWIGTYPE_p_lldb__SBAddressRangeList,_proxy__wrap_new_SBAddressRangeList, swig_delete_SBAddressRangeList, swig_SBAddressRangeList_methods, swig_SBAddressRangeList_attributes, &swig_SBAddressRangeList_Sf_SwigStatic, swig_SBAddressRangeList_meta, swig_SBAddressRangeList_bases, swig_SBAddressRangeList_base_names }; + +static int _wrap_new_SBAttachInfo__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *result = 0 ; + + SWIG_check_num_args("lldb::SBAttachInfo::SBAttachInfo",0,0) + result = (lldb::SBAttachInfo *)new lldb::SBAttachInfo(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBAttachInfo,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBAttachInfo__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::pid_t arg1 ; + lldb::SBAttachInfo *result = 0 ; + + SWIG_check_num_args("lldb::SBAttachInfo::SBAttachInfo",1,1) + if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SBAttachInfo",1,"lldb::pid_t"); + arg1 = (lldb::pid_t)lua_tointeger(L, 1); + result = (lldb::SBAttachInfo *)new lldb::SBAttachInfo(arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBAttachInfo,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBAttachInfo__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + bool arg2 ; + lldb::SBAttachInfo *result = 0 ; + + SWIG_check_num_args("lldb::SBAttachInfo::SBAttachInfo",2,2) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SBAttachInfo",1,"char const *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBAttachInfo::SBAttachInfo",2,"bool"); + arg1 = (char *)lua_tostring(L, 1); + arg2 = (lua_toboolean(L, 2)!=0); + result = (lldb::SBAttachInfo *)new lldb::SBAttachInfo((char const *)arg1,arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBAttachInfo,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBAttachInfo__SWIG_3(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + bool arg2 ; + bool arg3 ; + lldb::SBAttachInfo *result = 0 ; + + SWIG_check_num_args("lldb::SBAttachInfo::SBAttachInfo",3,3) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SBAttachInfo",1,"char const *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBAttachInfo::SBAttachInfo",2,"bool"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBAttachInfo::SBAttachInfo",3,"bool"); + arg1 = (char *)lua_tostring(L, 1); + arg2 = (lua_toboolean(L, 2)!=0); + arg3 = (lua_toboolean(L, 3)!=0); + result = (lldb::SBAttachInfo *)new lldb::SBAttachInfo((char const *)arg1,arg2,arg3); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBAttachInfo,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBAttachInfo__SWIG_4(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = 0 ; + lldb::SBAttachInfo *result = 0 ; + + SWIG_check_num_args("lldb::SBAttachInfo::SBAttachInfo",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SBAttachInfo",1,"lldb::SBAttachInfo const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("new_SBAttachInfo",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + result = (lldb::SBAttachInfo *)new lldb::SBAttachInfo((lldb::SBAttachInfo const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBAttachInfo,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBAttachInfo(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBAttachInfo__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBAttachInfo, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBAttachInfo__SWIG_4(L); + } + } + if (argc == 1) { + int _v = 0; + { + _v = lua_isnumber(L,argv[0]); + } + if (_v) { + return _wrap_new_SBAttachInfo__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + _v = SWIG_lua_isnilstring(L,argv[0]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[1]); + } + if (_v) { + return _wrap_new_SBAttachInfo__SWIG_2(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + _v = SWIG_lua_isnilstring(L,argv[0]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[1]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[2]); + } + if (_v) { + return _wrap_new_SBAttachInfo__SWIG_3(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBAttachInfo_GetProcessID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::pid_t result; + + SWIG_check_num_args("lldb::SBAttachInfo::GetProcessID",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::GetProcessID",1,"lldb::SBAttachInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_GetProcessID",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + result = (lldb::pid_t)(arg1)->GetProcessID(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAttachInfo_SetProcessID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::pid_t arg2 ; + + SWIG_check_num_args("lldb::SBAttachInfo::SetProcessID",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SetProcessID",1,"lldb::SBAttachInfo *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBAttachInfo::SetProcessID",2,"lldb::pid_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_SetProcessID",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + arg2 = (lldb::pid_t)lua_tointeger(L, 2); + (arg1)->SetProcessID(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAttachInfo_SetExecutable__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBAttachInfo::SetExecutable",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SetExecutable",1,"lldb::SBAttachInfo *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBAttachInfo::SetExecutable",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_SetExecutable",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetExecutable((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAttachInfo_SetExecutable__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBFileSpec arg2 ; + lldb::SBFileSpec *argp2 ; + + SWIG_check_num_args("lldb::SBAttachInfo::SetExecutable",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SetExecutable",1,"lldb::SBAttachInfo *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBAttachInfo::SetExecutable",2,"lldb::SBFileSpec"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_SetExecutable",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBAttachInfo_SetExecutable",2,SWIGTYPE_p_lldb__SBFileSpec); + } + arg2 = *argp2; + + (arg1)->SetExecutable(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAttachInfo_SetExecutable(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBAttachInfo, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBAttachInfo_SetExecutable__SWIG_1(L); + } + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBAttachInfo, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + return _wrap_SBAttachInfo_SetExecutable__SWIG_0(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBAttachInfo_GetWaitForLaunch(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBAttachInfo::GetWaitForLaunch",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::GetWaitForLaunch",1,"lldb::SBAttachInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_GetWaitForLaunch",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + result = (bool)(arg1)->GetWaitForLaunch(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAttachInfo_SetWaitForLaunch__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBAttachInfo::SetWaitForLaunch",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SetWaitForLaunch",1,"lldb::SBAttachInfo *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBAttachInfo::SetWaitForLaunch",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_SetWaitForLaunch",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetWaitForLaunch(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAttachInfo_SetWaitForLaunch__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + bool arg2 ; + bool arg3 ; + + SWIG_check_num_args("lldb::SBAttachInfo::SetWaitForLaunch",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SetWaitForLaunch",1,"lldb::SBAttachInfo *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBAttachInfo::SetWaitForLaunch",2,"bool"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBAttachInfo::SetWaitForLaunch",3,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_SetWaitForLaunch",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + arg2 = (lua_toboolean(L, 2)!=0); + arg3 = (lua_toboolean(L, 3)!=0); + (arg1)->SetWaitForLaunch(arg2,arg3); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAttachInfo_SetWaitForLaunch(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBAttachInfo, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[1]); + } + if (_v) { + return _wrap_SBAttachInfo_SetWaitForLaunch__SWIG_0(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBAttachInfo, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[1]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[2]); + } + if (_v) { + return _wrap_SBAttachInfo_SetWaitForLaunch__SWIG_1(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBAttachInfo_SetWaitForLaunch'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBAttachInfo::SetWaitForLaunch(bool)\n" + " lldb::SBAttachInfo::SetWaitForLaunch(bool,bool)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBAttachInfo_GetIgnoreExisting(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBAttachInfo::GetIgnoreExisting",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::GetIgnoreExisting",1,"lldb::SBAttachInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_GetIgnoreExisting",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + result = (bool)(arg1)->GetIgnoreExisting(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAttachInfo_SetIgnoreExisting(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBAttachInfo::SetIgnoreExisting",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SetIgnoreExisting",1,"lldb::SBAttachInfo *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBAttachInfo::SetIgnoreExisting",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_SetIgnoreExisting",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetIgnoreExisting(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAttachInfo_GetResumeCount(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBAttachInfo::GetResumeCount",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::GetResumeCount",1,"lldb::SBAttachInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_GetResumeCount",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + result = (uint32_t)(arg1)->GetResumeCount(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAttachInfo_SetResumeCount(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + uint32_t arg2 ; + + SWIG_check_num_args("lldb::SBAttachInfo::SetResumeCount",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SetResumeCount",1,"lldb::SBAttachInfo *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBAttachInfo::SetResumeCount",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_SetResumeCount",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + (arg1)->SetResumeCount(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAttachInfo_GetProcessPluginName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBAttachInfo::GetProcessPluginName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::GetProcessPluginName",1,"lldb::SBAttachInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_GetProcessPluginName",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + result = (char *)(arg1)->GetProcessPluginName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAttachInfo_SetProcessPluginName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBAttachInfo::SetProcessPluginName",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SetProcessPluginName",1,"lldb::SBAttachInfo *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBAttachInfo::SetProcessPluginName",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_SetProcessPluginName",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetProcessPluginName((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAttachInfo_GetUserID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBAttachInfo::GetUserID",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::GetUserID",1,"lldb::SBAttachInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_GetUserID",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + result = (uint32_t)(arg1)->GetUserID(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAttachInfo_GetGroupID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBAttachInfo::GetGroupID",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::GetGroupID",1,"lldb::SBAttachInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_GetGroupID",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + result = (uint32_t)(arg1)->GetGroupID(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAttachInfo_UserIDIsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBAttachInfo::UserIDIsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::UserIDIsValid",1,"lldb::SBAttachInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_UserIDIsValid",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + result = (bool)(arg1)->UserIDIsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAttachInfo_GroupIDIsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBAttachInfo::GroupIDIsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::GroupIDIsValid",1,"lldb::SBAttachInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_GroupIDIsValid",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + result = (bool)(arg1)->GroupIDIsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAttachInfo_SetUserID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + uint32_t arg2 ; + + SWIG_check_num_args("lldb::SBAttachInfo::SetUserID",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SetUserID",1,"lldb::SBAttachInfo *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBAttachInfo::SetUserID",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_SetUserID",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + (arg1)->SetUserID(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAttachInfo_SetGroupID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + uint32_t arg2 ; + + SWIG_check_num_args("lldb::SBAttachInfo::SetGroupID",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SetGroupID",1,"lldb::SBAttachInfo *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBAttachInfo::SetGroupID",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_SetGroupID",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + (arg1)->SetGroupID(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAttachInfo_GetEffectiveUserID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBAttachInfo::GetEffectiveUserID",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::GetEffectiveUserID",1,"lldb::SBAttachInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_GetEffectiveUserID",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + result = (uint32_t)(arg1)->GetEffectiveUserID(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAttachInfo_GetEffectiveGroupID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBAttachInfo::GetEffectiveGroupID",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::GetEffectiveGroupID",1,"lldb::SBAttachInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_GetEffectiveGroupID",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + result = (uint32_t)(arg1)->GetEffectiveGroupID(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAttachInfo_EffectiveUserIDIsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBAttachInfo::EffectiveUserIDIsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::EffectiveUserIDIsValid",1,"lldb::SBAttachInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_EffectiveUserIDIsValid",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + result = (bool)(arg1)->EffectiveUserIDIsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAttachInfo_EffectiveGroupIDIsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBAttachInfo::EffectiveGroupIDIsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::EffectiveGroupIDIsValid",1,"lldb::SBAttachInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_EffectiveGroupIDIsValid",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + result = (bool)(arg1)->EffectiveGroupIDIsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAttachInfo_SetEffectiveUserID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + uint32_t arg2 ; + + SWIG_check_num_args("lldb::SBAttachInfo::SetEffectiveUserID",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SetEffectiveUserID",1,"lldb::SBAttachInfo *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBAttachInfo::SetEffectiveUserID",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_SetEffectiveUserID",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + (arg1)->SetEffectiveUserID(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAttachInfo_SetEffectiveGroupID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + uint32_t arg2 ; + + SWIG_check_num_args("lldb::SBAttachInfo::SetEffectiveGroupID",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SetEffectiveGroupID",1,"lldb::SBAttachInfo *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBAttachInfo::SetEffectiveGroupID",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_SetEffectiveGroupID",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + (arg1)->SetEffectiveGroupID(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAttachInfo_GetParentProcessID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::pid_t result; + + SWIG_check_num_args("lldb::SBAttachInfo::GetParentProcessID",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::GetParentProcessID",1,"lldb::SBAttachInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_GetParentProcessID",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + result = (lldb::pid_t)(arg1)->GetParentProcessID(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAttachInfo_SetParentProcessID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::pid_t arg2 ; + + SWIG_check_num_args("lldb::SBAttachInfo::SetParentProcessID",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SetParentProcessID",1,"lldb::SBAttachInfo *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBAttachInfo::SetParentProcessID",2,"lldb::pid_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_SetParentProcessID",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + arg2 = (lldb::pid_t)lua_tointeger(L, 2); + (arg1)->SetParentProcessID(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAttachInfo_ParentProcessIDIsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBAttachInfo::ParentProcessIDIsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::ParentProcessIDIsValid",1,"lldb::SBAttachInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_ParentProcessIDIsValid",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + result = (bool)(arg1)->ParentProcessIDIsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAttachInfo_GetListener(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBListener result; + + SWIG_check_num_args("lldb::SBAttachInfo::GetListener",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::GetListener",1,"lldb::SBAttachInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_GetListener",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + result = (arg1)->GetListener(); + { + lldb::SBListener * resultptr = new lldb::SBListener(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBListener,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAttachInfo_SetListener(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBListener *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBAttachInfo::SetListener",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SetListener",1,"lldb::SBAttachInfo *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBAttachInfo::SetListener",2,"lldb::SBListener &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_SetListener",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBListener,0))){ + SWIG_fail_ptr("SBAttachInfo_SetListener",2,SWIGTYPE_p_lldb__SBListener); + } + + (arg1)->SetListener(*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAttachInfo_GetShadowListener(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBListener result; + + SWIG_check_num_args("lldb::SBAttachInfo::GetShadowListener",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::GetShadowListener",1,"lldb::SBAttachInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_GetShadowListener",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + result = (arg1)->GetShadowListener(); + { + lldb::SBListener * resultptr = new lldb::SBListener(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBListener,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAttachInfo_SetShadowListener(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBListener *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBAttachInfo::SetShadowListener",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SetShadowListener",1,"lldb::SBAttachInfo *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBAttachInfo::SetShadowListener",2,"lldb::SBListener &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_SetShadowListener",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBListener,0))){ + SWIG_fail_ptr("SBAttachInfo_SetShadowListener",2,SWIGTYPE_p_lldb__SBListener); + } + + (arg1)->SetShadowListener(*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAttachInfo_GetScriptedProcessClassName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBAttachInfo::GetScriptedProcessClassName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::GetScriptedProcessClassName",1,"lldb::SBAttachInfo const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_GetScriptedProcessClassName",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + result = (char *)((lldb::SBAttachInfo const *)arg1)->GetScriptedProcessClassName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAttachInfo_SetScriptedProcessClassName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBAttachInfo::SetScriptedProcessClassName",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SetScriptedProcessClassName",1,"lldb::SBAttachInfo *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBAttachInfo::SetScriptedProcessClassName",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_SetScriptedProcessClassName",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetScriptedProcessClassName((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAttachInfo_GetScriptedProcessDictionary(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBStructuredData result; + + SWIG_check_num_args("lldb::SBAttachInfo::GetScriptedProcessDictionary",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::GetScriptedProcessDictionary",1,"lldb::SBAttachInfo const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_GetScriptedProcessDictionary",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + result = ((lldb::SBAttachInfo const *)arg1)->GetScriptedProcessDictionary(); + { + lldb::SBStructuredData * resultptr = new lldb::SBStructuredData(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBStructuredData,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBAttachInfo_SetScriptedProcessDictionary(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) 0 ; + lldb::SBStructuredData arg2 ; + lldb::SBStructuredData *argp2 ; + + SWIG_check_num_args("lldb::SBAttachInfo::SetScriptedProcessDictionary",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBAttachInfo::SetScriptedProcessDictionary",1,"lldb::SBAttachInfo *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBAttachInfo::SetScriptedProcessDictionary",2,"lldb::SBStructuredData"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBAttachInfo_SetScriptedProcessDictionary",1,SWIGTYPE_p_lldb__SBAttachInfo); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("SBAttachInfo_SetScriptedProcessDictionary",2,SWIGTYPE_p_lldb__SBStructuredData); + } + arg2 = *argp2; + + (arg1)->SetScriptedProcessDictionary(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBAttachInfo(void *obj) { +lldb::SBAttachInfo *arg1 = (lldb::SBAttachInfo *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBAttachInfo(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBAttachInfo); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBAttachInfo_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBAttachInfo_methods[]= { + { "GetProcessID", _wrap_SBAttachInfo_GetProcessID}, + { "SetProcessID", _wrap_SBAttachInfo_SetProcessID}, + { "SetExecutable", _wrap_SBAttachInfo_SetExecutable}, + { "GetWaitForLaunch", _wrap_SBAttachInfo_GetWaitForLaunch}, + { "SetWaitForLaunch", _wrap_SBAttachInfo_SetWaitForLaunch}, + { "GetIgnoreExisting", _wrap_SBAttachInfo_GetIgnoreExisting}, + { "SetIgnoreExisting", _wrap_SBAttachInfo_SetIgnoreExisting}, + { "GetResumeCount", _wrap_SBAttachInfo_GetResumeCount}, + { "SetResumeCount", _wrap_SBAttachInfo_SetResumeCount}, + { "GetProcessPluginName", _wrap_SBAttachInfo_GetProcessPluginName}, + { "SetProcessPluginName", _wrap_SBAttachInfo_SetProcessPluginName}, + { "GetUserID", _wrap_SBAttachInfo_GetUserID}, + { "GetGroupID", _wrap_SBAttachInfo_GetGroupID}, + { "UserIDIsValid", _wrap_SBAttachInfo_UserIDIsValid}, + { "GroupIDIsValid", _wrap_SBAttachInfo_GroupIDIsValid}, + { "SetUserID", _wrap_SBAttachInfo_SetUserID}, + { "SetGroupID", _wrap_SBAttachInfo_SetGroupID}, + { "GetEffectiveUserID", _wrap_SBAttachInfo_GetEffectiveUserID}, + { "GetEffectiveGroupID", _wrap_SBAttachInfo_GetEffectiveGroupID}, + { "EffectiveUserIDIsValid", _wrap_SBAttachInfo_EffectiveUserIDIsValid}, + { "EffectiveGroupIDIsValid", _wrap_SBAttachInfo_EffectiveGroupIDIsValid}, + { "SetEffectiveUserID", _wrap_SBAttachInfo_SetEffectiveUserID}, + { "SetEffectiveGroupID", _wrap_SBAttachInfo_SetEffectiveGroupID}, + { "GetParentProcessID", _wrap_SBAttachInfo_GetParentProcessID}, + { "SetParentProcessID", _wrap_SBAttachInfo_SetParentProcessID}, + { "ParentProcessIDIsValid", _wrap_SBAttachInfo_ParentProcessIDIsValid}, + { "GetListener", _wrap_SBAttachInfo_GetListener}, + { "SetListener", _wrap_SBAttachInfo_SetListener}, + { "GetShadowListener", _wrap_SBAttachInfo_GetShadowListener}, + { "SetShadowListener", _wrap_SBAttachInfo_SetShadowListener}, + { "GetScriptedProcessClassName", _wrap_SBAttachInfo_GetScriptedProcessClassName}, + { "SetScriptedProcessClassName", _wrap_SBAttachInfo_SetScriptedProcessClassName}, + { "GetScriptedProcessDictionary", _wrap_SBAttachInfo_GetScriptedProcessDictionary}, + { "SetScriptedProcessDictionary", _wrap_SBAttachInfo_SetScriptedProcessDictionary}, + {0,0} +}; +static swig_lua_method swig_SBAttachInfo_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBAttachInfo_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBAttachInfo_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBAttachInfo_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBAttachInfo_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBAttachInfo_Sf_SwigStatic = { + "SBAttachInfo", + swig_SBAttachInfo_Sf_SwigStatic_methods, + swig_SBAttachInfo_Sf_SwigStatic_attributes, + swig_SBAttachInfo_Sf_SwigStatic_constants, + swig_SBAttachInfo_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBAttachInfo_bases[] = {0}; +static const char *swig_SBAttachInfo_base_names[] = {0}; +static swig_lua_class _wrap_class_SBAttachInfo = { "SBAttachInfo", "SBAttachInfo", &SWIGTYPE_p_lldb__SBAttachInfo,_proxy__wrap_new_SBAttachInfo, swig_delete_SBAttachInfo, swig_SBAttachInfo_methods, swig_SBAttachInfo_attributes, &swig_SBAttachInfo_Sf_SwigStatic, swig_SBAttachInfo_meta, swig_SBAttachInfo_bases, swig_SBAttachInfo_base_names }; + +static int _wrap_new_SBBlock__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBlock *result = 0 ; + + SWIG_check_num_args("lldb::SBBlock::SBBlock",0,0) + result = (lldb::SBBlock *)new lldb::SBBlock(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBBlock,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBBlock__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBlock *arg1 = 0 ; + lldb::SBBlock *result = 0 ; + + SWIG_check_num_args("lldb::SBBlock::SBBlock",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBBlock::SBBlock",1,"lldb::SBBlock const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){ + SWIG_fail_ptr("new_SBBlock",1,SWIGTYPE_p_lldb__SBBlock); + } + + result = (lldb::SBBlock *)new lldb::SBBlock((lldb::SBBlock const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBBlock,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBBlock(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBBlock__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBlock, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBBlock__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBBlock'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBBlock::SBBlock()\n" + " lldb::SBBlock::SBBlock(lldb::SBBlock const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBBlock_IsInlined(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBBlock::IsInlined",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::IsInlined",1,"lldb::SBBlock const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){ + SWIG_fail_ptr("SBBlock_IsInlined",1,SWIGTYPE_p_lldb__SBBlock); + } + + result = (bool)((lldb::SBBlock const *)arg1)->IsInlined(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBlock_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBBlock::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::IsValid",1,"lldb::SBBlock const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){ + SWIG_fail_ptr("SBBlock_IsValid",1,SWIGTYPE_p_lldb__SBBlock); + } + + result = (bool)((lldb::SBBlock const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBlock_GetInlinedName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBBlock::GetInlinedName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::GetInlinedName",1,"lldb::SBBlock const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){ + SWIG_fail_ptr("SBBlock_GetInlinedName",1,SWIGTYPE_p_lldb__SBBlock); + } + + result = (char *)((lldb::SBBlock const *)arg1)->GetInlinedName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBlock_GetInlinedCallSiteFile(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + lldb::SBFileSpec result; + + SWIG_check_num_args("lldb::SBBlock::GetInlinedCallSiteFile",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::GetInlinedCallSiteFile",1,"lldb::SBBlock const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){ + SWIG_fail_ptr("SBBlock_GetInlinedCallSiteFile",1,SWIGTYPE_p_lldb__SBBlock); + } + + result = ((lldb::SBBlock const *)arg1)->GetInlinedCallSiteFile(); + { + lldb::SBFileSpec * resultptr = new lldb::SBFileSpec(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBlock_GetInlinedCallSiteLine(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBBlock::GetInlinedCallSiteLine",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::GetInlinedCallSiteLine",1,"lldb::SBBlock const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){ + SWIG_fail_ptr("SBBlock_GetInlinedCallSiteLine",1,SWIGTYPE_p_lldb__SBBlock); + } + + result = (uint32_t)((lldb::SBBlock const *)arg1)->GetInlinedCallSiteLine(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBlock_GetInlinedCallSiteColumn(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBBlock::GetInlinedCallSiteColumn",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::GetInlinedCallSiteColumn",1,"lldb::SBBlock const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){ + SWIG_fail_ptr("SBBlock_GetInlinedCallSiteColumn",1,SWIGTYPE_p_lldb__SBBlock); + } + + result = (uint32_t)((lldb::SBBlock const *)arg1)->GetInlinedCallSiteColumn(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBlock_GetParent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + lldb::SBBlock result; + + SWIG_check_num_args("lldb::SBBlock::GetParent",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::GetParent",1,"lldb::SBBlock *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){ + SWIG_fail_ptr("SBBlock_GetParent",1,SWIGTYPE_p_lldb__SBBlock); + } + + result = (arg1)->GetParent(); + { + lldb::SBBlock * resultptr = new lldb::SBBlock(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBlock,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBlock_GetSibling(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + lldb::SBBlock result; + + SWIG_check_num_args("lldb::SBBlock::GetSibling",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::GetSibling",1,"lldb::SBBlock *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){ + SWIG_fail_ptr("SBBlock_GetSibling",1,SWIGTYPE_p_lldb__SBBlock); + } + + result = (arg1)->GetSibling(); + { + lldb::SBBlock * resultptr = new lldb::SBBlock(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBlock,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBlock_GetFirstChild(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + lldb::SBBlock result; + + SWIG_check_num_args("lldb::SBBlock::GetFirstChild",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::GetFirstChild",1,"lldb::SBBlock *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){ + SWIG_fail_ptr("SBBlock_GetFirstChild",1,SWIGTYPE_p_lldb__SBBlock); + } + + result = (arg1)->GetFirstChild(); + { + lldb::SBBlock * resultptr = new lldb::SBBlock(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBlock,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBlock_GetNumRanges(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBBlock::GetNumRanges",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::GetNumRanges",1,"lldb::SBBlock *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){ + SWIG_fail_ptr("SBBlock_GetNumRanges",1,SWIGTYPE_p_lldb__SBBlock); + } + + result = (uint32_t)(arg1)->GetNumRanges(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBlock_GetRangeStartAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + uint32_t arg2 ; + lldb::SBAddress result; + + SWIG_check_num_args("lldb::SBBlock::GetRangeStartAddress",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::GetRangeStartAddress",1,"lldb::SBBlock *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBlock::GetRangeStartAddress",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){ + SWIG_fail_ptr("SBBlock_GetRangeStartAddress",1,SWIGTYPE_p_lldb__SBBlock); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetRangeStartAddress(arg2); + { + lldb::SBAddress * resultptr = new lldb::SBAddress(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBlock_GetRangeEndAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + uint32_t arg2 ; + lldb::SBAddress result; + + SWIG_check_num_args("lldb::SBBlock::GetRangeEndAddress",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::GetRangeEndAddress",1,"lldb::SBBlock *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBlock::GetRangeEndAddress",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){ + SWIG_fail_ptr("SBBlock_GetRangeEndAddress",1,SWIGTYPE_p_lldb__SBBlock); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetRangeEndAddress(arg2); + { + lldb::SBAddress * resultptr = new lldb::SBAddress(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBlock_GetRanges(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + lldb::SBAddressRangeList result; + + SWIG_check_num_args("lldb::SBBlock::GetRanges",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::GetRanges",1,"lldb::SBBlock *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){ + SWIG_fail_ptr("SBBlock_GetRanges",1,SWIGTYPE_p_lldb__SBBlock); + } + + result = (arg1)->GetRanges(); + { + lldb::SBAddressRangeList * resultptr = new lldb::SBAddressRangeList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddressRangeList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBlock_GetRangeIndexForBlockAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + lldb::SBAddress arg2 ; + lldb::SBAddress *argp2 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBBlock::GetRangeIndexForBlockAddress",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::GetRangeIndexForBlockAddress",1,"lldb::SBBlock *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBlock::GetRangeIndexForBlockAddress",2,"lldb::SBAddress"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){ + SWIG_fail_ptr("SBBlock_GetRangeIndexForBlockAddress",1,SWIGTYPE_p_lldb__SBBlock); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBBlock_GetRangeIndexForBlockAddress",2,SWIGTYPE_p_lldb__SBAddress); + } + arg2 = *argp2; + + result = (uint32_t)(arg1)->GetRangeIndexForBlockAddress(arg2); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBlock_GetVariables__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + lldb::SBFrame *arg2 = 0 ; + bool arg3 ; + bool arg4 ; + bool arg5 ; + lldb::DynamicValueType arg6 ; + lldb::SBValueList result; + + SWIG_check_num_args("lldb::SBBlock::GetVariables",6,6) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::GetVariables",1,"lldb::SBBlock *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBlock::GetVariables",2,"lldb::SBFrame &"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBBlock::GetVariables",3,"bool"); + if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBBlock::GetVariables",4,"bool"); + if(!lua_isboolean(L,5)) SWIG_fail_arg("lldb::SBBlock::GetVariables",5,"bool"); + if(!lua_isinteger(L,6)) SWIG_fail_arg("lldb::SBBlock::GetVariables",6,"lldb::DynamicValueType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){ + SWIG_fail_ptr("SBBlock_GetVariables",1,SWIGTYPE_p_lldb__SBBlock); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBBlock_GetVariables",2,SWIGTYPE_p_lldb__SBFrame); + } + + arg3 = (lua_toboolean(L, 3)!=0); + arg4 = (lua_toboolean(L, 4)!=0); + arg5 = (lua_toboolean(L, 5)!=0); + arg6 = (lldb::DynamicValueType)lua_tointeger(L, 6); + result = (arg1)->GetVariables(*arg2,arg3,arg4,arg5,arg6); + { + lldb::SBValueList * resultptr = new lldb::SBValueList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValueList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBlock_GetVariables__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + lldb::SBTarget *arg2 = 0 ; + bool arg3 ; + bool arg4 ; + bool arg5 ; + lldb::SBValueList result; + + SWIG_check_num_args("lldb::SBBlock::GetVariables",5,5) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::GetVariables",1,"lldb::SBBlock *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBlock::GetVariables",2,"lldb::SBTarget &"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBBlock::GetVariables",3,"bool"); + if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBBlock::GetVariables",4,"bool"); + if(!lua_isboolean(L,5)) SWIG_fail_arg("lldb::SBBlock::GetVariables",5,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){ + SWIG_fail_ptr("SBBlock_GetVariables",1,SWIGTYPE_p_lldb__SBBlock); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBBlock_GetVariables",2,SWIGTYPE_p_lldb__SBTarget); + } + + arg3 = (lua_toboolean(L, 3)!=0); + arg4 = (lua_toboolean(L, 4)!=0); + arg5 = (lua_toboolean(L, 5)!=0); + result = (arg1)->GetVariables(*arg2,arg3,arg4,arg5); + { + lldb::SBValueList * resultptr = new lldb::SBValueList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValueList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBlock_GetVariables(lua_State* L) { + int argc; + int argv[7]={ + 1,2,3,4,5,6,7 + }; + + argc = lua_gettop(L); + if (argc == 5) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBlock, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[2]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[3]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[4]); + } + if (_v) { + return _wrap_SBBlock_GetVariables__SWIG_1(L); + } + } + } + } + } + } + if (argc == 6) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBlock, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[2]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[3]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[4]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[5]); + } + if (_v) { + return _wrap_SBBlock_GetVariables__SWIG_0(L); + } + } + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBBlock_GetContainingInlinedBlock(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + lldb::SBBlock result; + + SWIG_check_num_args("lldb::SBBlock::GetContainingInlinedBlock",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::GetContainingInlinedBlock",1,"lldb::SBBlock *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){ + SWIG_fail_ptr("SBBlock_GetContainingInlinedBlock",1,SWIGTYPE_p_lldb__SBBlock); + } + + result = (arg1)->GetContainingInlinedBlock(); + { + lldb::SBBlock * resultptr = new lldb::SBBlock(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBlock,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBlock_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBBlock::GetDescription",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::GetDescription",1,"lldb::SBBlock *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBlock::GetDescription",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){ + SWIG_fail_ptr("SBBlock_GetDescription",1,SWIGTYPE_p_lldb__SBBlock); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBBlock_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)(arg1)->GetDescription(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBlock___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBlock *arg1 = (lldb::SBBlock *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBBlock::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBlock::__repr__",1,"lldb::SBBlock *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBlock,0))){ + SWIG_fail_ptr("SBBlock___tostring",1,SWIGTYPE_p_lldb__SBBlock); + } + + result = lldb_SBBlock___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBBlock(void *obj) { +lldb::SBBlock *arg1 = (lldb::SBBlock *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBBlock(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBBlock); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBBlock_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBBlock_methods[]= { + { "IsInlined", _wrap_SBBlock_IsInlined}, + { "IsValid", _wrap_SBBlock_IsValid}, + { "GetInlinedName", _wrap_SBBlock_GetInlinedName}, + { "GetInlinedCallSiteFile", _wrap_SBBlock_GetInlinedCallSiteFile}, + { "GetInlinedCallSiteLine", _wrap_SBBlock_GetInlinedCallSiteLine}, + { "GetInlinedCallSiteColumn", _wrap_SBBlock_GetInlinedCallSiteColumn}, + { "GetParent", _wrap_SBBlock_GetParent}, + { "GetSibling", _wrap_SBBlock_GetSibling}, + { "GetFirstChild", _wrap_SBBlock_GetFirstChild}, + { "GetNumRanges", _wrap_SBBlock_GetNumRanges}, + { "GetRangeStartAddress", _wrap_SBBlock_GetRangeStartAddress}, + { "GetRangeEndAddress", _wrap_SBBlock_GetRangeEndAddress}, + { "GetRanges", _wrap_SBBlock_GetRanges}, + { "GetRangeIndexForBlockAddress", _wrap_SBBlock_GetRangeIndexForBlockAddress}, + { "GetVariables", _wrap_SBBlock_GetVariables}, + { "GetContainingInlinedBlock", _wrap_SBBlock_GetContainingInlinedBlock}, + { "GetDescription", _wrap_SBBlock_GetDescription}, + { "__tostring", _wrap_SBBlock___tostring}, + {0,0} +}; +static swig_lua_method swig_SBBlock_meta[] = { + { "__tostring", _wrap_SBBlock___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBBlock_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBBlock_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBBlock_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBBlock_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBBlock_Sf_SwigStatic = { + "SBBlock", + swig_SBBlock_Sf_SwigStatic_methods, + swig_SBBlock_Sf_SwigStatic_attributes, + swig_SBBlock_Sf_SwigStatic_constants, + swig_SBBlock_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBBlock_bases[] = {0}; +static const char *swig_SBBlock_base_names[] = {0}; +static swig_lua_class _wrap_class_SBBlock = { "SBBlock", "SBBlock", &SWIGTYPE_p_lldb__SBBlock,_proxy__wrap_new_SBBlock, swig_delete_SBBlock, swig_SBBlock_methods, swig_SBBlock_attributes, &swig_SBBlock_Sf_SwigStatic, swig_SBBlock_meta, swig_SBBlock_bases, swig_SBBlock_base_names }; + +static int _wrap_new_SBBreakpoint__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *result = 0 ; + + SWIG_check_num_args("lldb::SBBreakpoint::SBBreakpoint",0,0) + result = (lldb::SBBreakpoint *)new lldb::SBBreakpoint(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBBreakpoint__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = 0 ; + lldb::SBBreakpoint *result = 0 ; + + SWIG_check_num_args("lldb::SBBreakpoint::SBBreakpoint",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::SBBreakpoint",1,"lldb::SBBreakpoint const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("new_SBBreakpoint",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + result = (lldb::SBBreakpoint *)new lldb::SBBreakpoint((lldb::SBBreakpoint const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBBreakpoint(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBBreakpoint__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBBreakpoint__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBBreakpoint'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBBreakpoint::SBBreakpoint()\n" + " lldb::SBBreakpoint::SBBreakpoint(lldb::SBBreakpoint const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBBreakpoint___eq(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBBreakpoint *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBBreakpoint::operator ==",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::operator ==",1,"lldb::SBBreakpoint *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::operator ==",2,"lldb::SBBreakpoint const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint___eq",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint___eq",2,SWIGTYPE_p_lldb__SBBreakpoint); + } + + result = (bool)(arg1)->operator ==((lldb::SBBreakpoint const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_GetID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::break_id_t result; + + SWIG_check_num_args("lldb::SBBreakpoint::GetID",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetID",1,"lldb::SBBreakpoint const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_GetID",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + result = (lldb::break_id_t)((lldb::SBBreakpoint const *)arg1)->GetID(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBBreakpoint::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::IsValid",1,"lldb::SBBreakpoint const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_IsValid",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + result = (bool)((lldb::SBBreakpoint const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_ClearAllBreakpointSites(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + + SWIG_check_num_args("lldb::SBBreakpoint::ClearAllBreakpointSites",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::ClearAllBreakpointSites",1,"lldb::SBBreakpoint *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_ClearAllBreakpointSites",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + (arg1)->ClearAllBreakpointSites(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_GetTarget(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBTarget result; + + SWIG_check_num_args("lldb::SBBreakpoint::GetTarget",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetTarget",1,"lldb::SBBreakpoint const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_GetTarget",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + result = ((lldb::SBBreakpoint const *)arg1)->GetTarget(); + { + lldb::SBTarget * resultptr = new lldb::SBTarget(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTarget,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_FindLocationByAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::addr_t arg2 ; + lldb::SBBreakpointLocation result; + + SWIG_check_num_args("lldb::SBBreakpoint::FindLocationByAddress",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::FindLocationByAddress",1,"lldb::SBBreakpoint *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::FindLocationByAddress",2,"lldb::addr_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_FindLocationByAddress",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + arg2 = (lldb::addr_t)lua_tointeger(L, 2); + result = (arg1)->FindLocationByAddress(arg2); + { + lldb::SBBreakpointLocation * resultptr = new lldb::SBBreakpointLocation(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpointLocation,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_FindLocationIDByAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::addr_t arg2 ; + lldb::break_id_t result; + + SWIG_check_num_args("lldb::SBBreakpoint::FindLocationIDByAddress",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::FindLocationIDByAddress",1,"lldb::SBBreakpoint *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::FindLocationIDByAddress",2,"lldb::addr_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_FindLocationIDByAddress",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + arg2 = (lldb::addr_t)lua_tointeger(L, 2); + result = (lldb::break_id_t)(arg1)->FindLocationIDByAddress(arg2); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_FindLocationByID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::break_id_t arg2 ; + lldb::SBBreakpointLocation result; + + SWIG_check_num_args("lldb::SBBreakpoint::FindLocationByID",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::FindLocationByID",1,"lldb::SBBreakpoint *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::FindLocationByID",2,"lldb::break_id_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_FindLocationByID",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + arg2 = (lldb::break_id_t)lua_tointeger(L, 2); + result = (arg1)->FindLocationByID(arg2); + { + lldb::SBBreakpointLocation * resultptr = new lldb::SBBreakpointLocation(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpointLocation,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_GetLocationAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + uint32_t arg2 ; + lldb::SBBreakpointLocation result; + + SWIG_check_num_args("lldb::SBBreakpoint::GetLocationAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetLocationAtIndex",1,"lldb::SBBreakpoint *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::GetLocationAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_GetLocationAtIndex",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetLocationAtIndex(arg2); + { + lldb::SBBreakpointLocation * resultptr = new lldb::SBBreakpointLocation(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpointLocation,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_SetEnabled(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBBreakpoint::SetEnabled",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::SetEnabled",1,"lldb::SBBreakpoint *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::SetEnabled",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_SetEnabled",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetEnabled(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_IsEnabled(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBBreakpoint::IsEnabled",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::IsEnabled",1,"lldb::SBBreakpoint *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_IsEnabled",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + result = (bool)(arg1)->IsEnabled(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_SetOneShot(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBBreakpoint::SetOneShot",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::SetOneShot",1,"lldb::SBBreakpoint *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::SetOneShot",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_SetOneShot",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetOneShot(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_IsOneShot(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBBreakpoint::IsOneShot",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::IsOneShot",1,"lldb::SBBreakpoint const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_IsOneShot",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + result = (bool)((lldb::SBBreakpoint const *)arg1)->IsOneShot(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_IsInternal(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBBreakpoint::IsInternal",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::IsInternal",1,"lldb::SBBreakpoint *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_IsInternal",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + result = (bool)(arg1)->IsInternal(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_GetHitCount(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBBreakpoint::GetHitCount",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetHitCount",1,"lldb::SBBreakpoint const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_GetHitCount",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + result = (uint32_t)((lldb::SBBreakpoint const *)arg1)->GetHitCount(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_SetIgnoreCount(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + uint32_t arg2 ; + + SWIG_check_num_args("lldb::SBBreakpoint::SetIgnoreCount",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::SetIgnoreCount",1,"lldb::SBBreakpoint *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::SetIgnoreCount",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_SetIgnoreCount",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + (arg1)->SetIgnoreCount(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_GetIgnoreCount(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBBreakpoint::GetIgnoreCount",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetIgnoreCount",1,"lldb::SBBreakpoint const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_GetIgnoreCount",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + result = (uint32_t)((lldb::SBBreakpoint const *)arg1)->GetIgnoreCount(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_SetCondition(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBBreakpoint::SetCondition",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::SetCondition",1,"lldb::SBBreakpoint *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::SetCondition",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_SetCondition",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetCondition((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_GetCondition(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBBreakpoint::GetCondition",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetCondition",1,"lldb::SBBreakpoint *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_GetCondition",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + result = (char *)(arg1)->GetCondition(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_SetAutoContinue(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBBreakpoint::SetAutoContinue",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::SetAutoContinue",1,"lldb::SBBreakpoint *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::SetAutoContinue",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_SetAutoContinue",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetAutoContinue(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_GetAutoContinue(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBBreakpoint::GetAutoContinue",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetAutoContinue",1,"lldb::SBBreakpoint *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_GetAutoContinue",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + result = (bool)(arg1)->GetAutoContinue(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_SetThreadID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::tid_t arg2 ; + + SWIG_check_num_args("lldb::SBBreakpoint::SetThreadID",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::SetThreadID",1,"lldb::SBBreakpoint *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::SetThreadID",2,"lldb::tid_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_SetThreadID",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + arg2 = (lldb::tid_t)lua_tointeger(L, 2); + (arg1)->SetThreadID(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_GetThreadID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::tid_t result; + + SWIG_check_num_args("lldb::SBBreakpoint::GetThreadID",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetThreadID",1,"lldb::SBBreakpoint *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_GetThreadID",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + result = (lldb::tid_t)(arg1)->GetThreadID(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_SetThreadIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + uint32_t arg2 ; + + SWIG_check_num_args("lldb::SBBreakpoint::SetThreadIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::SetThreadIndex",1,"lldb::SBBreakpoint *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::SetThreadIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_SetThreadIndex",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + (arg1)->SetThreadIndex(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_GetThreadIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBBreakpoint::GetThreadIndex",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetThreadIndex",1,"lldb::SBBreakpoint const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_GetThreadIndex",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + result = (uint32_t)((lldb::SBBreakpoint const *)arg1)->GetThreadIndex(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_SetThreadName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBBreakpoint::SetThreadName",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::SetThreadName",1,"lldb::SBBreakpoint *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::SetThreadName",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_SetThreadName",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetThreadName((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_GetThreadName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBBreakpoint::GetThreadName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetThreadName",1,"lldb::SBBreakpoint const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_GetThreadName",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + result = (char *)((lldb::SBBreakpoint const *)arg1)->GetThreadName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_SetQueueName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBBreakpoint::SetQueueName",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::SetQueueName",1,"lldb::SBBreakpoint *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::SetQueueName",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_SetQueueName",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetQueueName((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_GetQueueName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBBreakpoint::GetQueueName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetQueueName",1,"lldb::SBBreakpoint const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_GetQueueName",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + result = (char *)((lldb::SBBreakpoint const *)arg1)->GetQueueName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_SetScriptCallbackFunction__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBBreakpoint::SetScriptCallbackFunction",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::SetScriptCallbackFunction",1,"lldb::SBBreakpoint *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::SetScriptCallbackFunction",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_SetScriptCallbackFunction",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetScriptCallbackFunction((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_SetScriptCallbackFunction__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBStructuredData *arg3 = 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBBreakpoint::SetScriptCallbackFunction",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::SetScriptCallbackFunction",1,"lldb::SBBreakpoint *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::SetScriptCallbackFunction",2,"char const *"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBBreakpoint::SetScriptCallbackFunction",3,"lldb::SBStructuredData &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_SetScriptCallbackFunction",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + arg2 = (char *)lua_tostring(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("SBBreakpoint_SetScriptCallbackFunction",3,SWIGTYPE_p_lldb__SBStructuredData); + } + + result = (arg1)->SetScriptCallbackFunction((char const *)arg2,*arg3); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_SetScriptCallbackFunction(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBreakpoint, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + return _wrap_SBBreakpoint_SetScriptCallbackFunction__SWIG_0(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBreakpoint, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBBreakpoint_SetScriptCallbackFunction__SWIG_1(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBBreakpoint_SetCommandLineCommands(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBStringList *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBBreakpoint::SetCommandLineCommands",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::SetCommandLineCommands",1,"lldb::SBBreakpoint *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::SetCommandLineCommands",2,"lldb::SBStringList &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_SetCommandLineCommands",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStringList,0))){ + SWIG_fail_ptr("SBBreakpoint_SetCommandLineCommands",2,SWIGTYPE_p_lldb__SBStringList); + } + + (arg1)->SetCommandLineCommands(*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_GetCommandLineCommands(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBStringList *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBBreakpoint::GetCommandLineCommands",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetCommandLineCommands",1,"lldb::SBBreakpoint *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::GetCommandLineCommands",2,"lldb::SBStringList &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_GetCommandLineCommands",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStringList,0))){ + SWIG_fail_ptr("SBBreakpoint_GetCommandLineCommands",2,SWIGTYPE_p_lldb__SBStringList); + } + + result = (bool)(arg1)->GetCommandLineCommands(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_SetScriptCallbackBody(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBBreakpoint::SetScriptCallbackBody",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::SetScriptCallbackBody",1,"lldb::SBBreakpoint *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::SetScriptCallbackBody",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_SetScriptCallbackBody",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->SetScriptCallbackBody((char const *)arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_AddName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + char *arg2 = (char *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBBreakpoint::AddName",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::AddName",1,"lldb::SBBreakpoint *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::AddName",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_AddName",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (bool)(arg1)->AddName((char const *)arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_AddNameWithErrorHandling(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBBreakpoint::AddNameWithErrorHandling",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::AddNameWithErrorHandling",1,"lldb::SBBreakpoint *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::AddNameWithErrorHandling",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_AddNameWithErrorHandling",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->AddNameWithErrorHandling((char const *)arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_RemoveName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBBreakpoint::RemoveName",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::RemoveName",1,"lldb::SBBreakpoint *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::RemoveName",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_RemoveName",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->RemoveName((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_MatchesName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + char *arg2 = (char *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBBreakpoint::MatchesName",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::MatchesName",1,"lldb::SBBreakpoint *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::MatchesName",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_MatchesName",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (bool)(arg1)->MatchesName((char const *)arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_GetNames(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBStringList *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBBreakpoint::GetNames",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetNames",1,"lldb::SBBreakpoint *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::GetNames",2,"lldb::SBStringList &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_GetNames",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStringList,0))){ + SWIG_fail_ptr("SBBreakpoint_GetNames",2,SWIGTYPE_p_lldb__SBStringList); + } + + (arg1)->GetNames(*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_GetNumResolvedLocations(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + size_t result; + + SWIG_check_num_args("lldb::SBBreakpoint::GetNumResolvedLocations",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetNumResolvedLocations",1,"lldb::SBBreakpoint const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_GetNumResolvedLocations",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + result = ((lldb::SBBreakpoint const *)arg1)->GetNumResolvedLocations(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_GetNumLocations(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + size_t result; + + SWIG_check_num_args("lldb::SBBreakpoint::GetNumLocations",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetNumLocations",1,"lldb::SBBreakpoint const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_GetNumLocations",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + result = ((lldb::SBBreakpoint const *)arg1)->GetNumLocations(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_GetDescription__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBBreakpoint::GetDescription",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetDescription",1,"lldb::SBBreakpoint *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::GetDescription",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_GetDescription",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBBreakpoint_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)(arg1)->GetDescription(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_GetDescription__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool arg3 ; + bool result; + + SWIG_check_num_args("lldb::SBBreakpoint::GetDescription",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetDescription",1,"lldb::SBBreakpoint *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::GetDescription",2,"lldb::SBStream &"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBBreakpoint::GetDescription",3,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_GetDescription",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBBreakpoint_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + arg3 = (lua_toboolean(L, 3)!=0); + result = (bool)(arg1)->GetDescription(*arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_GetDescription(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBreakpoint, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBBreakpoint_GetDescription__SWIG_0(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBreakpoint, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[2]); + } + if (_v) { + return _wrap_SBBreakpoint_GetDescription__SWIG_1(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBBreakpoint_EventIsBreakpointEvent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBBreakpoint::EventIsBreakpointEvent",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::EventIsBreakpointEvent",1,"lldb::SBEvent const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBBreakpoint_EventIsBreakpointEvent",1,SWIGTYPE_p_lldb__SBEvent); + } + + result = (bool)lldb::SBBreakpoint::EventIsBreakpointEvent((lldb::SBEvent const &)*arg1); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_GetBreakpointEventTypeFromEvent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = 0 ; + lldb::BreakpointEventType result; + + SWIG_check_num_args("lldb::SBBreakpoint::GetBreakpointEventTypeFromEvent",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetBreakpointEventTypeFromEvent",1,"lldb::SBEvent const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBBreakpoint_GetBreakpointEventTypeFromEvent",1,SWIGTYPE_p_lldb__SBEvent); + } + + result = (lldb::BreakpointEventType)lldb::SBBreakpoint::GetBreakpointEventTypeFromEvent((lldb::SBEvent const &)*arg1); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_GetBreakpointFromEvent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = 0 ; + lldb::SBBreakpoint result; + + SWIG_check_num_args("lldb::SBBreakpoint::GetBreakpointFromEvent",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetBreakpointFromEvent",1,"lldb::SBEvent const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBBreakpoint_GetBreakpointFromEvent",1,SWIGTYPE_p_lldb__SBEvent); + } + + result = lldb::SBBreakpoint::GetBreakpointFromEvent((lldb::SBEvent const &)*arg1); + { + lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_GetBreakpointLocationAtIndexFromEvent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = 0 ; + uint32_t arg2 ; + lldb::SBBreakpointLocation result; + + SWIG_check_num_args("lldb::SBBreakpoint::GetBreakpointLocationAtIndexFromEvent",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetBreakpointLocationAtIndexFromEvent",1,"lldb::SBEvent const &"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::GetBreakpointLocationAtIndexFromEvent",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBBreakpoint_GetBreakpointLocationAtIndexFromEvent",1,SWIGTYPE_p_lldb__SBEvent); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = lldb::SBBreakpoint::GetBreakpointLocationAtIndexFromEvent((lldb::SBEvent const &)*arg1,arg2); + { + lldb::SBBreakpointLocation * resultptr = new lldb::SBBreakpointLocation(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpointLocation,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_GetNumBreakpointLocationsFromEvent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBBreakpoint::GetNumBreakpointLocationsFromEvent",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::GetNumBreakpointLocationsFromEvent",1,"lldb::SBEvent const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBBreakpoint_GetNumBreakpointLocationsFromEvent",1,SWIGTYPE_p_lldb__SBEvent); + } + + result = (uint32_t)lldb::SBBreakpoint::GetNumBreakpointLocationsFromEvent((lldb::SBEvent const &)*arg1); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_IsHardware(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBBreakpoint::IsHardware",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::IsHardware",1,"lldb::SBBreakpoint const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_IsHardware",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + result = (bool)((lldb::SBBreakpoint const *)arg1)->IsHardware(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_AddLocation(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBAddress *arg2 = 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBBreakpoint::AddLocation",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::AddLocation",1,"lldb::SBBreakpoint *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBreakpoint::AddLocation",2,"lldb::SBAddress &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_AddLocation",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBBreakpoint_AddLocation",2,SWIGTYPE_p_lldb__SBAddress); + } + + result = (arg1)->AddLocation(*arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint_SerializeToStructuredData(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + lldb::SBStructuredData result; + + SWIG_check_num_args("lldb::SBBreakpoint::SerializeToStructuredData",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::SerializeToStructuredData",1,"lldb::SBBreakpoint *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint_SerializeToStructuredData",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + result = (arg1)->SerializeToStructuredData(); + { + lldb::SBStructuredData * resultptr = new lldb::SBStructuredData(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBStructuredData,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpoint___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBBreakpoint::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpoint::__repr__",1,"lldb::SBBreakpoint *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpoint___tostring",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + result = lldb_SBBreakpoint___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBBreakpoint(void *obj) { +lldb::SBBreakpoint *arg1 = (lldb::SBBreakpoint *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBBreakpoint(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBBreakpoint); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBBreakpoint_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBBreakpoint_methods[]= { + { "__eq", _wrap_SBBreakpoint___eq}, + { "GetID", _wrap_SBBreakpoint_GetID}, + { "IsValid", _wrap_SBBreakpoint_IsValid}, + { "ClearAllBreakpointSites", _wrap_SBBreakpoint_ClearAllBreakpointSites}, + { "GetTarget", _wrap_SBBreakpoint_GetTarget}, + { "FindLocationByAddress", _wrap_SBBreakpoint_FindLocationByAddress}, + { "FindLocationIDByAddress", _wrap_SBBreakpoint_FindLocationIDByAddress}, + { "FindLocationByID", _wrap_SBBreakpoint_FindLocationByID}, + { "GetLocationAtIndex", _wrap_SBBreakpoint_GetLocationAtIndex}, + { "SetEnabled", _wrap_SBBreakpoint_SetEnabled}, + { "IsEnabled", _wrap_SBBreakpoint_IsEnabled}, + { "SetOneShot", _wrap_SBBreakpoint_SetOneShot}, + { "IsOneShot", _wrap_SBBreakpoint_IsOneShot}, + { "IsInternal", _wrap_SBBreakpoint_IsInternal}, + { "GetHitCount", _wrap_SBBreakpoint_GetHitCount}, + { "SetIgnoreCount", _wrap_SBBreakpoint_SetIgnoreCount}, + { "GetIgnoreCount", _wrap_SBBreakpoint_GetIgnoreCount}, + { "SetCondition", _wrap_SBBreakpoint_SetCondition}, + { "GetCondition", _wrap_SBBreakpoint_GetCondition}, + { "SetAutoContinue", _wrap_SBBreakpoint_SetAutoContinue}, + { "GetAutoContinue", _wrap_SBBreakpoint_GetAutoContinue}, + { "SetThreadID", _wrap_SBBreakpoint_SetThreadID}, + { "GetThreadID", _wrap_SBBreakpoint_GetThreadID}, + { "SetThreadIndex", _wrap_SBBreakpoint_SetThreadIndex}, + { "GetThreadIndex", _wrap_SBBreakpoint_GetThreadIndex}, + { "SetThreadName", _wrap_SBBreakpoint_SetThreadName}, + { "GetThreadName", _wrap_SBBreakpoint_GetThreadName}, + { "SetQueueName", _wrap_SBBreakpoint_SetQueueName}, + { "GetQueueName", _wrap_SBBreakpoint_GetQueueName}, + { "SetScriptCallbackFunction", _wrap_SBBreakpoint_SetScriptCallbackFunction}, + { "SetCommandLineCommands", _wrap_SBBreakpoint_SetCommandLineCommands}, + { "GetCommandLineCommands", _wrap_SBBreakpoint_GetCommandLineCommands}, + { "SetScriptCallbackBody", _wrap_SBBreakpoint_SetScriptCallbackBody}, + { "AddName", _wrap_SBBreakpoint_AddName}, + { "AddNameWithErrorHandling", _wrap_SBBreakpoint_AddNameWithErrorHandling}, + { "RemoveName", _wrap_SBBreakpoint_RemoveName}, + { "MatchesName", _wrap_SBBreakpoint_MatchesName}, + { "GetNames", _wrap_SBBreakpoint_GetNames}, + { "GetNumResolvedLocations", _wrap_SBBreakpoint_GetNumResolvedLocations}, + { "GetNumLocations", _wrap_SBBreakpoint_GetNumLocations}, + { "GetDescription", _wrap_SBBreakpoint_GetDescription}, + { "IsHardware", _wrap_SBBreakpoint_IsHardware}, + { "AddLocation", _wrap_SBBreakpoint_AddLocation}, + { "SerializeToStructuredData", _wrap_SBBreakpoint_SerializeToStructuredData}, + { "__tostring", _wrap_SBBreakpoint___tostring}, + {0,0} +}; +static swig_lua_method swig_SBBreakpoint_meta[] = { + { "__eq", _wrap_SBBreakpoint___eq}, + { "__tostring", _wrap_SBBreakpoint___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBBreakpoint_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBBreakpoint_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBBreakpoint_Sf_SwigStatic_methods[]= { + { "EventIsBreakpointEvent", _wrap_SBBreakpoint_EventIsBreakpointEvent}, + { "GetBreakpointEventTypeFromEvent", _wrap_SBBreakpoint_GetBreakpointEventTypeFromEvent}, + { "GetBreakpointFromEvent", _wrap_SBBreakpoint_GetBreakpointFromEvent}, + { "GetBreakpointLocationAtIndexFromEvent", _wrap_SBBreakpoint_GetBreakpointLocationAtIndexFromEvent}, + { "GetNumBreakpointLocationsFromEvent", _wrap_SBBreakpoint_GetNumBreakpointLocationsFromEvent}, + {0,0} +}; +static swig_lua_class* swig_SBBreakpoint_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBBreakpoint_Sf_SwigStatic = { + "SBBreakpoint", + swig_SBBreakpoint_Sf_SwigStatic_methods, + swig_SBBreakpoint_Sf_SwigStatic_attributes, + swig_SBBreakpoint_Sf_SwigStatic_constants, + swig_SBBreakpoint_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBBreakpoint_bases[] = {0}; +static const char *swig_SBBreakpoint_base_names[] = {0}; +static swig_lua_class _wrap_class_SBBreakpoint = { "SBBreakpoint", "SBBreakpoint", &SWIGTYPE_p_lldb__SBBreakpoint,_proxy__wrap_new_SBBreakpoint, swig_delete_SBBreakpoint, swig_SBBreakpoint_methods, swig_SBBreakpoint_attributes, &swig_SBBreakpoint_Sf_SwigStatic, swig_SBBreakpoint_meta, swig_SBBreakpoint_bases, swig_SBBreakpoint_base_names }; + +static int _wrap_new_SBBreakpointList(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = 0 ; + lldb::SBBreakpointList *result = 0 ; + + SWIG_check_num_args("lldb::SBBreakpointList::SBBreakpointList",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBBreakpointList::SBBreakpointList",1,"lldb::SBTarget &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("new_SBBreakpointList",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = (lldb::SBBreakpointList *)new lldb::SBBreakpointList(*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBBreakpointList,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointList_GetSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ; + size_t result; + + SWIG_check_num_args("lldb::SBBreakpointList::GetSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointList::GetSize",1,"lldb::SBBreakpointList const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointList,0))){ + SWIG_fail_ptr("SBBreakpointList_GetSize",1,SWIGTYPE_p_lldb__SBBreakpointList); + } + + result = ((lldb::SBBreakpointList const *)arg1)->GetSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointList_GetBreakpointAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ; + size_t arg2 ; + lldb::SBBreakpoint result; + + SWIG_check_num_args("lldb::SBBreakpointList::GetBreakpointAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointList::GetBreakpointAtIndex",1,"lldb::SBBreakpointList *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBreakpointList::GetBreakpointAtIndex",2,"size_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointList,0))){ + SWIG_fail_ptr("SBBreakpointList_GetBreakpointAtIndex",1,SWIGTYPE_p_lldb__SBBreakpointList); + } + + arg2 = (size_t)lua_tointeger(L, 2); + result = (arg1)->GetBreakpointAtIndex(arg2); + { + lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointList_FindBreakpointByID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ; + lldb::break_id_t arg2 ; + lldb::SBBreakpoint result; + + SWIG_check_num_args("lldb::SBBreakpointList::FindBreakpointByID",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointList::FindBreakpointByID",1,"lldb::SBBreakpointList *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBreakpointList::FindBreakpointByID",2,"lldb::break_id_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointList,0))){ + SWIG_fail_ptr("SBBreakpointList_FindBreakpointByID",1,SWIGTYPE_p_lldb__SBBreakpointList); + } + + arg2 = (lldb::break_id_t)lua_tointeger(L, 2); + result = (arg1)->FindBreakpointByID(arg2); + { + lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointList_Append(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ; + lldb::SBBreakpoint *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBBreakpointList::Append",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointList::Append",1,"lldb::SBBreakpointList *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBreakpointList::Append",2,"lldb::SBBreakpoint const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointList,0))){ + SWIG_fail_ptr("SBBreakpointList_Append",1,SWIGTYPE_p_lldb__SBBreakpointList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpointList_Append",2,SWIGTYPE_p_lldb__SBBreakpoint); + } + + (arg1)->Append((lldb::SBBreakpoint const &)*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointList_AppendIfUnique(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ; + lldb::SBBreakpoint *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBBreakpointList::AppendIfUnique",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointList::AppendIfUnique",1,"lldb::SBBreakpointList *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBreakpointList::AppendIfUnique",2,"lldb::SBBreakpoint const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointList,0))){ + SWIG_fail_ptr("SBBreakpointList_AppendIfUnique",1,SWIGTYPE_p_lldb__SBBreakpointList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("SBBreakpointList_AppendIfUnique",2,SWIGTYPE_p_lldb__SBBreakpoint); + } + + result = (bool)(arg1)->AppendIfUnique((lldb::SBBreakpoint const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointList_AppendByID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ; + lldb::break_id_t arg2 ; + + SWIG_check_num_args("lldb::SBBreakpointList::AppendByID",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointList::AppendByID",1,"lldb::SBBreakpointList *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBreakpointList::AppendByID",2,"lldb::break_id_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointList,0))){ + SWIG_fail_ptr("SBBreakpointList_AppendByID",1,SWIGTYPE_p_lldb__SBBreakpointList); + } + + arg2 = (lldb::break_id_t)lua_tointeger(L, 2); + (arg1)->AppendByID(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointList_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) 0 ; + + SWIG_check_num_args("lldb::SBBreakpointList::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointList::Clear",1,"lldb::SBBreakpointList *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointList,0))){ + SWIG_fail_ptr("SBBreakpointList_Clear",1,SWIGTYPE_p_lldb__SBBreakpointList); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBBreakpointList(void *obj) { +lldb::SBBreakpointList *arg1 = (lldb::SBBreakpointList *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBBreakpointList(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBBreakpointList); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBBreakpointList_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBBreakpointList_methods[]= { + { "GetSize", _wrap_SBBreakpointList_GetSize}, + { "GetBreakpointAtIndex", _wrap_SBBreakpointList_GetBreakpointAtIndex}, + { "FindBreakpointByID", _wrap_SBBreakpointList_FindBreakpointByID}, + { "Append", _wrap_SBBreakpointList_Append}, + { "AppendIfUnique", _wrap_SBBreakpointList_AppendIfUnique}, + { "AppendByID", _wrap_SBBreakpointList_AppendByID}, + { "Clear", _wrap_SBBreakpointList_Clear}, + {0,0} +}; +static swig_lua_method swig_SBBreakpointList_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBBreakpointList_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBBreakpointList_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBBreakpointList_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBBreakpointList_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBBreakpointList_Sf_SwigStatic = { + "SBBreakpointList", + swig_SBBreakpointList_Sf_SwigStatic_methods, + swig_SBBreakpointList_Sf_SwigStatic_attributes, + swig_SBBreakpointList_Sf_SwigStatic_constants, + swig_SBBreakpointList_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBBreakpointList_bases[] = {0}; +static const char *swig_SBBreakpointList_base_names[] = {0}; +static swig_lua_class _wrap_class_SBBreakpointList = { "SBBreakpointList", "SBBreakpointList", &SWIGTYPE_p_lldb__SBBreakpointList,_proxy__wrap_new_SBBreakpointList, swig_delete_SBBreakpointList, swig_SBBreakpointList_methods, swig_SBBreakpointList_attributes, &swig_SBBreakpointList_Sf_SwigStatic, swig_SBBreakpointList_meta, swig_SBBreakpointList_bases, swig_SBBreakpointList_base_names }; + +static int _wrap_new_SBBreakpointLocation__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointLocation *result = 0 ; + + SWIG_check_num_args("lldb::SBBreakpointLocation::SBBreakpointLocation",0,0) + result = (lldb::SBBreakpointLocation *)new lldb::SBBreakpointLocation(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBBreakpointLocation,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBBreakpointLocation__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointLocation *arg1 = 0 ; + lldb::SBBreakpointLocation *result = 0 ; + + SWIG_check_num_args("lldb::SBBreakpointLocation::SBBreakpointLocation",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::SBBreakpointLocation",1,"lldb::SBBreakpointLocation const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){ + SWIG_fail_ptr("new_SBBreakpointLocation",1,SWIGTYPE_p_lldb__SBBreakpointLocation); + } + + result = (lldb::SBBreakpointLocation *)new lldb::SBBreakpointLocation((lldb::SBBreakpointLocation const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBBreakpointLocation,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBBreakpointLocation(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBBreakpointLocation__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBreakpointLocation, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBBreakpointLocation__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBBreakpointLocation'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBBreakpointLocation::SBBreakpointLocation()\n" + " lldb::SBBreakpointLocation::SBBreakpointLocation(lldb::SBBreakpointLocation const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBBreakpointLocation_GetID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + lldb::break_id_t result; + + SWIG_check_num_args("lldb::SBBreakpointLocation::GetID",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::GetID",1,"lldb::SBBreakpointLocation *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){ + SWIG_fail_ptr("SBBreakpointLocation_GetID",1,SWIGTYPE_p_lldb__SBBreakpointLocation); + } + + result = (lldb::break_id_t)(arg1)->GetID(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointLocation_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBBreakpointLocation::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::IsValid",1,"lldb::SBBreakpointLocation const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){ + SWIG_fail_ptr("SBBreakpointLocation_IsValid",1,SWIGTYPE_p_lldb__SBBreakpointLocation); + } + + result = (bool)((lldb::SBBreakpointLocation const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointLocation_GetAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + lldb::SBAddress result; + + SWIG_check_num_args("lldb::SBBreakpointLocation::GetAddress",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::GetAddress",1,"lldb::SBBreakpointLocation *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){ + SWIG_fail_ptr("SBBreakpointLocation_GetAddress",1,SWIGTYPE_p_lldb__SBBreakpointLocation); + } + + result = (arg1)->GetAddress(); + { + lldb::SBAddress * resultptr = new lldb::SBAddress(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointLocation_GetLoadAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + lldb::addr_t result; + + SWIG_check_num_args("lldb::SBBreakpointLocation::GetLoadAddress",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::GetLoadAddress",1,"lldb::SBBreakpointLocation *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){ + SWIG_fail_ptr("SBBreakpointLocation_GetLoadAddress",1,SWIGTYPE_p_lldb__SBBreakpointLocation); + } + + result = (lldb::addr_t)(arg1)->GetLoadAddress(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointLocation_SetEnabled(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBBreakpointLocation::SetEnabled",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetEnabled",1,"lldb::SBBreakpointLocation *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetEnabled",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){ + SWIG_fail_ptr("SBBreakpointLocation_SetEnabled",1,SWIGTYPE_p_lldb__SBBreakpointLocation); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetEnabled(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointLocation_IsEnabled(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBBreakpointLocation::IsEnabled",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::IsEnabled",1,"lldb::SBBreakpointLocation *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){ + SWIG_fail_ptr("SBBreakpointLocation_IsEnabled",1,SWIGTYPE_p_lldb__SBBreakpointLocation); + } + + result = (bool)(arg1)->IsEnabled(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointLocation_GetHitCount(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBBreakpointLocation::GetHitCount",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::GetHitCount",1,"lldb::SBBreakpointLocation *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){ + SWIG_fail_ptr("SBBreakpointLocation_GetHitCount",1,SWIGTYPE_p_lldb__SBBreakpointLocation); + } + + result = (uint32_t)(arg1)->GetHitCount(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointLocation_GetIgnoreCount(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBBreakpointLocation::GetIgnoreCount",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::GetIgnoreCount",1,"lldb::SBBreakpointLocation *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){ + SWIG_fail_ptr("SBBreakpointLocation_GetIgnoreCount",1,SWIGTYPE_p_lldb__SBBreakpointLocation); + } + + result = (uint32_t)(arg1)->GetIgnoreCount(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointLocation_SetIgnoreCount(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + uint32_t arg2 ; + + SWIG_check_num_args("lldb::SBBreakpointLocation::SetIgnoreCount",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetIgnoreCount",1,"lldb::SBBreakpointLocation *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetIgnoreCount",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){ + SWIG_fail_ptr("SBBreakpointLocation_SetIgnoreCount",1,SWIGTYPE_p_lldb__SBBreakpointLocation); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + (arg1)->SetIgnoreCount(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointLocation_SetCondition(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBBreakpointLocation::SetCondition",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetCondition",1,"lldb::SBBreakpointLocation *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetCondition",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){ + SWIG_fail_ptr("SBBreakpointLocation_SetCondition",1,SWIGTYPE_p_lldb__SBBreakpointLocation); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetCondition((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointLocation_GetCondition(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBBreakpointLocation::GetCondition",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::GetCondition",1,"lldb::SBBreakpointLocation *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){ + SWIG_fail_ptr("SBBreakpointLocation_GetCondition",1,SWIGTYPE_p_lldb__SBBreakpointLocation); + } + + result = (char *)(arg1)->GetCondition(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointLocation_SetAutoContinue(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBBreakpointLocation::SetAutoContinue",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetAutoContinue",1,"lldb::SBBreakpointLocation *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetAutoContinue",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){ + SWIG_fail_ptr("SBBreakpointLocation_SetAutoContinue",1,SWIGTYPE_p_lldb__SBBreakpointLocation); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetAutoContinue(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointLocation_GetAutoContinue(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBBreakpointLocation::GetAutoContinue",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::GetAutoContinue",1,"lldb::SBBreakpointLocation *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){ + SWIG_fail_ptr("SBBreakpointLocation_GetAutoContinue",1,SWIGTYPE_p_lldb__SBBreakpointLocation); + } + + result = (bool)(arg1)->GetAutoContinue(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointLocation_SetScriptCallbackFunction__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBBreakpointLocation::SetScriptCallbackFunction",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetScriptCallbackFunction",1,"lldb::SBBreakpointLocation *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetScriptCallbackFunction",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){ + SWIG_fail_ptr("SBBreakpointLocation_SetScriptCallbackFunction",1,SWIGTYPE_p_lldb__SBBreakpointLocation); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetScriptCallbackFunction((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointLocation_SetScriptCallbackFunction__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBStructuredData *arg3 = 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBBreakpointLocation::SetScriptCallbackFunction",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetScriptCallbackFunction",1,"lldb::SBBreakpointLocation *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetScriptCallbackFunction",2,"char const *"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetScriptCallbackFunction",3,"lldb::SBStructuredData &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){ + SWIG_fail_ptr("SBBreakpointLocation_SetScriptCallbackFunction",1,SWIGTYPE_p_lldb__SBBreakpointLocation); + } + + arg2 = (char *)lua_tostring(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("SBBreakpointLocation_SetScriptCallbackFunction",3,SWIGTYPE_p_lldb__SBStructuredData); + } + + result = (arg1)->SetScriptCallbackFunction((char const *)arg2,*arg3); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointLocation_SetScriptCallbackFunction(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBreakpointLocation, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + return _wrap_SBBreakpointLocation_SetScriptCallbackFunction__SWIG_0(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBreakpointLocation, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBBreakpointLocation_SetScriptCallbackFunction__SWIG_1(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBBreakpointLocation_SetScriptCallbackBody(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBBreakpointLocation::SetScriptCallbackBody",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetScriptCallbackBody",1,"lldb::SBBreakpointLocation *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetScriptCallbackBody",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){ + SWIG_fail_ptr("SBBreakpointLocation_SetScriptCallbackBody",1,SWIGTYPE_p_lldb__SBBreakpointLocation); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->SetScriptCallbackBody((char const *)arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointLocation_SetCommandLineCommands(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + lldb::SBStringList *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBBreakpointLocation::SetCommandLineCommands",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetCommandLineCommands",1,"lldb::SBBreakpointLocation *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetCommandLineCommands",2,"lldb::SBStringList &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){ + SWIG_fail_ptr("SBBreakpointLocation_SetCommandLineCommands",1,SWIGTYPE_p_lldb__SBBreakpointLocation); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStringList,0))){ + SWIG_fail_ptr("SBBreakpointLocation_SetCommandLineCommands",2,SWIGTYPE_p_lldb__SBStringList); + } + + (arg1)->SetCommandLineCommands(*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointLocation_GetCommandLineCommands(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + lldb::SBStringList *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBBreakpointLocation::GetCommandLineCommands",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::GetCommandLineCommands",1,"lldb::SBBreakpointLocation *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBreakpointLocation::GetCommandLineCommands",2,"lldb::SBStringList &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){ + SWIG_fail_ptr("SBBreakpointLocation_GetCommandLineCommands",1,SWIGTYPE_p_lldb__SBBreakpointLocation); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStringList,0))){ + SWIG_fail_ptr("SBBreakpointLocation_GetCommandLineCommands",2,SWIGTYPE_p_lldb__SBStringList); + } + + result = (bool)(arg1)->GetCommandLineCommands(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointLocation_SetThreadID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + lldb::tid_t arg2 ; + + SWIG_check_num_args("lldb::SBBreakpointLocation::SetThreadID",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetThreadID",1,"lldb::SBBreakpointLocation *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetThreadID",2,"lldb::tid_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){ + SWIG_fail_ptr("SBBreakpointLocation_SetThreadID",1,SWIGTYPE_p_lldb__SBBreakpointLocation); + } + + arg2 = (lldb::tid_t)lua_tointeger(L, 2); + (arg1)->SetThreadID(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointLocation_GetThreadID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + lldb::tid_t result; + + SWIG_check_num_args("lldb::SBBreakpointLocation::GetThreadID",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::GetThreadID",1,"lldb::SBBreakpointLocation *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){ + SWIG_fail_ptr("SBBreakpointLocation_GetThreadID",1,SWIGTYPE_p_lldb__SBBreakpointLocation); + } + + result = (lldb::tid_t)(arg1)->GetThreadID(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointLocation_SetThreadIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + uint32_t arg2 ; + + SWIG_check_num_args("lldb::SBBreakpointLocation::SetThreadIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetThreadIndex",1,"lldb::SBBreakpointLocation *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetThreadIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){ + SWIG_fail_ptr("SBBreakpointLocation_SetThreadIndex",1,SWIGTYPE_p_lldb__SBBreakpointLocation); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + (arg1)->SetThreadIndex(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointLocation_GetThreadIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBBreakpointLocation::GetThreadIndex",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::GetThreadIndex",1,"lldb::SBBreakpointLocation const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){ + SWIG_fail_ptr("SBBreakpointLocation_GetThreadIndex",1,SWIGTYPE_p_lldb__SBBreakpointLocation); + } + + result = (uint32_t)((lldb::SBBreakpointLocation const *)arg1)->GetThreadIndex(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointLocation_SetThreadName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBBreakpointLocation::SetThreadName",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetThreadName",1,"lldb::SBBreakpointLocation *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetThreadName",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){ + SWIG_fail_ptr("SBBreakpointLocation_SetThreadName",1,SWIGTYPE_p_lldb__SBBreakpointLocation); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetThreadName((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointLocation_GetThreadName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBBreakpointLocation::GetThreadName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::GetThreadName",1,"lldb::SBBreakpointLocation const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){ + SWIG_fail_ptr("SBBreakpointLocation_GetThreadName",1,SWIGTYPE_p_lldb__SBBreakpointLocation); + } + + result = (char *)((lldb::SBBreakpointLocation const *)arg1)->GetThreadName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointLocation_SetQueueName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBBreakpointLocation::SetQueueName",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetQueueName",1,"lldb::SBBreakpointLocation *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpointLocation::SetQueueName",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){ + SWIG_fail_ptr("SBBreakpointLocation_SetQueueName",1,SWIGTYPE_p_lldb__SBBreakpointLocation); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetQueueName((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointLocation_GetQueueName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBBreakpointLocation::GetQueueName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::GetQueueName",1,"lldb::SBBreakpointLocation const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){ + SWIG_fail_ptr("SBBreakpointLocation_GetQueueName",1,SWIGTYPE_p_lldb__SBBreakpointLocation); + } + + result = (char *)((lldb::SBBreakpointLocation const *)arg1)->GetQueueName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointLocation_IsResolved(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBBreakpointLocation::IsResolved",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::IsResolved",1,"lldb::SBBreakpointLocation *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){ + SWIG_fail_ptr("SBBreakpointLocation_IsResolved",1,SWIGTYPE_p_lldb__SBBreakpointLocation); + } + + result = (bool)(arg1)->IsResolved(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointLocation_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + lldb::SBStream *arg2 = 0 ; + lldb::DescriptionLevel arg3 ; + bool result; + + SWIG_check_num_args("lldb::SBBreakpointLocation::GetDescription",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::GetDescription",1,"lldb::SBBreakpointLocation *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBreakpointLocation::GetDescription",2,"lldb::SBStream &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBBreakpointLocation::GetDescription",3,"lldb::DescriptionLevel"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){ + SWIG_fail_ptr("SBBreakpointLocation_GetDescription",1,SWIGTYPE_p_lldb__SBBreakpointLocation); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBBreakpointLocation_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + arg3 = (lldb::DescriptionLevel)lua_tointeger(L, 3); + result = (bool)(arg1)->GetDescription(*arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointLocation_GetBreakpoint(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + lldb::SBBreakpoint result; + + SWIG_check_num_args("lldb::SBBreakpointLocation::GetBreakpoint",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::GetBreakpoint",1,"lldb::SBBreakpointLocation *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){ + SWIG_fail_ptr("SBBreakpointLocation_GetBreakpoint",1,SWIGTYPE_p_lldb__SBBreakpointLocation); + } + + result = (arg1)->GetBreakpoint(); + { + lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointLocation___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBBreakpointLocation::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointLocation::__repr__",1,"lldb::SBBreakpointLocation *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointLocation,0))){ + SWIG_fail_ptr("SBBreakpointLocation___tostring",1,SWIGTYPE_p_lldb__SBBreakpointLocation); + } + + result = lldb_SBBreakpointLocation___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBBreakpointLocation(void *obj) { +lldb::SBBreakpointLocation *arg1 = (lldb::SBBreakpointLocation *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBBreakpointLocation(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBBreakpointLocation); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBBreakpointLocation_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBBreakpointLocation_methods[]= { + { "GetID", _wrap_SBBreakpointLocation_GetID}, + { "IsValid", _wrap_SBBreakpointLocation_IsValid}, + { "GetAddress", _wrap_SBBreakpointLocation_GetAddress}, + { "GetLoadAddress", _wrap_SBBreakpointLocation_GetLoadAddress}, + { "SetEnabled", _wrap_SBBreakpointLocation_SetEnabled}, + { "IsEnabled", _wrap_SBBreakpointLocation_IsEnabled}, + { "GetHitCount", _wrap_SBBreakpointLocation_GetHitCount}, + { "GetIgnoreCount", _wrap_SBBreakpointLocation_GetIgnoreCount}, + { "SetIgnoreCount", _wrap_SBBreakpointLocation_SetIgnoreCount}, + { "SetCondition", _wrap_SBBreakpointLocation_SetCondition}, + { "GetCondition", _wrap_SBBreakpointLocation_GetCondition}, + { "SetAutoContinue", _wrap_SBBreakpointLocation_SetAutoContinue}, + { "GetAutoContinue", _wrap_SBBreakpointLocation_GetAutoContinue}, + { "SetScriptCallbackFunction", _wrap_SBBreakpointLocation_SetScriptCallbackFunction}, + { "SetScriptCallbackBody", _wrap_SBBreakpointLocation_SetScriptCallbackBody}, + { "SetCommandLineCommands", _wrap_SBBreakpointLocation_SetCommandLineCommands}, + { "GetCommandLineCommands", _wrap_SBBreakpointLocation_GetCommandLineCommands}, + { "SetThreadID", _wrap_SBBreakpointLocation_SetThreadID}, + { "GetThreadID", _wrap_SBBreakpointLocation_GetThreadID}, + { "SetThreadIndex", _wrap_SBBreakpointLocation_SetThreadIndex}, + { "GetThreadIndex", _wrap_SBBreakpointLocation_GetThreadIndex}, + { "SetThreadName", _wrap_SBBreakpointLocation_SetThreadName}, + { "GetThreadName", _wrap_SBBreakpointLocation_GetThreadName}, + { "SetQueueName", _wrap_SBBreakpointLocation_SetQueueName}, + { "GetQueueName", _wrap_SBBreakpointLocation_GetQueueName}, + { "IsResolved", _wrap_SBBreakpointLocation_IsResolved}, + { "GetDescription", _wrap_SBBreakpointLocation_GetDescription}, + { "GetBreakpoint", _wrap_SBBreakpointLocation_GetBreakpoint}, + { "__tostring", _wrap_SBBreakpointLocation___tostring}, + {0,0} +}; +static swig_lua_method swig_SBBreakpointLocation_meta[] = { + { "__tostring", _wrap_SBBreakpointLocation___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBBreakpointLocation_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBBreakpointLocation_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBBreakpointLocation_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBBreakpointLocation_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBBreakpointLocation_Sf_SwigStatic = { + "SBBreakpointLocation", + swig_SBBreakpointLocation_Sf_SwigStatic_methods, + swig_SBBreakpointLocation_Sf_SwigStatic_attributes, + swig_SBBreakpointLocation_Sf_SwigStatic_constants, + swig_SBBreakpointLocation_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBBreakpointLocation_bases[] = {0}; +static const char *swig_SBBreakpointLocation_base_names[] = {0}; +static swig_lua_class _wrap_class_SBBreakpointLocation = { "SBBreakpointLocation", "SBBreakpointLocation", &SWIGTYPE_p_lldb__SBBreakpointLocation,_proxy__wrap_new_SBBreakpointLocation, swig_delete_SBBreakpointLocation, swig_SBBreakpointLocation_methods, swig_SBBreakpointLocation_attributes, &swig_SBBreakpointLocation_Sf_SwigStatic, swig_SBBreakpointLocation_meta, swig_SBBreakpointLocation_bases, swig_SBBreakpointLocation_base_names }; + +static int _wrap_new_SBBreakpointName__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *result = 0 ; + + SWIG_check_num_args("lldb::SBBreakpointName::SBBreakpointName",0,0) + result = (lldb::SBBreakpointName *)new lldb::SBBreakpointName(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBBreakpointName,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBBreakpointName__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = 0 ; + char *arg2 = (char *) 0 ; + lldb::SBBreakpointName *result = 0 ; + + SWIG_check_num_args("lldb::SBBreakpointName::SBBreakpointName",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SBBreakpointName",1,"lldb::SBTarget &"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SBBreakpointName",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("new_SBBreakpointName",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (lldb::SBBreakpointName *)new lldb::SBBreakpointName(*arg1,(char const *)arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBBreakpointName,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBBreakpointName__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpoint *arg1 = 0 ; + char *arg2 = (char *) 0 ; + lldb::SBBreakpointName *result = 0 ; + + SWIG_check_num_args("lldb::SBBreakpointName::SBBreakpointName",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SBBreakpointName",1,"lldb::SBBreakpoint &"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SBBreakpointName",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpoint,0))){ + SWIG_fail_ptr("new_SBBreakpointName",1,SWIGTYPE_p_lldb__SBBreakpoint); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (lldb::SBBreakpointName *)new lldb::SBBreakpointName(*arg1,(char const *)arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBBreakpointName,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBBreakpointName__SWIG_3(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = 0 ; + lldb::SBBreakpointName *result = 0 ; + + SWIG_check_num_args("lldb::SBBreakpointName::SBBreakpointName",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SBBreakpointName",1,"lldb::SBBreakpointName const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("new_SBBreakpointName",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + result = (lldb::SBBreakpointName *)new lldb::SBBreakpointName((lldb::SBBreakpointName const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBBreakpointName,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBBreakpointName(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBBreakpointName__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBreakpointName, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBBreakpointName__SWIG_3(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBreakpoint, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + return _wrap_new_SBBreakpointName__SWIG_2(L); + } + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + return _wrap_new_SBBreakpointName__SWIG_1(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBBreakpointName___eq(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBBreakpointName *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBBreakpointName::operator ==",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::operator ==",1,"lldb::SBBreakpointName *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::operator ==",2,"lldb::SBBreakpointName const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName___eq",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName___eq",2,SWIGTYPE_p_lldb__SBBreakpointName); + } + + result = (bool)(arg1)->operator ==((lldb::SBBreakpointName const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointName_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBBreakpointName::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::IsValid",1,"lldb::SBBreakpointName const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName_IsValid",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + result = (bool)((lldb::SBBreakpointName const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointName_GetName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBBreakpointName::GetName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::GetName",1,"lldb::SBBreakpointName const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName_GetName",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + result = (char *)((lldb::SBBreakpointName const *)arg1)->GetName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointName_SetEnabled(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBBreakpointName::SetEnabled",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SetEnabled",1,"lldb::SBBreakpointName *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SetEnabled",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName_SetEnabled",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetEnabled(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointName_IsEnabled(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBBreakpointName::IsEnabled",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::IsEnabled",1,"lldb::SBBreakpointName *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName_IsEnabled",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + result = (bool)(arg1)->IsEnabled(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointName_SetOneShot(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBBreakpointName::SetOneShot",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SetOneShot",1,"lldb::SBBreakpointName *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SetOneShot",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName_SetOneShot",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetOneShot(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointName_IsOneShot(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBBreakpointName::IsOneShot",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::IsOneShot",1,"lldb::SBBreakpointName const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName_IsOneShot",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + result = (bool)((lldb::SBBreakpointName const *)arg1)->IsOneShot(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointName_SetIgnoreCount(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + uint32_t arg2 ; + + SWIG_check_num_args("lldb::SBBreakpointName::SetIgnoreCount",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SetIgnoreCount",1,"lldb::SBBreakpointName *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SetIgnoreCount",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName_SetIgnoreCount",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + (arg1)->SetIgnoreCount(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointName_GetIgnoreCount(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBBreakpointName::GetIgnoreCount",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::GetIgnoreCount",1,"lldb::SBBreakpointName const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName_GetIgnoreCount",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + result = (uint32_t)((lldb::SBBreakpointName const *)arg1)->GetIgnoreCount(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointName_SetCondition(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBBreakpointName::SetCondition",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SetCondition",1,"lldb::SBBreakpointName *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SetCondition",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName_SetCondition",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetCondition((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointName_GetCondition(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBBreakpointName::GetCondition",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::GetCondition",1,"lldb::SBBreakpointName *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName_GetCondition",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + result = (char *)(arg1)->GetCondition(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointName_SetAutoContinue(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBBreakpointName::SetAutoContinue",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SetAutoContinue",1,"lldb::SBBreakpointName *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SetAutoContinue",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName_SetAutoContinue",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetAutoContinue(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointName_GetAutoContinue(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBBreakpointName::GetAutoContinue",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::GetAutoContinue",1,"lldb::SBBreakpointName *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName_GetAutoContinue",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + result = (bool)(arg1)->GetAutoContinue(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointName_SetThreadID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::tid_t arg2 ; + + SWIG_check_num_args("lldb::SBBreakpointName::SetThreadID",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SetThreadID",1,"lldb::SBBreakpointName *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SetThreadID",2,"lldb::tid_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName_SetThreadID",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + arg2 = (lldb::tid_t)lua_tointeger(L, 2); + (arg1)->SetThreadID(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointName_GetThreadID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::tid_t result; + + SWIG_check_num_args("lldb::SBBreakpointName::GetThreadID",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::GetThreadID",1,"lldb::SBBreakpointName *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName_GetThreadID",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + result = (lldb::tid_t)(arg1)->GetThreadID(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointName_SetThreadIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + uint32_t arg2 ; + + SWIG_check_num_args("lldb::SBBreakpointName::SetThreadIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SetThreadIndex",1,"lldb::SBBreakpointName *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SetThreadIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName_SetThreadIndex",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + (arg1)->SetThreadIndex(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointName_GetThreadIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBBreakpointName::GetThreadIndex",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::GetThreadIndex",1,"lldb::SBBreakpointName const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName_GetThreadIndex",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + result = (uint32_t)((lldb::SBBreakpointName const *)arg1)->GetThreadIndex(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointName_SetThreadName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBBreakpointName::SetThreadName",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SetThreadName",1,"lldb::SBBreakpointName *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SetThreadName",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName_SetThreadName",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetThreadName((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointName_GetThreadName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBBreakpointName::GetThreadName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::GetThreadName",1,"lldb::SBBreakpointName const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName_GetThreadName",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + result = (char *)((lldb::SBBreakpointName const *)arg1)->GetThreadName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointName_SetQueueName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBBreakpointName::SetQueueName",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SetQueueName",1,"lldb::SBBreakpointName *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SetQueueName",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName_SetQueueName",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetQueueName((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointName_GetQueueName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBBreakpointName::GetQueueName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::GetQueueName",1,"lldb::SBBreakpointName const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName_GetQueueName",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + result = (char *)((lldb::SBBreakpointName const *)arg1)->GetQueueName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointName_SetScriptCallbackFunction__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBBreakpointName::SetScriptCallbackFunction",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SetScriptCallbackFunction",1,"lldb::SBBreakpointName *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SetScriptCallbackFunction",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName_SetScriptCallbackFunction",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetScriptCallbackFunction((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointName_SetScriptCallbackFunction__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBStructuredData *arg3 = 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBBreakpointName::SetScriptCallbackFunction",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SetScriptCallbackFunction",1,"lldb::SBBreakpointName *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SetScriptCallbackFunction",2,"char const *"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBBreakpointName::SetScriptCallbackFunction",3,"lldb::SBStructuredData &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName_SetScriptCallbackFunction",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + arg2 = (char *)lua_tostring(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("SBBreakpointName_SetScriptCallbackFunction",3,SWIGTYPE_p_lldb__SBStructuredData); + } + + result = (arg1)->SetScriptCallbackFunction((char const *)arg2,*arg3); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointName_SetScriptCallbackFunction(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBreakpointName, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + return _wrap_SBBreakpointName_SetScriptCallbackFunction__SWIG_0(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBreakpointName, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBBreakpointName_SetScriptCallbackFunction__SWIG_1(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBBreakpointName_SetCommandLineCommands(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBStringList *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBBreakpointName::SetCommandLineCommands",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SetCommandLineCommands",1,"lldb::SBBreakpointName *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SetCommandLineCommands",2,"lldb::SBStringList &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName_SetCommandLineCommands",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStringList,0))){ + SWIG_fail_ptr("SBBreakpointName_SetCommandLineCommands",2,SWIGTYPE_p_lldb__SBStringList); + } + + (arg1)->SetCommandLineCommands(*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointName_GetCommandLineCommands(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBStringList *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBBreakpointName::GetCommandLineCommands",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::GetCommandLineCommands",1,"lldb::SBBreakpointName *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::GetCommandLineCommands",2,"lldb::SBStringList &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName_GetCommandLineCommands",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStringList,0))){ + SWIG_fail_ptr("SBBreakpointName_GetCommandLineCommands",2,SWIGTYPE_p_lldb__SBStringList); + } + + result = (bool)(arg1)->GetCommandLineCommands(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointName_SetScriptCallbackBody(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBBreakpointName::SetScriptCallbackBody",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SetScriptCallbackBody",1,"lldb::SBBreakpointName *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SetScriptCallbackBody",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName_SetScriptCallbackBody",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->SetScriptCallbackBody((char const *)arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointName_GetHelpString(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBBreakpointName::GetHelpString",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::GetHelpString",1,"lldb::SBBreakpointName const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName_GetHelpString",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + result = (char *)((lldb::SBBreakpointName const *)arg1)->GetHelpString(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointName_SetHelpString(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBBreakpointName::SetHelpString",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SetHelpString",1,"lldb::SBBreakpointName *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SetHelpString",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName_SetHelpString",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetHelpString((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointName_GetAllowList(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBBreakpointName::GetAllowList",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::GetAllowList",1,"lldb::SBBreakpointName const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName_GetAllowList",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + result = (bool)((lldb::SBBreakpointName const *)arg1)->GetAllowList(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointName_SetAllowList(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBBreakpointName::SetAllowList",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SetAllowList",1,"lldb::SBBreakpointName *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SetAllowList",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName_SetAllowList",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetAllowList(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointName_GetAllowDelete(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBBreakpointName::GetAllowDelete",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::GetAllowDelete",1,"lldb::SBBreakpointName *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName_GetAllowDelete",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + result = (bool)(arg1)->GetAllowDelete(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointName_SetAllowDelete(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBBreakpointName::SetAllowDelete",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SetAllowDelete",1,"lldb::SBBreakpointName *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SetAllowDelete",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName_SetAllowDelete",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetAllowDelete(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointName_GetAllowDisable(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBBreakpointName::GetAllowDisable",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::GetAllowDisable",1,"lldb::SBBreakpointName *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName_GetAllowDisable",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + result = (bool)(arg1)->GetAllowDisable(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointName_SetAllowDisable(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBBreakpointName::SetAllowDisable",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::SetAllowDisable",1,"lldb::SBBreakpointName *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::SetAllowDisable",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName_SetAllowDisable",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetAllowDisable(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointName_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBBreakpointName::GetDescription",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::GetDescription",1,"lldb::SBBreakpointName *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBreakpointName::GetDescription",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName_GetDescription",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBBreakpointName_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)(arg1)->GetDescription(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBreakpointName___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBBreakpointName::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBreakpointName::__repr__",1,"lldb::SBBreakpointName *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBreakpointName,0))){ + SWIG_fail_ptr("SBBreakpointName___tostring",1,SWIGTYPE_p_lldb__SBBreakpointName); + } + + result = lldb_SBBreakpointName___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBBreakpointName(void *obj) { +lldb::SBBreakpointName *arg1 = (lldb::SBBreakpointName *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBBreakpointName(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBBreakpointName); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBBreakpointName_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBBreakpointName_methods[]= { + { "__eq", _wrap_SBBreakpointName___eq}, + { "IsValid", _wrap_SBBreakpointName_IsValid}, + { "GetName", _wrap_SBBreakpointName_GetName}, + { "SetEnabled", _wrap_SBBreakpointName_SetEnabled}, + { "IsEnabled", _wrap_SBBreakpointName_IsEnabled}, + { "SetOneShot", _wrap_SBBreakpointName_SetOneShot}, + { "IsOneShot", _wrap_SBBreakpointName_IsOneShot}, + { "SetIgnoreCount", _wrap_SBBreakpointName_SetIgnoreCount}, + { "GetIgnoreCount", _wrap_SBBreakpointName_GetIgnoreCount}, + { "SetCondition", _wrap_SBBreakpointName_SetCondition}, + { "GetCondition", _wrap_SBBreakpointName_GetCondition}, + { "SetAutoContinue", _wrap_SBBreakpointName_SetAutoContinue}, + { "GetAutoContinue", _wrap_SBBreakpointName_GetAutoContinue}, + { "SetThreadID", _wrap_SBBreakpointName_SetThreadID}, + { "GetThreadID", _wrap_SBBreakpointName_GetThreadID}, + { "SetThreadIndex", _wrap_SBBreakpointName_SetThreadIndex}, + { "GetThreadIndex", _wrap_SBBreakpointName_GetThreadIndex}, + { "SetThreadName", _wrap_SBBreakpointName_SetThreadName}, + { "GetThreadName", _wrap_SBBreakpointName_GetThreadName}, + { "SetQueueName", _wrap_SBBreakpointName_SetQueueName}, + { "GetQueueName", _wrap_SBBreakpointName_GetQueueName}, + { "SetScriptCallbackFunction", _wrap_SBBreakpointName_SetScriptCallbackFunction}, + { "SetCommandLineCommands", _wrap_SBBreakpointName_SetCommandLineCommands}, + { "GetCommandLineCommands", _wrap_SBBreakpointName_GetCommandLineCommands}, + { "SetScriptCallbackBody", _wrap_SBBreakpointName_SetScriptCallbackBody}, + { "GetHelpString", _wrap_SBBreakpointName_GetHelpString}, + { "SetHelpString", _wrap_SBBreakpointName_SetHelpString}, + { "GetAllowList", _wrap_SBBreakpointName_GetAllowList}, + { "SetAllowList", _wrap_SBBreakpointName_SetAllowList}, + { "GetAllowDelete", _wrap_SBBreakpointName_GetAllowDelete}, + { "SetAllowDelete", _wrap_SBBreakpointName_SetAllowDelete}, + { "GetAllowDisable", _wrap_SBBreakpointName_GetAllowDisable}, + { "SetAllowDisable", _wrap_SBBreakpointName_SetAllowDisable}, + { "GetDescription", _wrap_SBBreakpointName_GetDescription}, + { "__tostring", _wrap_SBBreakpointName___tostring}, + {0,0} +}; +static swig_lua_method swig_SBBreakpointName_meta[] = { + { "__eq", _wrap_SBBreakpointName___eq}, + { "__tostring", _wrap_SBBreakpointName___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBBreakpointName_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBBreakpointName_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBBreakpointName_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBBreakpointName_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBBreakpointName_Sf_SwigStatic = { + "SBBreakpointName", + swig_SBBreakpointName_Sf_SwigStatic_methods, + swig_SBBreakpointName_Sf_SwigStatic_attributes, + swig_SBBreakpointName_Sf_SwigStatic_constants, + swig_SBBreakpointName_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBBreakpointName_bases[] = {0}; +static const char *swig_SBBreakpointName_base_names[] = {0}; +static swig_lua_class _wrap_class_SBBreakpointName = { "SBBreakpointName", "SBBreakpointName", &SWIGTYPE_p_lldb__SBBreakpointName,_proxy__wrap_new_SBBreakpointName, swig_delete_SBBreakpointName, swig_SBBreakpointName_methods, swig_SBBreakpointName_attributes, &swig_SBBreakpointName_Sf_SwigStatic, swig_SBBreakpointName_meta, swig_SBBreakpointName_bases, swig_SBBreakpointName_base_names }; + +static int _wrap_new_SBBroadcaster__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBroadcaster *result = 0 ; + + SWIG_check_num_args("lldb::SBBroadcaster::SBBroadcaster",0,0) + result = (lldb::SBBroadcaster *)new lldb::SBBroadcaster(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBBroadcaster,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBBroadcaster__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + lldb::SBBroadcaster *result = 0 ; + + SWIG_check_num_args("lldb::SBBroadcaster::SBBroadcaster",1,1) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBBroadcaster::SBBroadcaster",1,"char const *"); + arg1 = (char *)lua_tostring(L, 1); + result = (lldb::SBBroadcaster *)new lldb::SBBroadcaster((char const *)arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBBroadcaster,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBBroadcaster__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBroadcaster *arg1 = 0 ; + lldb::SBBroadcaster *result = 0 ; + + SWIG_check_num_args("lldb::SBBroadcaster::SBBroadcaster",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBBroadcaster::SBBroadcaster",1,"lldb::SBBroadcaster const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBroadcaster,0))){ + SWIG_fail_ptr("new_SBBroadcaster",1,SWIGTYPE_p_lldb__SBBroadcaster); + } + + result = (lldb::SBBroadcaster *)new lldb::SBBroadcaster((lldb::SBBroadcaster const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBBroadcaster,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBBroadcaster(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBBroadcaster__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBroadcaster, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBBroadcaster__SWIG_2(L); + } + } + if (argc == 1) { + int _v = 0; + { + _v = SWIG_lua_isnilstring(L,argv[0]); + } + if (_v) { + return _wrap_new_SBBroadcaster__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBBroadcaster_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBBroadcaster::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBroadcaster::IsValid",1,"lldb::SBBroadcaster const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBroadcaster,0))){ + SWIG_fail_ptr("SBBroadcaster_IsValid",1,SWIGTYPE_p_lldb__SBBroadcaster); + } + + result = (bool)((lldb::SBBroadcaster const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBroadcaster_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ; + + SWIG_check_num_args("lldb::SBBroadcaster::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBroadcaster::Clear",1,"lldb::SBBroadcaster *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBroadcaster,0))){ + SWIG_fail_ptr("SBBroadcaster_Clear",1,SWIGTYPE_p_lldb__SBBroadcaster); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBroadcaster_BroadcastEventByType__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ; + uint32_t arg2 ; + bool arg3 ; + + SWIG_check_num_args("lldb::SBBroadcaster::BroadcastEventByType",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBroadcaster::BroadcastEventByType",1,"lldb::SBBroadcaster *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBroadcaster::BroadcastEventByType",2,"uint32_t"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBBroadcaster::BroadcastEventByType",3,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBroadcaster,0))){ + SWIG_fail_ptr("SBBroadcaster_BroadcastEventByType",1,SWIGTYPE_p_lldb__SBBroadcaster); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + arg3 = (lua_toboolean(L, 3)!=0); + (arg1)->BroadcastEventByType(arg2,arg3); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBroadcaster_BroadcastEventByType__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ; + uint32_t arg2 ; + + SWIG_check_num_args("lldb::SBBroadcaster::BroadcastEventByType",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBroadcaster::BroadcastEventByType",1,"lldb::SBBroadcaster *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBroadcaster::BroadcastEventByType",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBroadcaster,0))){ + SWIG_fail_ptr("SBBroadcaster_BroadcastEventByType",1,SWIGTYPE_p_lldb__SBBroadcaster); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + (arg1)->BroadcastEventByType(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBroadcaster_BroadcastEventByType(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBroadcaster, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_SBBroadcaster_BroadcastEventByType__SWIG_1(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBroadcaster, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[2]); + } + if (_v) { + return _wrap_SBBroadcaster_BroadcastEventByType__SWIG_0(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBBroadcaster_BroadcastEvent__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ; + lldb::SBEvent *arg2 = 0 ; + bool arg3 ; + + SWIG_check_num_args("lldb::SBBroadcaster::BroadcastEvent",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBroadcaster::BroadcastEvent",1,"lldb::SBBroadcaster *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBroadcaster::BroadcastEvent",2,"lldb::SBEvent const &"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBBroadcaster::BroadcastEvent",3,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBroadcaster,0))){ + SWIG_fail_ptr("SBBroadcaster_BroadcastEvent",1,SWIGTYPE_p_lldb__SBBroadcaster); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBBroadcaster_BroadcastEvent",2,SWIGTYPE_p_lldb__SBEvent); + } + + arg3 = (lua_toboolean(L, 3)!=0); + (arg1)->BroadcastEvent((lldb::SBEvent const &)*arg2,arg3); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBroadcaster_BroadcastEvent__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ; + lldb::SBEvent *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBBroadcaster::BroadcastEvent",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBroadcaster::BroadcastEvent",1,"lldb::SBBroadcaster *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBroadcaster::BroadcastEvent",2,"lldb::SBEvent const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBroadcaster,0))){ + SWIG_fail_ptr("SBBroadcaster_BroadcastEvent",1,SWIGTYPE_p_lldb__SBBroadcaster); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBBroadcaster_BroadcastEvent",2,SWIGTYPE_p_lldb__SBEvent); + } + + (arg1)->BroadcastEvent((lldb::SBEvent const &)*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBroadcaster_BroadcastEvent(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBroadcaster, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBEvent, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBBroadcaster_BroadcastEvent__SWIG_1(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBroadcaster, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBEvent, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[2]); + } + if (_v) { + return _wrap_SBBroadcaster_BroadcastEvent__SWIG_0(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBBroadcaster_AddInitialEventsToListener(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ; + lldb::SBListener *arg2 = 0 ; + uint32_t arg3 ; + + SWIG_check_num_args("lldb::SBBroadcaster::AddInitialEventsToListener",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBroadcaster::AddInitialEventsToListener",1,"lldb::SBBroadcaster *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBroadcaster::AddInitialEventsToListener",2,"lldb::SBListener const &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBBroadcaster::AddInitialEventsToListener",3,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBroadcaster,0))){ + SWIG_fail_ptr("SBBroadcaster_AddInitialEventsToListener",1,SWIGTYPE_p_lldb__SBBroadcaster); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBListener,0))){ + SWIG_fail_ptr("SBBroadcaster_AddInitialEventsToListener",2,SWIGTYPE_p_lldb__SBListener); + } + + arg3 = (uint32_t)lua_tointeger(L, 3); + (arg1)->AddInitialEventsToListener((lldb::SBListener const &)*arg2,arg3); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBroadcaster_AddListener(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ; + lldb::SBListener *arg2 = 0 ; + uint32_t arg3 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBBroadcaster::AddListener",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBroadcaster::AddListener",1,"lldb::SBBroadcaster *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBroadcaster::AddListener",2,"lldb::SBListener const &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBBroadcaster::AddListener",3,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBroadcaster,0))){ + SWIG_fail_ptr("SBBroadcaster_AddListener",1,SWIGTYPE_p_lldb__SBBroadcaster); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBListener,0))){ + SWIG_fail_ptr("SBBroadcaster_AddListener",2,SWIGTYPE_p_lldb__SBListener); + } + + arg3 = (uint32_t)lua_tointeger(L, 3); + result = (uint32_t)(arg1)->AddListener((lldb::SBListener const &)*arg2,arg3); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBroadcaster_GetName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBBroadcaster::GetName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBroadcaster::GetName",1,"lldb::SBBroadcaster const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBroadcaster,0))){ + SWIG_fail_ptr("SBBroadcaster_GetName",1,SWIGTYPE_p_lldb__SBBroadcaster); + } + + result = (char *)((lldb::SBBroadcaster const *)arg1)->GetName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBroadcaster_EventTypeHasListeners(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ; + uint32_t arg2 ; + bool result; + + SWIG_check_num_args("lldb::SBBroadcaster::EventTypeHasListeners",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBroadcaster::EventTypeHasListeners",1,"lldb::SBBroadcaster *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBBroadcaster::EventTypeHasListeners",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBroadcaster,0))){ + SWIG_fail_ptr("SBBroadcaster_EventTypeHasListeners",1,SWIGTYPE_p_lldb__SBBroadcaster); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (bool)(arg1)->EventTypeHasListeners(arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBroadcaster_RemoveListener__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ; + lldb::SBListener *arg2 = 0 ; + uint32_t arg3 ; + bool result; + + SWIG_check_num_args("lldb::SBBroadcaster::RemoveListener",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBroadcaster::RemoveListener",1,"lldb::SBBroadcaster *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBroadcaster::RemoveListener",2,"lldb::SBListener const &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBBroadcaster::RemoveListener",3,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBroadcaster,0))){ + SWIG_fail_ptr("SBBroadcaster_RemoveListener",1,SWIGTYPE_p_lldb__SBBroadcaster); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBListener,0))){ + SWIG_fail_ptr("SBBroadcaster_RemoveListener",2,SWIGTYPE_p_lldb__SBListener); + } + + arg3 = (uint32_t)lua_tointeger(L, 3); + result = (bool)(arg1)->RemoveListener((lldb::SBListener const &)*arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBroadcaster_RemoveListener__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ; + lldb::SBListener *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBBroadcaster::RemoveListener",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBroadcaster::RemoveListener",1,"lldb::SBBroadcaster *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBroadcaster::RemoveListener",2,"lldb::SBListener const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBroadcaster,0))){ + SWIG_fail_ptr("SBBroadcaster_RemoveListener",1,SWIGTYPE_p_lldb__SBBroadcaster); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBListener,0))){ + SWIG_fail_ptr("SBBroadcaster_RemoveListener",2,SWIGTYPE_p_lldb__SBListener); + } + + result = (bool)(arg1)->RemoveListener((lldb::SBListener const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBroadcaster_RemoveListener(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBroadcaster, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBListener, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBBroadcaster_RemoveListener__SWIG_1(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBBroadcaster, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBListener, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + return _wrap_SBBroadcaster_RemoveListener__SWIG_0(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBBroadcaster___eq(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ; + lldb::SBBroadcaster *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBBroadcaster::operator ==",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBroadcaster::operator ==",1,"lldb::SBBroadcaster const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBroadcaster::operator ==",2,"lldb::SBBroadcaster const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBroadcaster,0))){ + SWIG_fail_ptr("SBBroadcaster___eq",1,SWIGTYPE_p_lldb__SBBroadcaster); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBBroadcaster,0))){ + SWIG_fail_ptr("SBBroadcaster___eq",2,SWIGTYPE_p_lldb__SBBroadcaster); + } + + result = (bool)((lldb::SBBroadcaster const *)arg1)->operator ==((lldb::SBBroadcaster const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBBroadcaster___lt(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) 0 ; + lldb::SBBroadcaster *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBBroadcaster::operator <",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBBroadcaster::operator <",1,"lldb::SBBroadcaster const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBBroadcaster::operator <",2,"lldb::SBBroadcaster const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBBroadcaster,0))){ + SWIG_fail_ptr("SBBroadcaster___lt",1,SWIGTYPE_p_lldb__SBBroadcaster); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBBroadcaster,0))){ + SWIG_fail_ptr("SBBroadcaster___lt",2,SWIGTYPE_p_lldb__SBBroadcaster); + } + + result = (bool)((lldb::SBBroadcaster const *)arg1)->operator <((lldb::SBBroadcaster const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBBroadcaster(void *obj) { +lldb::SBBroadcaster *arg1 = (lldb::SBBroadcaster *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBBroadcaster(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBBroadcaster); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBBroadcaster_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBBroadcaster_methods[]= { + { "IsValid", _wrap_SBBroadcaster_IsValid}, + { "Clear", _wrap_SBBroadcaster_Clear}, + { "BroadcastEventByType", _wrap_SBBroadcaster_BroadcastEventByType}, + { "BroadcastEvent", _wrap_SBBroadcaster_BroadcastEvent}, + { "AddInitialEventsToListener", _wrap_SBBroadcaster_AddInitialEventsToListener}, + { "AddListener", _wrap_SBBroadcaster_AddListener}, + { "GetName", _wrap_SBBroadcaster_GetName}, + { "EventTypeHasListeners", _wrap_SBBroadcaster_EventTypeHasListeners}, + { "RemoveListener", _wrap_SBBroadcaster_RemoveListener}, + { "__eq", _wrap_SBBroadcaster___eq}, + { "__lt", _wrap_SBBroadcaster___lt}, + {0,0} +}; +static swig_lua_method swig_SBBroadcaster_meta[] = { + { "__eq", _wrap_SBBroadcaster___eq}, + { "__lt", _wrap_SBBroadcaster___lt}, + {0,0} +}; + +static swig_lua_attribute swig_SBBroadcaster_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBBroadcaster_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBBroadcaster_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBBroadcaster_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBBroadcaster_Sf_SwigStatic = { + "SBBroadcaster", + swig_SBBroadcaster_Sf_SwigStatic_methods, + swig_SBBroadcaster_Sf_SwigStatic_attributes, + swig_SBBroadcaster_Sf_SwigStatic_constants, + swig_SBBroadcaster_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBBroadcaster_bases[] = {0}; +static const char *swig_SBBroadcaster_base_names[] = {0}; +static swig_lua_class _wrap_class_SBBroadcaster = { "SBBroadcaster", "SBBroadcaster", &SWIGTYPE_p_lldb__SBBroadcaster,_proxy__wrap_new_SBBroadcaster, swig_delete_SBBroadcaster, swig_SBBroadcaster_methods, swig_SBBroadcaster_attributes, &swig_SBBroadcaster_Sf_SwigStatic, swig_SBBroadcaster_meta, swig_SBBroadcaster_bases, swig_SBBroadcaster_base_names }; + +static int _wrap_new_SBCommandInterpreter__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *result = 0 ; + + SWIG_check_num_args("lldb::SBCommandInterpreter::SBCommandInterpreter",0,0) + result = (lldb::SBCommandInterpreter *)new lldb::SBCommandInterpreter(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBCommandInterpreter,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBCommandInterpreter__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *arg1 = 0 ; + lldb::SBCommandInterpreter *result = 0 ; + + SWIG_check_num_args("lldb::SBCommandInterpreter::SBCommandInterpreter",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::SBCommandInterpreter",1,"lldb::SBCommandInterpreter const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){ + SWIG_fail_ptr("new_SBCommandInterpreter",1,SWIGTYPE_p_lldb__SBCommandInterpreter); + } + + result = (lldb::SBCommandInterpreter *)new lldb::SBCommandInterpreter((lldb::SBCommandInterpreter const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBCommandInterpreter,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBCommandInterpreter(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBCommandInterpreter__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandInterpreter, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBCommandInterpreter__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBCommandInterpreter'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBCommandInterpreter::SBCommandInterpreter()\n" + " lldb::SBCommandInterpreter::SBCommandInterpreter(lldb::SBCommandInterpreter const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBCommandInterpreter_GetArgumentTypeAsCString(lua_State* L) { + { + int SWIG_arg = 0; + lldb::CommandArgumentType arg1 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBCommandInterpreter::GetArgumentTypeAsCString",1,1) + if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::GetArgumentTypeAsCString",1,"lldb::CommandArgumentType const"); + arg1 = (lldb::CommandArgumentType const)lua_tointeger(L, 1); + result = (char *)lldb::SBCommandInterpreter::GetArgumentTypeAsCString(arg1); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_GetArgumentDescriptionAsCString(lua_State* L) { + { + int SWIG_arg = 0; + lldb::CommandArgumentType arg1 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBCommandInterpreter::GetArgumentDescriptionAsCString",1,1) + if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::GetArgumentDescriptionAsCString",1,"lldb::CommandArgumentType const"); + arg1 = (lldb::CommandArgumentType const)lua_tointeger(L, 1); + result = (char *)lldb::SBCommandInterpreter::GetArgumentDescriptionAsCString(arg1); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_EventIsCommandInterpreterEvent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommandInterpreter::EventIsCommandInterpreterEvent",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::EventIsCommandInterpreterEvent",1,"lldb::SBEvent const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBCommandInterpreter_EventIsCommandInterpreterEvent",1,SWIGTYPE_p_lldb__SBEvent); + } + + result = (bool)lldb::SBCommandInterpreter::EventIsCommandInterpreterEvent((lldb::SBEvent const &)*arg1); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommandInterpreter::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::IsValid",1,"lldb::SBCommandInterpreter const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){ + SWIG_fail_ptr("SBCommandInterpreter_IsValid",1,SWIGTYPE_p_lldb__SBCommandInterpreter); + } + + result = (bool)((lldb::SBCommandInterpreter const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_CommandExists(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + char *arg2 = (char *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommandInterpreter::CommandExists",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::CommandExists",1,"lldb::SBCommandInterpreter *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreter::CommandExists",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){ + SWIG_fail_ptr("SBCommandInterpreter_CommandExists",1,SWIGTYPE_p_lldb__SBCommandInterpreter); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (bool)(arg1)->CommandExists((char const *)arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_UserCommandExists(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + char *arg2 = (char *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommandInterpreter::UserCommandExists",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::UserCommandExists",1,"lldb::SBCommandInterpreter *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreter::UserCommandExists",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){ + SWIG_fail_ptr("SBCommandInterpreter_UserCommandExists",1,SWIGTYPE_p_lldb__SBCommandInterpreter); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (bool)(arg1)->UserCommandExists((char const *)arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_AliasExists(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + char *arg2 = (char *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommandInterpreter::AliasExists",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::AliasExists",1,"lldb::SBCommandInterpreter *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreter::AliasExists",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){ + SWIG_fail_ptr("SBCommandInterpreter_AliasExists",1,SWIGTYPE_p_lldb__SBCommandInterpreter); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (bool)(arg1)->AliasExists((char const *)arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_GetBroadcaster(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + lldb::SBBroadcaster result; + + SWIG_check_num_args("lldb::SBCommandInterpreter::GetBroadcaster",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::GetBroadcaster",1,"lldb::SBCommandInterpreter *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){ + SWIG_fail_ptr("SBCommandInterpreter_GetBroadcaster",1,SWIGTYPE_p_lldb__SBCommandInterpreter); + } + + result = (arg1)->GetBroadcaster(); + { + lldb::SBBroadcaster * resultptr = new lldb::SBBroadcaster(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBroadcaster,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_GetBroadcasterClass(lua_State* L) { + { + int SWIG_arg = 0; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBCommandInterpreter::GetBroadcasterClass",0,0) + result = (char *)lldb::SBCommandInterpreter::GetBroadcasterClass(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_HasCommands(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommandInterpreter::HasCommands",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::HasCommands",1,"lldb::SBCommandInterpreter *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){ + SWIG_fail_ptr("SBCommandInterpreter_HasCommands",1,SWIGTYPE_p_lldb__SBCommandInterpreter); + } + + result = (bool)(arg1)->HasCommands(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_HasAliases(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommandInterpreter::HasAliases",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::HasAliases",1,"lldb::SBCommandInterpreter *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){ + SWIG_fail_ptr("SBCommandInterpreter_HasAliases",1,SWIGTYPE_p_lldb__SBCommandInterpreter); + } + + result = (bool)(arg1)->HasAliases(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_HasAliasOptions(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommandInterpreter::HasAliasOptions",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::HasAliasOptions",1,"lldb::SBCommandInterpreter *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){ + SWIG_fail_ptr("SBCommandInterpreter_HasAliasOptions",1,SWIGTYPE_p_lldb__SBCommandInterpreter); + } + + result = (bool)(arg1)->HasAliasOptions(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_IsInteractive(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommandInterpreter::IsInteractive",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::IsInteractive",1,"lldb::SBCommandInterpreter *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){ + SWIG_fail_ptr("SBCommandInterpreter_IsInteractive",1,SWIGTYPE_p_lldb__SBCommandInterpreter); + } + + result = (bool)(arg1)->IsInteractive(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_GetProcess(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + lldb::SBProcess result; + + SWIG_check_num_args("lldb::SBCommandInterpreter::GetProcess",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::GetProcess",1,"lldb::SBCommandInterpreter *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){ + SWIG_fail_ptr("SBCommandInterpreter_GetProcess",1,SWIGTYPE_p_lldb__SBCommandInterpreter); + } + + result = (arg1)->GetProcess(); + { + lldb::SBProcess * resultptr = new lldb::SBProcess(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_GetDebugger(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + lldb::SBDebugger result; + + SWIG_check_num_args("lldb::SBCommandInterpreter::GetDebugger",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::GetDebugger",1,"lldb::SBCommandInterpreter *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){ + SWIG_fail_ptr("SBCommandInterpreter_GetDebugger",1,SWIGTYPE_p_lldb__SBCommandInterpreter); + } + + result = (arg1)->GetDebugger(); + { + lldb::SBDebugger * resultptr = new lldb::SBDebugger(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBDebugger,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_SourceInitFileInHomeDirectory__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + lldb::SBCommandReturnObject *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBCommandInterpreter::SourceInitFileInHomeDirectory",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::SourceInitFileInHomeDirectory",1,"lldb::SBCommandInterpreter *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreter::SourceInitFileInHomeDirectory",2,"lldb::SBCommandReturnObject &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){ + SWIG_fail_ptr("SBCommandInterpreter_SourceInitFileInHomeDirectory",1,SWIGTYPE_p_lldb__SBCommandInterpreter); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandInterpreter_SourceInitFileInHomeDirectory",2,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + (arg1)->SourceInitFileInHomeDirectory(*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_SourceInitFileInHomeDirectory__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + lldb::SBCommandReturnObject *arg2 = 0 ; + bool arg3 ; + + SWIG_check_num_args("lldb::SBCommandInterpreter::SourceInitFileInHomeDirectory",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::SourceInitFileInHomeDirectory",1,"lldb::SBCommandInterpreter *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreter::SourceInitFileInHomeDirectory",2,"lldb::SBCommandReturnObject &"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBCommandInterpreter::SourceInitFileInHomeDirectory",3,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){ + SWIG_fail_ptr("SBCommandInterpreter_SourceInitFileInHomeDirectory",1,SWIGTYPE_p_lldb__SBCommandInterpreter); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandInterpreter_SourceInitFileInHomeDirectory",2,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + arg3 = (lua_toboolean(L, 3)!=0); + (arg1)->SourceInitFileInHomeDirectory(*arg2,arg3); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_SourceInitFileInHomeDirectory(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandInterpreter, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBCommandInterpreter_SourceInitFileInHomeDirectory__SWIG_0(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandInterpreter, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[2]); + } + if (_v) { + return _wrap_SBCommandInterpreter_SourceInitFileInHomeDirectory__SWIG_1(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBCommandInterpreter_SourceInitFileInCurrentWorkingDirectory(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + lldb::SBCommandReturnObject *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory",1,"lldb::SBCommandInterpreter *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory",2,"lldb::SBCommandReturnObject &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){ + SWIG_fail_ptr("SBCommandInterpreter_SourceInitFileInCurrentWorkingDirectory",1,SWIGTYPE_p_lldb__SBCommandInterpreter); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandInterpreter_SourceInitFileInCurrentWorkingDirectory",2,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + (arg1)->SourceInitFileInCurrentWorkingDirectory(*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_HandleCommand__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBCommandReturnObject *arg3 = 0 ; + bool arg4 ; + lldb::ReturnStatus result; + + SWIG_check_num_args("lldb::SBCommandInterpreter::HandleCommand",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommand",1,"lldb::SBCommandInterpreter *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommand",2,"char const *"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommand",3,"lldb::SBCommandReturnObject &"); + if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommand",4,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){ + SWIG_fail_ptr("SBCommandInterpreter_HandleCommand",1,SWIGTYPE_p_lldb__SBCommandInterpreter); + } + + arg2 = (char *)lua_tostring(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandInterpreter_HandleCommand",3,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + arg4 = (lua_toboolean(L, 4)!=0); + result = (lldb::ReturnStatus)(arg1)->HandleCommand((char const *)arg2,*arg3,arg4); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_HandleCommand__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBCommandReturnObject *arg3 = 0 ; + lldb::ReturnStatus result; + + SWIG_check_num_args("lldb::SBCommandInterpreter::HandleCommand",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommand",1,"lldb::SBCommandInterpreter *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommand",2,"char const *"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommand",3,"lldb::SBCommandReturnObject &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){ + SWIG_fail_ptr("SBCommandInterpreter_HandleCommand",1,SWIGTYPE_p_lldb__SBCommandInterpreter); + } + + arg2 = (char *)lua_tostring(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandInterpreter_HandleCommand",3,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + result = (lldb::ReturnStatus)(arg1)->HandleCommand((char const *)arg2,*arg3); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_HandleCommand__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBExecutionContext *arg3 = 0 ; + lldb::SBCommandReturnObject *arg4 = 0 ; + bool arg5 ; + lldb::ReturnStatus result; + + SWIG_check_num_args("lldb::SBCommandInterpreter::HandleCommand",5,5) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommand",1,"lldb::SBCommandInterpreter *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommand",2,"char const *"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommand",3,"lldb::SBExecutionContext &"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommand",4,"lldb::SBCommandReturnObject &"); + if(!lua_isboolean(L,5)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommand",5,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){ + SWIG_fail_ptr("SBCommandInterpreter_HandleCommand",1,SWIGTYPE_p_lldb__SBCommandInterpreter); + } + + arg2 = (char *)lua_tostring(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBExecutionContext,0))){ + SWIG_fail_ptr("SBCommandInterpreter_HandleCommand",3,SWIGTYPE_p_lldb__SBExecutionContext); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandInterpreter_HandleCommand",4,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + arg5 = (lua_toboolean(L, 5)!=0); + result = (lldb::ReturnStatus)(arg1)->HandleCommand((char const *)arg2,*arg3,*arg4,arg5); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_HandleCommand__SWIG_3(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBExecutionContext *arg3 = 0 ; + lldb::SBCommandReturnObject *arg4 = 0 ; + lldb::ReturnStatus result; + + SWIG_check_num_args("lldb::SBCommandInterpreter::HandleCommand",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommand",1,"lldb::SBCommandInterpreter *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommand",2,"char const *"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommand",3,"lldb::SBExecutionContext &"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommand",4,"lldb::SBCommandReturnObject &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){ + SWIG_fail_ptr("SBCommandInterpreter_HandleCommand",1,SWIGTYPE_p_lldb__SBCommandInterpreter); + } + + arg2 = (char *)lua_tostring(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBExecutionContext,0))){ + SWIG_fail_ptr("SBCommandInterpreter_HandleCommand",3,SWIGTYPE_p_lldb__SBExecutionContext); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandInterpreter_HandleCommand",4,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + result = (lldb::ReturnStatus)(arg1)->HandleCommand((char const *)arg2,*arg3,*arg4); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_HandleCommand(lua_State* L) { + int argc; + int argv[6]={ + 1,2,3,4,5,6 + }; + + argc = lua_gettop(L); + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandInterpreter, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBCommandInterpreter_HandleCommand__SWIG_1(L); + } + } + } + } + if (argc == 4) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandInterpreter, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[3]); + } + if (_v) { + return _wrap_SBCommandInterpreter_HandleCommand__SWIG_0(L); + } + } + } + } + } + if (argc == 4) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandInterpreter, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBExecutionContext, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBCommandInterpreter_HandleCommand__SWIG_3(L); + } + } + } + } + } + if (argc == 5) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandInterpreter, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBExecutionContext, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[4]); + } + if (_v) { + return _wrap_SBCommandInterpreter_HandleCommand__SWIG_2(L); + } + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBCommandInterpreter_HandleCommandsFromFile(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + lldb::SBFileSpec *arg2 = 0 ; + lldb::SBExecutionContext *arg3 = 0 ; + lldb::SBCommandInterpreterRunOptions *arg4 = 0 ; + lldb::SBCommandReturnObject arg5 ; + lldb::SBCommandReturnObject *argp5 ; + + SWIG_check_num_args("lldb::SBCommandInterpreter::HandleCommandsFromFile",5,5) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommandsFromFile",1,"lldb::SBCommandInterpreter *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommandsFromFile",2,"lldb::SBFileSpec &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommandsFromFile",3,"lldb::SBExecutionContext &"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommandsFromFile",4,"lldb::SBCommandInterpreterRunOptions &"); + if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCommandsFromFile",5,"lldb::SBCommandReturnObject"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){ + SWIG_fail_ptr("SBCommandInterpreter_HandleCommandsFromFile",1,SWIGTYPE_p_lldb__SBCommandInterpreter); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBCommandInterpreter_HandleCommandsFromFile",2,SWIGTYPE_p_lldb__SBFileSpec); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBExecutionContext,0))){ + SWIG_fail_ptr("SBCommandInterpreter_HandleCommandsFromFile",3,SWIGTYPE_p_lldb__SBExecutionContext); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){ + SWIG_fail_ptr("SBCommandInterpreter_HandleCommandsFromFile",4,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&argp5,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandInterpreter_HandleCommandsFromFile",5,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + arg5 = *argp5; + + (arg1)->HandleCommandsFromFile(*arg2,*arg3,*arg4,arg5); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_HandleCompletion(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + char *arg2 = (char *) 0 ; + uint32_t arg3 ; + int arg4 ; + int arg5 ; + lldb::SBStringList *arg6 = 0 ; + int result; + + SWIG_check_num_args("lldb::SBCommandInterpreter::HandleCompletion",6,6) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCompletion",1,"lldb::SBCommandInterpreter *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCompletion",2,"char const *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCompletion",3,"uint32_t"); + if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCompletion",4,"int"); + if(!lua_isinteger(L,5)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCompletion",5,"int"); + if(!lua_isuserdata(L,6)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCompletion",6,"lldb::SBStringList &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){ + SWIG_fail_ptr("SBCommandInterpreter_HandleCompletion",1,SWIGTYPE_p_lldb__SBCommandInterpreter); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (uint32_t)lua_tointeger(L, 3); + arg4 = (int)lua_tointeger(L, 4); + arg5 = (int)lua_tointeger(L, 5); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_lldb__SBStringList,0))){ + SWIG_fail_ptr("SBCommandInterpreter_HandleCompletion",6,SWIGTYPE_p_lldb__SBStringList); + } + + result = (int)(arg1)->HandleCompletion((char const *)arg2,arg3,arg4,arg5,*arg6); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_HandleCompletionWithDescriptions(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + char *arg2 = (char *) 0 ; + uint32_t arg3 ; + int arg4 ; + int arg5 ; + lldb::SBStringList *arg6 = 0 ; + lldb::SBStringList *arg7 = 0 ; + int result; + + SWIG_check_num_args("lldb::SBCommandInterpreter::HandleCompletionWithDescriptions",7,7) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCompletionWithDescriptions",1,"lldb::SBCommandInterpreter *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCompletionWithDescriptions",2,"char const *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCompletionWithDescriptions",3,"uint32_t"); + if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCompletionWithDescriptions",4,"int"); + if(!lua_isinteger(L,5)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCompletionWithDescriptions",5,"int"); + if(!lua_isuserdata(L,6)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCompletionWithDescriptions",6,"lldb::SBStringList &"); + if(!lua_isuserdata(L,7)) SWIG_fail_arg("lldb::SBCommandInterpreter::HandleCompletionWithDescriptions",7,"lldb::SBStringList &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){ + SWIG_fail_ptr("SBCommandInterpreter_HandleCompletionWithDescriptions",1,SWIGTYPE_p_lldb__SBCommandInterpreter); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (uint32_t)lua_tointeger(L, 3); + arg4 = (int)lua_tointeger(L, 4); + arg5 = (int)lua_tointeger(L, 5); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_lldb__SBStringList,0))){ + SWIG_fail_ptr("SBCommandInterpreter_HandleCompletionWithDescriptions",6,SWIGTYPE_p_lldb__SBStringList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,7,(void**)&arg7,SWIGTYPE_p_lldb__SBStringList,0))){ + SWIG_fail_ptr("SBCommandInterpreter_HandleCompletionWithDescriptions",7,SWIGTYPE_p_lldb__SBStringList); + } + + result = (int)(arg1)->HandleCompletionWithDescriptions((char const *)arg2,arg3,arg4,arg5,*arg6,*arg7); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_WasInterrupted(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommandInterpreter::WasInterrupted",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::WasInterrupted",1,"lldb::SBCommandInterpreter const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){ + SWIG_fail_ptr("SBCommandInterpreter_WasInterrupted",1,SWIGTYPE_p_lldb__SBCommandInterpreter); + } + + result = (bool)((lldb::SBCommandInterpreter const *)arg1)->WasInterrupted(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_InterruptCommand(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommandInterpreter::InterruptCommand",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::InterruptCommand",1,"lldb::SBCommandInterpreter *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){ + SWIG_fail_ptr("SBCommandInterpreter_InterruptCommand",1,SWIGTYPE_p_lldb__SBCommandInterpreter); + } + + result = (bool)(arg1)->InterruptCommand(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_SetCommandOverrideCallback(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + char *arg2 = (char *) 0 ; + lldb::CommandOverrideCallback arg3 = (lldb::CommandOverrideCallback) 0 ; + void *arg4 = (void *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommandInterpreter::SetCommandOverrideCallback",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::SetCommandOverrideCallback",1,"lldb::SBCommandInterpreter *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreter::SetCommandOverrideCallback",2,"char const *"); + if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("lldb::SBCommandInterpreter::SetCommandOverrideCallback",3,"lldb::CommandOverrideCallback"); + if(!SWIG_isptrtype(L,4)) SWIG_fail_arg("lldb::SBCommandInterpreter::SetCommandOverrideCallback",4,"void *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){ + SWIG_fail_ptr("SBCommandInterpreter_SetCommandOverrideCallback",1,SWIGTYPE_p_lldb__SBCommandInterpreter); + } + + arg2 = (char *)lua_tostring(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_f_p_void_p_p_q_const__char__bool,0))){ + SWIG_fail_ptr("SBCommandInterpreter_SetCommandOverrideCallback",3,SWIGTYPE_p_f_p_void_p_p_q_const__char__bool); + } + + arg4=(void *)SWIG_MustGetPtr(L,4,0,0,4,"SBCommandInterpreter_SetCommandOverrideCallback"); + result = (bool)(arg1)->SetCommandOverrideCallback((char const *)arg2,arg3,arg4); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_IsActive(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommandInterpreter::IsActive",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::IsActive",1,"lldb::SBCommandInterpreter *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){ + SWIG_fail_ptr("SBCommandInterpreter_IsActive",1,SWIGTYPE_p_lldb__SBCommandInterpreter); + } + + result = (bool)(arg1)->IsActive(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_GetIOHandlerControlSequence(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + char arg2 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBCommandInterpreter::GetIOHandlerControlSequence",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::GetIOHandlerControlSequence",1,"lldb::SBCommandInterpreter *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreter::GetIOHandlerControlSequence",2,"char"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){ + SWIG_fail_ptr("SBCommandInterpreter_GetIOHandlerControlSequence",1,SWIGTYPE_p_lldb__SBCommandInterpreter); + } + + arg2 = (lua_tostring(L, 2))[0]; + result = (char *)(arg1)->GetIOHandlerControlSequence(arg2); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_GetPromptOnQuit(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommandInterpreter::GetPromptOnQuit",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::GetPromptOnQuit",1,"lldb::SBCommandInterpreter *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){ + SWIG_fail_ptr("SBCommandInterpreter_GetPromptOnQuit",1,SWIGTYPE_p_lldb__SBCommandInterpreter); + } + + result = (bool)(arg1)->GetPromptOnQuit(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_SetPromptOnQuit(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBCommandInterpreter::SetPromptOnQuit",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::SetPromptOnQuit",1,"lldb::SBCommandInterpreter *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreter::SetPromptOnQuit",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){ + SWIG_fail_ptr("SBCommandInterpreter_SetPromptOnQuit",1,SWIGTYPE_p_lldb__SBCommandInterpreter); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetPromptOnQuit(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_AllowExitCodeOnQuit(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBCommandInterpreter::AllowExitCodeOnQuit",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::AllowExitCodeOnQuit",1,"lldb::SBCommandInterpreter *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreter::AllowExitCodeOnQuit",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){ + SWIG_fail_ptr("SBCommandInterpreter_AllowExitCodeOnQuit",1,SWIGTYPE_p_lldb__SBCommandInterpreter); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->AllowExitCodeOnQuit(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_HasCustomQuitExitCode(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommandInterpreter::HasCustomQuitExitCode",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::HasCustomQuitExitCode",1,"lldb::SBCommandInterpreter *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){ + SWIG_fail_ptr("SBCommandInterpreter_HasCustomQuitExitCode",1,SWIGTYPE_p_lldb__SBCommandInterpreter); + } + + result = (bool)(arg1)->HasCustomQuitExitCode(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_GetQuitStatus(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + int result; + + SWIG_check_num_args("lldb::SBCommandInterpreter::GetQuitStatus",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::GetQuitStatus",1,"lldb::SBCommandInterpreter *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){ + SWIG_fail_ptr("SBCommandInterpreter_GetQuitStatus",1,SWIGTYPE_p_lldb__SBCommandInterpreter); + } + + result = (int)(arg1)->GetQuitStatus(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_ResolveCommand(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBCommandReturnObject *arg3 = 0 ; + + SWIG_check_num_args("lldb::SBCommandInterpreter::ResolveCommand",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::ResolveCommand",1,"lldb::SBCommandInterpreter *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreter::ResolveCommand",2,"char const *"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBCommandInterpreter::ResolveCommand",3,"lldb::SBCommandReturnObject &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){ + SWIG_fail_ptr("SBCommandInterpreter_ResolveCommand",1,SWIGTYPE_p_lldb__SBCommandInterpreter); + } + + arg2 = (char *)lua_tostring(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandInterpreter_ResolveCommand",3,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + (arg1)->ResolveCommand((char const *)arg2,*arg3); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_GetStatistics(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + lldb::SBStructuredData result; + + SWIG_check_num_args("lldb::SBCommandInterpreter::GetStatistics",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::GetStatistics",1,"lldb::SBCommandInterpreter *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){ + SWIG_fail_ptr("SBCommandInterpreter_GetStatistics",1,SWIGTYPE_p_lldb__SBCommandInterpreter); + } + + result = (arg1)->GetStatistics(); + { + lldb::SBStructuredData * resultptr = new lldb::SBStructuredData(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBStructuredData,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreter_GetTranscript(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) 0 ; + lldb::SBStructuredData result; + + SWIG_check_num_args("lldb::SBCommandInterpreter::GetTranscript",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreter::GetTranscript",1,"lldb::SBCommandInterpreter *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreter,0))){ + SWIG_fail_ptr("SBCommandInterpreter_GetTranscript",1,SWIGTYPE_p_lldb__SBCommandInterpreter); + } + + result = (arg1)->GetTranscript(); + { + lldb::SBStructuredData * resultptr = new lldb::SBStructuredData(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBStructuredData,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBCommandInterpreter(void *obj) { +lldb::SBCommandInterpreter *arg1 = (lldb::SBCommandInterpreter *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBCommandInterpreter(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBCommandInterpreter); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBCommandInterpreter_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBCommandInterpreter_methods[]= { + { "IsValid", _wrap_SBCommandInterpreter_IsValid}, + { "CommandExists", _wrap_SBCommandInterpreter_CommandExists}, + { "UserCommandExists", _wrap_SBCommandInterpreter_UserCommandExists}, + { "AliasExists", _wrap_SBCommandInterpreter_AliasExists}, + { "GetBroadcaster", _wrap_SBCommandInterpreter_GetBroadcaster}, + { "HasCommands", _wrap_SBCommandInterpreter_HasCommands}, + { "HasAliases", _wrap_SBCommandInterpreter_HasAliases}, + { "HasAliasOptions", _wrap_SBCommandInterpreter_HasAliasOptions}, + { "IsInteractive", _wrap_SBCommandInterpreter_IsInteractive}, + { "GetProcess", _wrap_SBCommandInterpreter_GetProcess}, + { "GetDebugger", _wrap_SBCommandInterpreter_GetDebugger}, + { "SourceInitFileInHomeDirectory", _wrap_SBCommandInterpreter_SourceInitFileInHomeDirectory}, + { "SourceInitFileInCurrentWorkingDirectory", _wrap_SBCommandInterpreter_SourceInitFileInCurrentWorkingDirectory}, + { "HandleCommand", _wrap_SBCommandInterpreter_HandleCommand}, + { "HandleCommandsFromFile", _wrap_SBCommandInterpreter_HandleCommandsFromFile}, + { "HandleCompletion", _wrap_SBCommandInterpreter_HandleCompletion}, + { "HandleCompletionWithDescriptions", _wrap_SBCommandInterpreter_HandleCompletionWithDescriptions}, + { "WasInterrupted", _wrap_SBCommandInterpreter_WasInterrupted}, + { "InterruptCommand", _wrap_SBCommandInterpreter_InterruptCommand}, + { "SetCommandOverrideCallback", _wrap_SBCommandInterpreter_SetCommandOverrideCallback}, + { "IsActive", _wrap_SBCommandInterpreter_IsActive}, + { "GetIOHandlerControlSequence", _wrap_SBCommandInterpreter_GetIOHandlerControlSequence}, + { "GetPromptOnQuit", _wrap_SBCommandInterpreter_GetPromptOnQuit}, + { "SetPromptOnQuit", _wrap_SBCommandInterpreter_SetPromptOnQuit}, + { "AllowExitCodeOnQuit", _wrap_SBCommandInterpreter_AllowExitCodeOnQuit}, + { "HasCustomQuitExitCode", _wrap_SBCommandInterpreter_HasCustomQuitExitCode}, + { "GetQuitStatus", _wrap_SBCommandInterpreter_GetQuitStatus}, + { "ResolveCommand", _wrap_SBCommandInterpreter_ResolveCommand}, + { "GetStatistics", _wrap_SBCommandInterpreter_GetStatistics}, + { "GetTranscript", _wrap_SBCommandInterpreter_GetTranscript}, + {0,0} +}; +static swig_lua_method swig_SBCommandInterpreter_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBCommandInterpreter_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBCommandInterpreter_Sf_SwigStatic_constants[]= { + {SWIG_LUA_CONSTTAB_INT("eBroadcastBitThreadShouldExit", (lldb::SBCommandInterpreter::eBroadcastBitThreadShouldExit))}, + {SWIG_LUA_CONSTTAB_INT("eBroadcastBitResetPrompt", (lldb::SBCommandInterpreter::eBroadcastBitResetPrompt))}, + {SWIG_LUA_CONSTTAB_INT("eBroadcastBitQuitCommandReceived", (lldb::SBCommandInterpreter::eBroadcastBitQuitCommandReceived))}, + {SWIG_LUA_CONSTTAB_INT("eBroadcastBitAsynchronousOutputData", (lldb::SBCommandInterpreter::eBroadcastBitAsynchronousOutputData))}, + {SWIG_LUA_CONSTTAB_INT("eBroadcastBitAsynchronousErrorData", (lldb::SBCommandInterpreter::eBroadcastBitAsynchronousErrorData))}, + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBCommandInterpreter_Sf_SwigStatic_methods[]= { + { "GetArgumentTypeAsCString", _wrap_SBCommandInterpreter_GetArgumentTypeAsCString}, + { "GetArgumentDescriptionAsCString", _wrap_SBCommandInterpreter_GetArgumentDescriptionAsCString}, + { "EventIsCommandInterpreterEvent", _wrap_SBCommandInterpreter_EventIsCommandInterpreterEvent}, + { "GetBroadcasterClass", _wrap_SBCommandInterpreter_GetBroadcasterClass}, + {0,0} +}; +static swig_lua_class* swig_SBCommandInterpreter_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBCommandInterpreter_Sf_SwigStatic = { + "SBCommandInterpreter", + swig_SBCommandInterpreter_Sf_SwigStatic_methods, + swig_SBCommandInterpreter_Sf_SwigStatic_attributes, + swig_SBCommandInterpreter_Sf_SwigStatic_constants, + swig_SBCommandInterpreter_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBCommandInterpreter_bases[] = {0}; +static const char *swig_SBCommandInterpreter_base_names[] = {0}; +static swig_lua_class _wrap_class_SBCommandInterpreter = { "SBCommandInterpreter", "SBCommandInterpreter", &SWIGTYPE_p_lldb__SBCommandInterpreter,_proxy__wrap_new_SBCommandInterpreter, swig_delete_SBCommandInterpreter, swig_SBCommandInterpreter_methods, swig_SBCommandInterpreter_attributes, &swig_SBCommandInterpreter_Sf_SwigStatic, swig_SBCommandInterpreter_meta, swig_SBCommandInterpreter_bases, swig_SBCommandInterpreter_base_names }; + +static int _wrap_new_SBCommandInterpreterRunOptions__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreterRunOptions *result = 0 ; + + SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions",0,0) + result = (lldb::SBCommandInterpreterRunOptions *)new lldb::SBCommandInterpreterRunOptions(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBCommandInterpreterRunOptions__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreterRunOptions *arg1 = 0 ; + lldb::SBCommandInterpreterRunOptions *result = 0 ; + + SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions",1,"lldb::SBCommandInterpreterRunOptions const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){ + SWIG_fail_ptr("new_SBCommandInterpreterRunOptions",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions); + } + + result = (lldb::SBCommandInterpreterRunOptions *)new lldb::SBCommandInterpreterRunOptions((lldb::SBCommandInterpreterRunOptions const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBCommandInterpreterRunOptions(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBCommandInterpreterRunOptions__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBCommandInterpreterRunOptions__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBCommandInterpreterRunOptions'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions()\n" + " lldb::SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions(lldb::SBCommandInterpreterRunOptions const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBCommandInterpreterRunOptions_GetStopOnContinue(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::GetStopOnContinue",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::GetStopOnContinue",1,"lldb::SBCommandInterpreterRunOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){ + SWIG_fail_ptr("SBCommandInterpreterRunOptions_GetStopOnContinue",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions); + } + + result = (bool)((lldb::SBCommandInterpreterRunOptions const *)arg1)->GetStopOnContinue(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreterRunOptions_SetStopOnContinue(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::SetStopOnContinue",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetStopOnContinue",1,"lldb::SBCommandInterpreterRunOptions *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetStopOnContinue",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){ + SWIG_fail_ptr("SBCommandInterpreterRunOptions_SetStopOnContinue",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetStopOnContinue(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreterRunOptions_GetStopOnError(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::GetStopOnError",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::GetStopOnError",1,"lldb::SBCommandInterpreterRunOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){ + SWIG_fail_ptr("SBCommandInterpreterRunOptions_GetStopOnError",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions); + } + + result = (bool)((lldb::SBCommandInterpreterRunOptions const *)arg1)->GetStopOnError(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreterRunOptions_SetStopOnError(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::SetStopOnError",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetStopOnError",1,"lldb::SBCommandInterpreterRunOptions *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetStopOnError",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){ + SWIG_fail_ptr("SBCommandInterpreterRunOptions_SetStopOnError",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetStopOnError(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreterRunOptions_GetStopOnCrash(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::GetStopOnCrash",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::GetStopOnCrash",1,"lldb::SBCommandInterpreterRunOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){ + SWIG_fail_ptr("SBCommandInterpreterRunOptions_GetStopOnCrash",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions); + } + + result = (bool)((lldb::SBCommandInterpreterRunOptions const *)arg1)->GetStopOnCrash(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreterRunOptions_SetStopOnCrash(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::SetStopOnCrash",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetStopOnCrash",1,"lldb::SBCommandInterpreterRunOptions *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetStopOnCrash",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){ + SWIG_fail_ptr("SBCommandInterpreterRunOptions_SetStopOnCrash",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetStopOnCrash(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreterRunOptions_GetEchoCommands(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::GetEchoCommands",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::GetEchoCommands",1,"lldb::SBCommandInterpreterRunOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){ + SWIG_fail_ptr("SBCommandInterpreterRunOptions_GetEchoCommands",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions); + } + + result = (bool)((lldb::SBCommandInterpreterRunOptions const *)arg1)->GetEchoCommands(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreterRunOptions_SetEchoCommands(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::SetEchoCommands",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetEchoCommands",1,"lldb::SBCommandInterpreterRunOptions *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetEchoCommands",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){ + SWIG_fail_ptr("SBCommandInterpreterRunOptions_SetEchoCommands",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetEchoCommands(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreterRunOptions_GetEchoCommentCommands(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::GetEchoCommentCommands",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::GetEchoCommentCommands",1,"lldb::SBCommandInterpreterRunOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){ + SWIG_fail_ptr("SBCommandInterpreterRunOptions_GetEchoCommentCommands",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions); + } + + result = (bool)((lldb::SBCommandInterpreterRunOptions const *)arg1)->GetEchoCommentCommands(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreterRunOptions_SetEchoCommentCommands(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::SetEchoCommentCommands",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetEchoCommentCommands",1,"lldb::SBCommandInterpreterRunOptions *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetEchoCommentCommands",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){ + SWIG_fail_ptr("SBCommandInterpreterRunOptions_SetEchoCommentCommands",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetEchoCommentCommands(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreterRunOptions_GetPrintResults(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::GetPrintResults",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::GetPrintResults",1,"lldb::SBCommandInterpreterRunOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){ + SWIG_fail_ptr("SBCommandInterpreterRunOptions_GetPrintResults",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions); + } + + result = (bool)((lldb::SBCommandInterpreterRunOptions const *)arg1)->GetPrintResults(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreterRunOptions_SetPrintResults(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::SetPrintResults",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetPrintResults",1,"lldb::SBCommandInterpreterRunOptions *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetPrintResults",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){ + SWIG_fail_ptr("SBCommandInterpreterRunOptions_SetPrintResults",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetPrintResults(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreterRunOptions_GetPrintErrors(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::GetPrintErrors",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::GetPrintErrors",1,"lldb::SBCommandInterpreterRunOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){ + SWIG_fail_ptr("SBCommandInterpreterRunOptions_GetPrintErrors",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions); + } + + result = (bool)((lldb::SBCommandInterpreterRunOptions const *)arg1)->GetPrintErrors(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreterRunOptions_SetPrintErrors(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::SetPrintErrors",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetPrintErrors",1,"lldb::SBCommandInterpreterRunOptions *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetPrintErrors",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){ + SWIG_fail_ptr("SBCommandInterpreterRunOptions_SetPrintErrors",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetPrintErrors(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreterRunOptions_GetAddToHistory(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::GetAddToHistory",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::GetAddToHistory",1,"lldb::SBCommandInterpreterRunOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){ + SWIG_fail_ptr("SBCommandInterpreterRunOptions_GetAddToHistory",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions); + } + + result = (bool)((lldb::SBCommandInterpreterRunOptions const *)arg1)->GetAddToHistory(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreterRunOptions_SetAddToHistory(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::SetAddToHistory",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetAddToHistory",1,"lldb::SBCommandInterpreterRunOptions *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetAddToHistory",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){ + SWIG_fail_ptr("SBCommandInterpreterRunOptions_SetAddToHistory",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetAddToHistory(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreterRunOptions_GetAutoHandleEvents(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::GetAutoHandleEvents",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::GetAutoHandleEvents",1,"lldb::SBCommandInterpreterRunOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){ + SWIG_fail_ptr("SBCommandInterpreterRunOptions_GetAutoHandleEvents",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions); + } + + result = (bool)((lldb::SBCommandInterpreterRunOptions const *)arg1)->GetAutoHandleEvents(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreterRunOptions_SetAutoHandleEvents(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::SetAutoHandleEvents",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetAutoHandleEvents",1,"lldb::SBCommandInterpreterRunOptions *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetAutoHandleEvents",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){ + SWIG_fail_ptr("SBCommandInterpreterRunOptions_SetAutoHandleEvents",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetAutoHandleEvents(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreterRunOptions_GetSpawnThread(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::GetSpawnThread",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::GetSpawnThread",1,"lldb::SBCommandInterpreterRunOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){ + SWIG_fail_ptr("SBCommandInterpreterRunOptions_GetSpawnThread",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions); + } + + result = (bool)((lldb::SBCommandInterpreterRunOptions const *)arg1)->GetSpawnThread(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreterRunOptions_SetSpawnThread(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::SetSpawnThread",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetSpawnThread",1,"lldb::SBCommandInterpreterRunOptions *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetSpawnThread",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){ + SWIG_fail_ptr("SBCommandInterpreterRunOptions_SetSpawnThread",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetSpawnThread(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreterRunOptions_GetAllowRepeats(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::GetAllowRepeats",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::GetAllowRepeats",1,"lldb::SBCommandInterpreterRunOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){ + SWIG_fail_ptr("SBCommandInterpreterRunOptions_GetAllowRepeats",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions); + } + + result = (bool)((lldb::SBCommandInterpreterRunOptions const *)arg1)->GetAllowRepeats(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandInterpreterRunOptions_SetAllowRepeats(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBCommandInterpreterRunOptions::SetAllowRepeats",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetAllowRepeats",1,"lldb::SBCommandInterpreterRunOptions *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBCommandInterpreterRunOptions::SetAllowRepeats",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){ + SWIG_fail_ptr("SBCommandInterpreterRunOptions_SetAllowRepeats",1,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetAllowRepeats(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBCommandInterpreterRunOptions(void *obj) { +lldb::SBCommandInterpreterRunOptions *arg1 = (lldb::SBCommandInterpreterRunOptions *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBCommandInterpreterRunOptions(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBCommandInterpreterRunOptions); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBCommandInterpreterRunOptions_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBCommandInterpreterRunOptions_methods[]= { + { "GetStopOnContinue", _wrap_SBCommandInterpreterRunOptions_GetStopOnContinue}, + { "SetStopOnContinue", _wrap_SBCommandInterpreterRunOptions_SetStopOnContinue}, + { "GetStopOnError", _wrap_SBCommandInterpreterRunOptions_GetStopOnError}, + { "SetStopOnError", _wrap_SBCommandInterpreterRunOptions_SetStopOnError}, + { "GetStopOnCrash", _wrap_SBCommandInterpreterRunOptions_GetStopOnCrash}, + { "SetStopOnCrash", _wrap_SBCommandInterpreterRunOptions_SetStopOnCrash}, + { "GetEchoCommands", _wrap_SBCommandInterpreterRunOptions_GetEchoCommands}, + { "SetEchoCommands", _wrap_SBCommandInterpreterRunOptions_SetEchoCommands}, + { "GetEchoCommentCommands", _wrap_SBCommandInterpreterRunOptions_GetEchoCommentCommands}, + { "SetEchoCommentCommands", _wrap_SBCommandInterpreterRunOptions_SetEchoCommentCommands}, + { "GetPrintResults", _wrap_SBCommandInterpreterRunOptions_GetPrintResults}, + { "SetPrintResults", _wrap_SBCommandInterpreterRunOptions_SetPrintResults}, + { "GetPrintErrors", _wrap_SBCommandInterpreterRunOptions_GetPrintErrors}, + { "SetPrintErrors", _wrap_SBCommandInterpreterRunOptions_SetPrintErrors}, + { "GetAddToHistory", _wrap_SBCommandInterpreterRunOptions_GetAddToHistory}, + { "SetAddToHistory", _wrap_SBCommandInterpreterRunOptions_SetAddToHistory}, + { "GetAutoHandleEvents", _wrap_SBCommandInterpreterRunOptions_GetAutoHandleEvents}, + { "SetAutoHandleEvents", _wrap_SBCommandInterpreterRunOptions_SetAutoHandleEvents}, + { "GetSpawnThread", _wrap_SBCommandInterpreterRunOptions_GetSpawnThread}, + { "SetSpawnThread", _wrap_SBCommandInterpreterRunOptions_SetSpawnThread}, + { "GetAllowRepeats", _wrap_SBCommandInterpreterRunOptions_GetAllowRepeats}, + { "SetAllowRepeats", _wrap_SBCommandInterpreterRunOptions_SetAllowRepeats}, + {0,0} +}; +static swig_lua_method swig_SBCommandInterpreterRunOptions_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBCommandInterpreterRunOptions_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBCommandInterpreterRunOptions_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBCommandInterpreterRunOptions_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBCommandInterpreterRunOptions_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBCommandInterpreterRunOptions_Sf_SwigStatic = { + "SBCommandInterpreterRunOptions", + swig_SBCommandInterpreterRunOptions_Sf_SwigStatic_methods, + swig_SBCommandInterpreterRunOptions_Sf_SwigStatic_attributes, + swig_SBCommandInterpreterRunOptions_Sf_SwigStatic_constants, + swig_SBCommandInterpreterRunOptions_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBCommandInterpreterRunOptions_bases[] = {0}; +static const char *swig_SBCommandInterpreterRunOptions_base_names[] = {0}; +static swig_lua_class _wrap_class_SBCommandInterpreterRunOptions = { "SBCommandInterpreterRunOptions", "SBCommandInterpreterRunOptions", &SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,_proxy__wrap_new_SBCommandInterpreterRunOptions, swig_delete_SBCommandInterpreterRunOptions, swig_SBCommandInterpreterRunOptions_methods, swig_SBCommandInterpreterRunOptions_attributes, &swig_SBCommandInterpreterRunOptions_Sf_SwigStatic, swig_SBCommandInterpreterRunOptions_meta, swig_SBCommandInterpreterRunOptions_bases, swig_SBCommandInterpreterRunOptions_base_names }; + +static int _wrap_new_SBCommandReturnObject__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandReturnObject *result = 0 ; + + SWIG_check_num_args("lldb::SBCommandReturnObject::SBCommandReturnObject",0,0) + result = (lldb::SBCommandReturnObject *)new lldb::SBCommandReturnObject(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBCommandReturnObject,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBCommandReturnObject__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandReturnObject *arg1 = 0 ; + lldb::SBCommandReturnObject *result = 0 ; + + SWIG_check_num_args("lldb::SBCommandReturnObject::SBCommandReturnObject",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::SBCommandReturnObject",1,"lldb::SBCommandReturnObject const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("new_SBCommandReturnObject",1,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + result = (lldb::SBCommandReturnObject *)new lldb::SBCommandReturnObject((lldb::SBCommandReturnObject const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBCommandReturnObject,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBCommandReturnObject(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBCommandReturnObject__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBCommandReturnObject__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBCommandReturnObject'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBCommandReturnObject::SBCommandReturnObject()\n" + " lldb::SBCommandReturnObject::SBCommandReturnObject(lldb::SBCommandReturnObject const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBCommandReturnObject_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommandReturnObject::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::IsValid",1,"lldb::SBCommandReturnObject const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandReturnObject_IsValid",1,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + result = (bool)((lldb::SBCommandReturnObject const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandReturnObject_GetOutput__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBCommandReturnObject::GetOutput",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::GetOutput",1,"lldb::SBCommandReturnObject *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandReturnObject_GetOutput",1,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + result = (char *)(arg1)->GetOutput(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandReturnObject_GetError__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBCommandReturnObject::GetError",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::GetError",1,"lldb::SBCommandReturnObject *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandReturnObject_GetError",1,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + result = (char *)(arg1)->GetError(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandReturnObject_PutOutput__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBFile arg2 ; + lldb::SBFile *argp2 ; + size_t result; + + SWIG_check_num_args("lldb::SBCommandReturnObject::PutOutput",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::PutOutput",1,"lldb::SBCommandReturnObject *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBCommandReturnObject::PutOutput",2,"lldb::SBFile"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandReturnObject_PutOutput",1,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBFile,0))){ + SWIG_fail_ptr("SBCommandReturnObject_PutOutput",2,SWIGTYPE_p_lldb__SBFile); + } + arg2 = *argp2; + + result = (arg1)->PutOutput(arg2); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandReturnObject_PutOutput__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ; + size_t result; + + SWIG_check_num_args("lldb::SBCommandReturnObject::PutOutput",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::PutOutput",1,"lldb::SBCommandReturnObject *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandReturnObject_PutOutput",1,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + { + luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 2, LUA_FILEHANDLE); + lldb::FileSP file_sp; + file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false); + if (!file_sp->IsValid()) + return luaL_error(L, "Invalid file"); + arg2 = file_sp; + } + result = (arg1)->PutOutput(arg2); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandReturnObject_PutOutput(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBCommandReturnObject_PutOutput__SWIG_0(L); + } + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = (lua_isuserdata(L, argv[1])) && + (luaL_testudata(L, argv[1], LUA_FILEHANDLE) != nullptr); + } + if (_v) { + return _wrap_SBCommandReturnObject_PutOutput__SWIG_1(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBCommandReturnObject_GetOutputSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + size_t result; + + SWIG_check_num_args("lldb::SBCommandReturnObject::GetOutputSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::GetOutputSize",1,"lldb::SBCommandReturnObject *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandReturnObject_GetOutputSize",1,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + result = (arg1)->GetOutputSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandReturnObject_GetErrorSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + size_t result; + + SWIG_check_num_args("lldb::SBCommandReturnObject::GetErrorSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::GetErrorSize",1,"lldb::SBCommandReturnObject *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandReturnObject_GetErrorSize",1,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + result = (arg1)->GetErrorSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandReturnObject_PutError__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBFile arg2 ; + lldb::SBFile *argp2 ; + size_t result; + + SWIG_check_num_args("lldb::SBCommandReturnObject::PutError",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::PutError",1,"lldb::SBCommandReturnObject *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBCommandReturnObject::PutError",2,"lldb::SBFile"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandReturnObject_PutError",1,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBFile,0))){ + SWIG_fail_ptr("SBCommandReturnObject_PutError",2,SWIGTYPE_p_lldb__SBFile); + } + arg2 = *argp2; + + result = (arg1)->PutError(arg2); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandReturnObject_PutError__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ; + size_t result; + + SWIG_check_num_args("lldb::SBCommandReturnObject::PutError",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::PutError",1,"lldb::SBCommandReturnObject *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandReturnObject_PutError",1,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + { + luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 2, LUA_FILEHANDLE); + lldb::FileSP file_sp; + file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false); + if (!file_sp->IsValid()) + return luaL_error(L, "Invalid file"); + arg2 = file_sp; + } + result = (arg1)->PutError(arg2); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandReturnObject_PutError(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBCommandReturnObject_PutError__SWIG_0(L); + } + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = (lua_isuserdata(L, argv[1])) && + (luaL_testudata(L, argv[1], LUA_FILEHANDLE) != nullptr); + } + if (_v) { + return _wrap_SBCommandReturnObject_PutError__SWIG_1(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBCommandReturnObject_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + + SWIG_check_num_args("lldb::SBCommandReturnObject::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::Clear",1,"lldb::SBCommandReturnObject *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandReturnObject_Clear",1,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandReturnObject_GetStatus(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::ReturnStatus result; + + SWIG_check_num_args("lldb::SBCommandReturnObject::GetStatus",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::GetStatus",1,"lldb::SBCommandReturnObject *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandReturnObject_GetStatus",1,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + result = (lldb::ReturnStatus)(arg1)->GetStatus(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandReturnObject_SetStatus(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::ReturnStatus arg2 ; + + SWIG_check_num_args("lldb::SBCommandReturnObject::SetStatus",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetStatus",1,"lldb::SBCommandReturnObject *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetStatus",2,"lldb::ReturnStatus"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandReturnObject_SetStatus",1,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + arg2 = (lldb::ReturnStatus)lua_tointeger(L, 2); + (arg1)->SetStatus(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandReturnObject_Succeeded(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommandReturnObject::Succeeded",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::Succeeded",1,"lldb::SBCommandReturnObject *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandReturnObject_Succeeded",1,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + result = (bool)(arg1)->Succeeded(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandReturnObject_HasResult(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommandReturnObject::HasResult",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::HasResult",1,"lldb::SBCommandReturnObject *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandReturnObject_HasResult",1,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + result = (bool)(arg1)->HasResult(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandReturnObject_AppendMessage(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBCommandReturnObject::AppendMessage",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::AppendMessage",1,"lldb::SBCommandReturnObject *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBCommandReturnObject::AppendMessage",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandReturnObject_AppendMessage",1,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->AppendMessage((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandReturnObject_AppendWarning(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBCommandReturnObject::AppendWarning",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::AppendWarning",1,"lldb::SBCommandReturnObject *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBCommandReturnObject::AppendWarning",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandReturnObject_AppendWarning",1,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->AppendWarning((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandReturnObject_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommandReturnObject::GetDescription",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::GetDescription",1,"lldb::SBCommandReturnObject *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBCommandReturnObject::GetDescription",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandReturnObject_GetDescription",1,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBCommandReturnObject_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)(arg1)->GetDescription(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandReturnObject_SetImmediateOutputFile__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBFile arg2 ; + lldb::SBFile *argp2 ; + + SWIG_check_num_args("lldb::SBCommandReturnObject::SetImmediateOutputFile",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetImmediateOutputFile",1,"lldb::SBCommandReturnObject *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetImmediateOutputFile",2,"lldb::SBFile"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandReturnObject_SetImmediateOutputFile",1,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBFile,0))){ + SWIG_fail_ptr("SBCommandReturnObject_SetImmediateOutputFile",2,SWIGTYPE_p_lldb__SBFile); + } + arg2 = *argp2; + + (arg1)->SetImmediateOutputFile(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandReturnObject_SetImmediateErrorFile__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBFile arg2 ; + lldb::SBFile *argp2 ; + + SWIG_check_num_args("lldb::SBCommandReturnObject::SetImmediateErrorFile",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetImmediateErrorFile",1,"lldb::SBCommandReturnObject *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetImmediateErrorFile",2,"lldb::SBFile"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandReturnObject_SetImmediateErrorFile",1,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBFile,0))){ + SWIG_fail_ptr("SBCommandReturnObject_SetImmediateErrorFile",2,SWIGTYPE_p_lldb__SBFile); + } + arg2 = *argp2; + + (arg1)->SetImmediateErrorFile(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandReturnObject_SetImmediateOutputFile__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ; + + SWIG_check_num_args("lldb::SBCommandReturnObject::SetImmediateOutputFile",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetImmediateOutputFile",1,"lldb::SBCommandReturnObject *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandReturnObject_SetImmediateOutputFile",1,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + { + luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 2, LUA_FILEHANDLE); + lldb::FileSP file_sp; + file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false); + if (!file_sp->IsValid()) + return luaL_error(L, "Invalid file"); + arg2 = file_sp; + } + (arg1)->SetImmediateOutputFile(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandReturnObject_SetImmediateErrorFile__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ; + + SWIG_check_num_args("lldb::SBCommandReturnObject::SetImmediateErrorFile",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetImmediateErrorFile",1,"lldb::SBCommandReturnObject *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandReturnObject_SetImmediateErrorFile",1,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + { + luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 2, LUA_FILEHANDLE); + lldb::FileSP file_sp; + file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false); + if (!file_sp->IsValid()) + return luaL_error(L, "Invalid file"); + arg2 = file_sp; + } + (arg1)->SetImmediateErrorFile(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandReturnObject_PutCString__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + + SWIG_check_num_args("lldb::SBCommandReturnObject::PutCString",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::PutCString",1,"lldb::SBCommandReturnObject *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandReturnObject_PutCString",1,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + { + if (lua_isnil(L, 2)) { + arg2 = NULL; + arg3 = 0; + } else { + arg2 = (char *)luaL_checklstring(L, 2, (size_t *)&arg3); + } + } + (arg1)->PutCString((char const *)arg2,arg3); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandReturnObject_PutCString__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBCommandReturnObject::PutCString",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::PutCString",1,"lldb::SBCommandReturnObject *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBCommandReturnObject::PutCString",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandReturnObject_PutCString",1,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->PutCString((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandReturnObject_PutCString(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + if (argc <= 2) { + return _wrap_SBCommandReturnObject_PutCString__SWIG_0(L); + } + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + return _wrap_SBCommandReturnObject_PutCString__SWIG_0(L); + } + } + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + return _wrap_SBCommandReturnObject_PutCString__SWIG_1(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBCommandReturnObject_GetOutput__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + bool arg2 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBCommandReturnObject::GetOutput",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::GetOutput",1,"lldb::SBCommandReturnObject *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBCommandReturnObject::GetOutput",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandReturnObject_GetOutput",1,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + arg2 = (lua_toboolean(L, 2)!=0); + result = (char *)(arg1)->GetOutput(arg2); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandReturnObject_GetOutput(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBCommandReturnObject_GetOutput__SWIG_0(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[1]); + } + if (_v) { + return _wrap_SBCommandReturnObject_GetOutput__SWIG_1(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBCommandReturnObject_GetOutput'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBCommandReturnObject::GetOutput()\n" + " lldb::SBCommandReturnObject::GetOutput(bool)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBCommandReturnObject_GetError__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + bool arg2 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBCommandReturnObject::GetError",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::GetError",1,"lldb::SBCommandReturnObject *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBCommandReturnObject::GetError",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandReturnObject_GetError",1,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + arg2 = (lua_toboolean(L, 2)!=0); + result = (char *)(arg1)->GetError(arg2); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandReturnObject_GetError(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBCommandReturnObject_GetError__SWIG_0(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[1]); + } + if (_v) { + return _wrap_SBCommandReturnObject_GetError__SWIG_1(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBCommandReturnObject_GetError'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBCommandReturnObject::GetError()\n" + " lldb::SBCommandReturnObject::GetError(bool)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBCommandReturnObject_SetError__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBError *arg2 = 0 ; + char *arg3 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBCommandReturnObject::SetError",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetError",1,"lldb::SBCommandReturnObject *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetError",2,"lldb::SBError &"); + if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetError",3,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandReturnObject_SetError",1,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBCommandReturnObject_SetError",2,SWIGTYPE_p_lldb__SBError); + } + + arg3 = (char *)lua_tostring(L, 3); + (arg1)->SetError(*arg2,(char const *)arg3); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandReturnObject_SetError__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + lldb::SBError *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBCommandReturnObject::SetError",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetError",1,"lldb::SBCommandReturnObject *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetError",2,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandReturnObject_SetError",1,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBCommandReturnObject_SetError",2,SWIGTYPE_p_lldb__SBError); + } + + (arg1)->SetError(*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandReturnObject_SetError__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBCommandReturnObject::SetError",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetError",1,"lldb::SBCommandReturnObject *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetError",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandReturnObject_SetError",1,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetError((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandReturnObject_SetError(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBCommandReturnObject_SetError__SWIG_1(L); + } + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + return _wrap_SBCommandReturnObject_SetError__SWIG_2(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[2]); + } + if (_v) { + return _wrap_SBCommandReturnObject_SetError__SWIG_0(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBCommandReturnObject___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBCommandReturnObject::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::__repr__",1,"lldb::SBCommandReturnObject *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandReturnObject___tostring",1,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + result = lldb_SBCommandReturnObject___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandReturnObject_SetImmediateOutputFile__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ; + bool arg3 ; + + SWIG_check_num_args("lldb::SBCommandReturnObject::SetImmediateOutputFile",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetImmediateOutputFile",1,"lldb::SBCommandReturnObject *"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetImmediateOutputFile",3,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandReturnObject_SetImmediateOutputFile",1,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + { + luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 2, LUA_FILEHANDLE); + lldb::FileSP file_sp; + file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false); + if (!file_sp->IsValid()) + return luaL_error(L, "Invalid file"); + arg2 = file_sp; + } + arg3 = (lua_toboolean(L, 3)!=0); + lldb_SBCommandReturnObject_SetImmediateOutputFile__SWIG_2(arg1,SWIG_STD_MOVE(arg2),arg3); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandReturnObject_SetImmediateOutputFile(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBCommandReturnObject_SetImmediateOutputFile__SWIG_0(L); + } + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = (lua_isuserdata(L, argv[1])) && + (luaL_testudata(L, argv[1], LUA_FILEHANDLE) != nullptr); + } + if (_v) { + return _wrap_SBCommandReturnObject_SetImmediateOutputFile__SWIG_1(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = (lua_isuserdata(L, argv[1])) && + (luaL_testudata(L, argv[1], LUA_FILEHANDLE) != nullptr); + } + if (_v) { + { + _v = lua_isboolean(L,argv[2]); + } + if (_v) { + return _wrap_SBCommandReturnObject_SetImmediateOutputFile__SWIG_2(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBCommandReturnObject_SetImmediateErrorFile__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ; + bool arg3 ; + + SWIG_check_num_args("lldb::SBCommandReturnObject::SetImmediateErrorFile",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetImmediateErrorFile",1,"lldb::SBCommandReturnObject *"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBCommandReturnObject::SetImmediateErrorFile",3,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandReturnObject_SetImmediateErrorFile",1,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + { + luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 2, LUA_FILEHANDLE); + lldb::FileSP file_sp; + file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false); + if (!file_sp->IsValid()) + return luaL_error(L, "Invalid file"); + arg2 = file_sp; + } + arg3 = (lua_toboolean(L, 3)!=0); + lldb_SBCommandReturnObject_SetImmediateErrorFile__SWIG_2(arg1,SWIG_STD_MOVE(arg2),arg3); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommandReturnObject_SetImmediateErrorFile(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBCommandReturnObject_SetImmediateErrorFile__SWIG_0(L); + } + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = (lua_isuserdata(L, argv[1])) && + (luaL_testudata(L, argv[1], LUA_FILEHANDLE) != nullptr); + } + if (_v) { + return _wrap_SBCommandReturnObject_SetImmediateErrorFile__SWIG_1(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCommandReturnObject, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = (lua_isuserdata(L, argv[1])) && + (luaL_testudata(L, argv[1], LUA_FILEHANDLE) != nullptr); + } + if (_v) { + { + _v = lua_isboolean(L,argv[2]); + } + if (_v) { + return _wrap_SBCommandReturnObject_SetImmediateErrorFile__SWIG_2(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBCommandReturnObject_Print(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBCommandReturnObject::Print",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommandReturnObject::Print",1,"lldb::SBCommandReturnObject *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBCommandReturnObject::Print",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBCommandReturnObject_Print",1,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + arg2 = (char *)lua_tostring(L, 2); + lldb_SBCommandReturnObject_Print(arg1,(char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBCommandReturnObject(void *obj) { +lldb::SBCommandReturnObject *arg1 = (lldb::SBCommandReturnObject *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBCommandReturnObject(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBCommandReturnObject); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBCommandReturnObject_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBCommandReturnObject_methods[]= { + { "IsValid", _wrap_SBCommandReturnObject_IsValid}, + { "PutOutput", _wrap_SBCommandReturnObject_PutOutput}, + { "GetOutputSize", _wrap_SBCommandReturnObject_GetOutputSize}, + { "GetErrorSize", _wrap_SBCommandReturnObject_GetErrorSize}, + { "PutError", _wrap_SBCommandReturnObject_PutError}, + { "Clear", _wrap_SBCommandReturnObject_Clear}, + { "GetStatus", _wrap_SBCommandReturnObject_GetStatus}, + { "SetStatus", _wrap_SBCommandReturnObject_SetStatus}, + { "Succeeded", _wrap_SBCommandReturnObject_Succeeded}, + { "HasResult", _wrap_SBCommandReturnObject_HasResult}, + { "AppendMessage", _wrap_SBCommandReturnObject_AppendMessage}, + { "AppendWarning", _wrap_SBCommandReturnObject_AppendWarning}, + { "GetDescription", _wrap_SBCommandReturnObject_GetDescription}, + { "PutCString", _wrap_SBCommandReturnObject_PutCString}, + { "GetOutput", _wrap_SBCommandReturnObject_GetOutput}, + { "GetError", _wrap_SBCommandReturnObject_GetError}, + { "SetError", _wrap_SBCommandReturnObject_SetError}, + { "__tostring", _wrap_SBCommandReturnObject___tostring}, + { "SetImmediateOutputFile", _wrap_SBCommandReturnObject_SetImmediateOutputFile}, + { "SetImmediateErrorFile", _wrap_SBCommandReturnObject_SetImmediateErrorFile}, + { "Print", _wrap_SBCommandReturnObject_Print}, + {0,0} +}; +static swig_lua_method swig_SBCommandReturnObject_meta[] = { + { "__tostring", _wrap_SBCommandReturnObject___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBCommandReturnObject_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBCommandReturnObject_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBCommandReturnObject_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBCommandReturnObject_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBCommandReturnObject_Sf_SwigStatic = { + "SBCommandReturnObject", + swig_SBCommandReturnObject_Sf_SwigStatic_methods, + swig_SBCommandReturnObject_Sf_SwigStatic_attributes, + swig_SBCommandReturnObject_Sf_SwigStatic_constants, + swig_SBCommandReturnObject_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBCommandReturnObject_bases[] = {0}; +static const char *swig_SBCommandReturnObject_base_names[] = {0}; +static swig_lua_class _wrap_class_SBCommandReturnObject = { "SBCommandReturnObject", "SBCommandReturnObject", &SWIGTYPE_p_lldb__SBCommandReturnObject,_proxy__wrap_new_SBCommandReturnObject, swig_delete_SBCommandReturnObject, swig_SBCommandReturnObject_methods, swig_SBCommandReturnObject_attributes, &swig_SBCommandReturnObject_Sf_SwigStatic, swig_SBCommandReturnObject_meta, swig_SBCommandReturnObject_bases, swig_SBCommandReturnObject_base_names }; + +static int _wrap_new_SBCommunication__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommunication *result = 0 ; + + SWIG_check_num_args("lldb::SBCommunication::SBCommunication",0,0) + result = (lldb::SBCommunication *)new lldb::SBCommunication(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBCommunication,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBCommunication__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + lldb::SBCommunication *result = 0 ; + + SWIG_check_num_args("lldb::SBCommunication::SBCommunication",1,1) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBCommunication::SBCommunication",1,"char const *"); + arg1 = (char *)lua_tostring(L, 1); + result = (lldb::SBCommunication *)new lldb::SBCommunication((char const *)arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBCommunication,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBCommunication(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBCommunication__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + _v = SWIG_lua_isnilstring(L,argv[0]); + } + if (_v) { + return _wrap_new_SBCommunication__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBCommunication'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBCommunication::SBCommunication()\n" + " lldb::SBCommunication::SBCommunication(char const *)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBCommunication_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommunication::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommunication::IsValid",1,"lldb::SBCommunication const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommunication,0))){ + SWIG_fail_ptr("SBCommunication_IsValid",1,SWIGTYPE_p_lldb__SBCommunication); + } + + result = (bool)((lldb::SBCommunication const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommunication_GetBroadcaster(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ; + lldb::SBBroadcaster result; + + SWIG_check_num_args("lldb::SBCommunication::GetBroadcaster",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommunication::GetBroadcaster",1,"lldb::SBCommunication *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommunication,0))){ + SWIG_fail_ptr("SBCommunication_GetBroadcaster",1,SWIGTYPE_p_lldb__SBCommunication); + } + + result = (arg1)->GetBroadcaster(); + { + lldb::SBBroadcaster * resultptr = new lldb::SBBroadcaster(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBroadcaster,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommunication_GetBroadcasterClass(lua_State* L) { + { + int SWIG_arg = 0; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBCommunication::GetBroadcasterClass",0,0) + result = (char *)lldb::SBCommunication::GetBroadcasterClass(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommunication_AdoptFileDesriptor(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ; + int arg2 ; + bool arg3 ; + lldb::ConnectionStatus result; + + SWIG_check_num_args("lldb::SBCommunication::AdoptFileDesriptor",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommunication::AdoptFileDesriptor",1,"lldb::SBCommunication *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBCommunication::AdoptFileDesriptor",2,"int"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBCommunication::AdoptFileDesriptor",3,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommunication,0))){ + SWIG_fail_ptr("SBCommunication_AdoptFileDesriptor",1,SWIGTYPE_p_lldb__SBCommunication); + } + + arg2 = (int)lua_tointeger(L, 2); + arg3 = (lua_toboolean(L, 3)!=0); + result = (lldb::ConnectionStatus)(arg1)->AdoptFileDesriptor(arg2,arg3); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommunication_Connect(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ; + char *arg2 = (char *) 0 ; + lldb::ConnectionStatus result; + + SWIG_check_num_args("lldb::SBCommunication::Connect",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommunication::Connect",1,"lldb::SBCommunication *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBCommunication::Connect",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommunication,0))){ + SWIG_fail_ptr("SBCommunication_Connect",1,SWIGTYPE_p_lldb__SBCommunication); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (lldb::ConnectionStatus)(arg1)->Connect((char const *)arg2); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommunication_Disconnect(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ; + lldb::ConnectionStatus result; + + SWIG_check_num_args("lldb::SBCommunication::Disconnect",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommunication::Disconnect",1,"lldb::SBCommunication *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommunication,0))){ + SWIG_fail_ptr("SBCommunication_Disconnect",1,SWIGTYPE_p_lldb__SBCommunication); + } + + result = (lldb::ConnectionStatus)(arg1)->Disconnect(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommunication_IsConnected(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommunication::IsConnected",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommunication::IsConnected",1,"lldb::SBCommunication const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommunication,0))){ + SWIG_fail_ptr("SBCommunication_IsConnected",1,SWIGTYPE_p_lldb__SBCommunication); + } + + result = (bool)((lldb::SBCommunication const *)arg1)->IsConnected(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommunication_GetCloseOnEOF(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommunication::GetCloseOnEOF",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommunication::GetCloseOnEOF",1,"lldb::SBCommunication *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommunication,0))){ + SWIG_fail_ptr("SBCommunication_GetCloseOnEOF",1,SWIGTYPE_p_lldb__SBCommunication); + } + + result = (bool)(arg1)->GetCloseOnEOF(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommunication_SetCloseOnEOF(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBCommunication::SetCloseOnEOF",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommunication::SetCloseOnEOF",1,"lldb::SBCommunication *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBCommunication::SetCloseOnEOF",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommunication,0))){ + SWIG_fail_ptr("SBCommunication_SetCloseOnEOF",1,SWIGTYPE_p_lldb__SBCommunication); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetCloseOnEOF(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommunication_Read(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ; + void *arg2 = (void *) 0 ; + size_t arg3 ; + uint32_t arg4 ; + lldb::ConnectionStatus *arg5 = 0 ; + size_t result; + + SWIG_check_num_args("lldb::SBCommunication::Read",5,5) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommunication::Read",1,"lldb::SBCommunication *"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("lldb::SBCommunication::Read",2,"void *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBCommunication::Read",3,"size_t"); + if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBCommunication::Read",4,"uint32_t"); + if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBCommunication::Read",5,"lldb::ConnectionStatus &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommunication,0))){ + SWIG_fail_ptr("SBCommunication_Read",1,SWIGTYPE_p_lldb__SBCommunication); + } + + arg2=(void *)SWIG_MustGetPtr(L,2,0,0,2,"SBCommunication_Read"); + arg3 = (size_t)lua_tointeger(L, 3); + arg4 = (uint32_t)lua_tointeger(L, 4); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_lldb__ConnectionStatus,0))){ + SWIG_fail_ptr("SBCommunication_Read",5,SWIGTYPE_p_lldb__ConnectionStatus); + } + + result = (arg1)->Read(arg2,arg3,arg4,*arg5); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommunication_Write(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ; + void *arg2 = (void *) 0 ; + size_t arg3 ; + lldb::ConnectionStatus *arg4 = 0 ; + size_t result; + + SWIG_check_num_args("lldb::SBCommunication::Write",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommunication::Write",1,"lldb::SBCommunication *"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("lldb::SBCommunication::Write",2,"void const *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBCommunication::Write",3,"size_t"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBCommunication::Write",4,"lldb::ConnectionStatus &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommunication,0))){ + SWIG_fail_ptr("SBCommunication_Write",1,SWIGTYPE_p_lldb__SBCommunication); + } + + arg2=(void *)SWIG_MustGetPtr(L,2,0,0,2,"SBCommunication_Write"); + arg3 = (size_t)lua_tointeger(L, 3); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__ConnectionStatus,0))){ + SWIG_fail_ptr("SBCommunication_Write",4,SWIGTYPE_p_lldb__ConnectionStatus); + } + + result = (arg1)->Write((void const *)arg2,arg3,*arg4); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommunication_ReadThreadStart(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommunication::ReadThreadStart",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommunication::ReadThreadStart",1,"lldb::SBCommunication *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommunication,0))){ + SWIG_fail_ptr("SBCommunication_ReadThreadStart",1,SWIGTYPE_p_lldb__SBCommunication); + } + + result = (bool)(arg1)->ReadThreadStart(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommunication_ReadThreadStop(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommunication::ReadThreadStop",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommunication::ReadThreadStop",1,"lldb::SBCommunication *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommunication,0))){ + SWIG_fail_ptr("SBCommunication_ReadThreadStop",1,SWIGTYPE_p_lldb__SBCommunication); + } + + result = (bool)(arg1)->ReadThreadStop(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommunication_ReadThreadIsRunning(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommunication::ReadThreadIsRunning",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommunication::ReadThreadIsRunning",1,"lldb::SBCommunication *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommunication,0))){ + SWIG_fail_ptr("SBCommunication_ReadThreadIsRunning",1,SWIGTYPE_p_lldb__SBCommunication); + } + + result = (bool)(arg1)->ReadThreadIsRunning(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCommunication_SetReadThreadBytesReceivedCallback(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCommunication *arg1 = (lldb::SBCommunication *) 0 ; + lldb::SBCommunication::ReadThreadBytesReceived arg2 = (lldb::SBCommunication::ReadThreadBytesReceived) 0 ; + void *arg3 = (void *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCommunication::SetReadThreadBytesReceivedCallback",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCommunication::SetReadThreadBytesReceivedCallback",1,"lldb::SBCommunication *"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("lldb::SBCommunication::SetReadThreadBytesReceivedCallback",2,"lldb::SBCommunication::ReadThreadBytesReceived"); + if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("lldb::SBCommunication::SetReadThreadBytesReceivedCallback",3,"void *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCommunication,0))){ + SWIG_fail_ptr("SBCommunication_SetReadThreadBytesReceivedCallback",1,SWIGTYPE_p_lldb__SBCommunication); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_f_p_void_p_q_const__void_size_t__void,0))){ + SWIG_fail_ptr("SBCommunication_SetReadThreadBytesReceivedCallback",2,SWIGTYPE_p_f_p_void_p_q_const__void_size_t__void); + } + + arg3=(void *)SWIG_MustGetPtr(L,3,0,0,3,"SBCommunication_SetReadThreadBytesReceivedCallback"); + result = (bool)(arg1)->SetReadThreadBytesReceivedCallback(arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBCommunication(void *obj) { +lldb::SBCommunication *arg1 = (lldb::SBCommunication *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBCommunication(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBCommunication); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBCommunication_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBCommunication_methods[]= { + { "IsValid", _wrap_SBCommunication_IsValid}, + { "GetBroadcaster", _wrap_SBCommunication_GetBroadcaster}, + { "AdoptFileDesriptor", _wrap_SBCommunication_AdoptFileDesriptor}, + { "Connect", _wrap_SBCommunication_Connect}, + { "Disconnect", _wrap_SBCommunication_Disconnect}, + { "IsConnected", _wrap_SBCommunication_IsConnected}, + { "GetCloseOnEOF", _wrap_SBCommunication_GetCloseOnEOF}, + { "SetCloseOnEOF", _wrap_SBCommunication_SetCloseOnEOF}, + { "Read", _wrap_SBCommunication_Read}, + { "Write", _wrap_SBCommunication_Write}, + { "ReadThreadStart", _wrap_SBCommunication_ReadThreadStart}, + { "ReadThreadStop", _wrap_SBCommunication_ReadThreadStop}, + { "ReadThreadIsRunning", _wrap_SBCommunication_ReadThreadIsRunning}, + { "SetReadThreadBytesReceivedCallback", _wrap_SBCommunication_SetReadThreadBytesReceivedCallback}, + {0,0} +}; +static swig_lua_method swig_SBCommunication_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBCommunication_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBCommunication_Sf_SwigStatic_constants[]= { + {SWIG_LUA_CONSTTAB_INT("eBroadcastBitDisconnected", (lldb::SBCommunication::eBroadcastBitDisconnected))}, + {SWIG_LUA_CONSTTAB_INT("eBroadcastBitReadThreadGotBytes", (lldb::SBCommunication::eBroadcastBitReadThreadGotBytes))}, + {SWIG_LUA_CONSTTAB_INT("eBroadcastBitReadThreadDidExit", (lldb::SBCommunication::eBroadcastBitReadThreadDidExit))}, + {SWIG_LUA_CONSTTAB_INT("eBroadcastBitReadThreadShouldExit", (lldb::SBCommunication::eBroadcastBitReadThreadShouldExit))}, + {SWIG_LUA_CONSTTAB_INT("eBroadcastBitPacketAvailable", (lldb::SBCommunication::eBroadcastBitPacketAvailable))}, + {SWIG_LUA_CONSTTAB_INT("eAllEventBits", (lldb::SBCommunication::eAllEventBits))}, + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBCommunication_Sf_SwigStatic_methods[]= { + { "GetBroadcasterClass", _wrap_SBCommunication_GetBroadcasterClass}, + {0,0} +}; +static swig_lua_class* swig_SBCommunication_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBCommunication_Sf_SwigStatic = { + "SBCommunication", + swig_SBCommunication_Sf_SwigStatic_methods, + swig_SBCommunication_Sf_SwigStatic_attributes, + swig_SBCommunication_Sf_SwigStatic_constants, + swig_SBCommunication_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBCommunication_bases[] = {0}; +static const char *swig_SBCommunication_base_names[] = {0}; +static swig_lua_class _wrap_class_SBCommunication = { "SBCommunication", "SBCommunication", &SWIGTYPE_p_lldb__SBCommunication,_proxy__wrap_new_SBCommunication, swig_delete_SBCommunication, swig_SBCommunication_methods, swig_SBCommunication_attributes, &swig_SBCommunication_Sf_SwigStatic, swig_SBCommunication_meta, swig_SBCommunication_bases, swig_SBCommunication_base_names }; + +static int _wrap_new_SBCompileUnit__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCompileUnit *result = 0 ; + + SWIG_check_num_args("lldb::SBCompileUnit::SBCompileUnit",0,0) + result = (lldb::SBCompileUnit *)new lldb::SBCompileUnit(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBCompileUnit,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBCompileUnit__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCompileUnit *arg1 = 0 ; + lldb::SBCompileUnit *result = 0 ; + + SWIG_check_num_args("lldb::SBCompileUnit::SBCompileUnit",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBCompileUnit::SBCompileUnit",1,"lldb::SBCompileUnit const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCompileUnit,0))){ + SWIG_fail_ptr("new_SBCompileUnit",1,SWIGTYPE_p_lldb__SBCompileUnit); + } + + result = (lldb::SBCompileUnit *)new lldb::SBCompileUnit((lldb::SBCompileUnit const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBCompileUnit,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBCompileUnit(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBCompileUnit__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCompileUnit, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBCompileUnit__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBCompileUnit'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBCompileUnit::SBCompileUnit()\n" + " lldb::SBCompileUnit::SBCompileUnit(lldb::SBCompileUnit const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBCompileUnit_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCompileUnit::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCompileUnit::IsValid",1,"lldb::SBCompileUnit const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCompileUnit,0))){ + SWIG_fail_ptr("SBCompileUnit_IsValid",1,SWIGTYPE_p_lldb__SBCompileUnit); + } + + result = (bool)((lldb::SBCompileUnit const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCompileUnit_GetFileSpec(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + lldb::SBFileSpec result; + + SWIG_check_num_args("lldb::SBCompileUnit::GetFileSpec",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCompileUnit::GetFileSpec",1,"lldb::SBCompileUnit const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCompileUnit,0))){ + SWIG_fail_ptr("SBCompileUnit_GetFileSpec",1,SWIGTYPE_p_lldb__SBCompileUnit); + } + + result = ((lldb::SBCompileUnit const *)arg1)->GetFileSpec(); + { + lldb::SBFileSpec * resultptr = new lldb::SBFileSpec(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCompileUnit_GetNumLineEntries(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBCompileUnit::GetNumLineEntries",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCompileUnit::GetNumLineEntries",1,"lldb::SBCompileUnit const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCompileUnit,0))){ + SWIG_fail_ptr("SBCompileUnit_GetNumLineEntries",1,SWIGTYPE_p_lldb__SBCompileUnit); + } + + result = (uint32_t)((lldb::SBCompileUnit const *)arg1)->GetNumLineEntries(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCompileUnit_GetLineEntryAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + uint32_t arg2 ; + lldb::SBLineEntry result; + + SWIG_check_num_args("lldb::SBCompileUnit::GetLineEntryAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCompileUnit::GetLineEntryAtIndex",1,"lldb::SBCompileUnit const *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBCompileUnit::GetLineEntryAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCompileUnit,0))){ + SWIG_fail_ptr("SBCompileUnit_GetLineEntryAtIndex",1,SWIGTYPE_p_lldb__SBCompileUnit); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = ((lldb::SBCompileUnit const *)arg1)->GetLineEntryAtIndex(arg2); + { + lldb::SBLineEntry * resultptr = new lldb::SBLineEntry(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBLineEntry,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCompileUnit_FindLineEntryIndex__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + lldb::SBLineEntry *arg2 = 0 ; + bool arg3 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBCompileUnit::FindLineEntryIndex",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCompileUnit::FindLineEntryIndex",1,"lldb::SBCompileUnit const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBCompileUnit::FindLineEntryIndex",2,"lldb::SBLineEntry &"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBCompileUnit::FindLineEntryIndex",3,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCompileUnit,0))){ + SWIG_fail_ptr("SBCompileUnit_FindLineEntryIndex",1,SWIGTYPE_p_lldb__SBCompileUnit); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBLineEntry,0))){ + SWIG_fail_ptr("SBCompileUnit_FindLineEntryIndex",2,SWIGTYPE_p_lldb__SBLineEntry); + } + + arg3 = (lua_toboolean(L, 3)!=0); + result = (uint32_t)((lldb::SBCompileUnit const *)arg1)->FindLineEntryIndex(*arg2,arg3); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCompileUnit_FindLineEntryIndex__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + lldb::SBLineEntry *arg2 = 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBCompileUnit::FindLineEntryIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCompileUnit::FindLineEntryIndex",1,"lldb::SBCompileUnit const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBCompileUnit::FindLineEntryIndex",2,"lldb::SBLineEntry &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCompileUnit,0))){ + SWIG_fail_ptr("SBCompileUnit_FindLineEntryIndex",1,SWIGTYPE_p_lldb__SBCompileUnit); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBLineEntry,0))){ + SWIG_fail_ptr("SBCompileUnit_FindLineEntryIndex",2,SWIGTYPE_p_lldb__SBLineEntry); + } + + result = (uint32_t)((lldb::SBCompileUnit const *)arg1)->FindLineEntryIndex(*arg2); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCompileUnit_FindLineEntryIndex__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + uint32_t arg2 ; + uint32_t arg3 ; + lldb::SBFileSpec *arg4 = (lldb::SBFileSpec *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBCompileUnit::FindLineEntryIndex",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCompileUnit::FindLineEntryIndex",1,"lldb::SBCompileUnit const *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBCompileUnit::FindLineEntryIndex",2,"uint32_t"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBCompileUnit::FindLineEntryIndex",3,"uint32_t"); + if(!SWIG_isptrtype(L,4)) SWIG_fail_arg("lldb::SBCompileUnit::FindLineEntryIndex",4,"lldb::SBFileSpec *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCompileUnit,0))){ + SWIG_fail_ptr("SBCompileUnit_FindLineEntryIndex",1,SWIGTYPE_p_lldb__SBCompileUnit); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + arg3 = (uint32_t)lua_tointeger(L, 3); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBCompileUnit_FindLineEntryIndex",4,SWIGTYPE_p_lldb__SBFileSpec); + } + + result = (uint32_t)((lldb::SBCompileUnit const *)arg1)->FindLineEntryIndex(arg2,arg3,arg4); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCompileUnit_FindLineEntryIndex__SWIG_3(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + uint32_t arg2 ; + uint32_t arg3 ; + lldb::SBFileSpec *arg4 = (lldb::SBFileSpec *) 0 ; + bool arg5 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBCompileUnit::FindLineEntryIndex",5,5) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCompileUnit::FindLineEntryIndex",1,"lldb::SBCompileUnit const *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBCompileUnit::FindLineEntryIndex",2,"uint32_t"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBCompileUnit::FindLineEntryIndex",3,"uint32_t"); + if(!SWIG_isptrtype(L,4)) SWIG_fail_arg("lldb::SBCompileUnit::FindLineEntryIndex",4,"lldb::SBFileSpec *"); + if(!lua_isboolean(L,5)) SWIG_fail_arg("lldb::SBCompileUnit::FindLineEntryIndex",5,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCompileUnit,0))){ + SWIG_fail_ptr("SBCompileUnit_FindLineEntryIndex",1,SWIGTYPE_p_lldb__SBCompileUnit); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + arg3 = (uint32_t)lua_tointeger(L, 3); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBCompileUnit_FindLineEntryIndex",4,SWIGTYPE_p_lldb__SBFileSpec); + } + + arg5 = (lua_toboolean(L, 5)!=0); + result = (uint32_t)((lldb::SBCompileUnit const *)arg1)->FindLineEntryIndex(arg2,arg3,arg4,arg5); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCompileUnit_FindLineEntryIndex(lua_State* L) { + int argc; + int argv[6]={ + 1,2,3,4,5,6 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCompileUnit, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBLineEntry, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBCompileUnit_FindLineEntryIndex__SWIG_1(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCompileUnit, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBLineEntry, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[2]); + } + if (_v) { + return _wrap_SBCompileUnit_FindLineEntryIndex__SWIG_0(L); + } + } + } + } + if (argc == 4) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCompileUnit, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + { + void *ptr; + if (SWIG_isptrtype(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBCompileUnit_FindLineEntryIndex__SWIG_2(L); + } + } + } + } + } + if (argc == 5) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCompileUnit, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + { + void *ptr; + if (SWIG_isptrtype(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[4]); + } + if (_v) { + return _wrap_SBCompileUnit_FindLineEntryIndex__SWIG_3(L); + } + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBCompileUnit_GetSupportFileAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + uint32_t arg2 ; + lldb::SBFileSpec result; + + SWIG_check_num_args("lldb::SBCompileUnit::GetSupportFileAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCompileUnit::GetSupportFileAtIndex",1,"lldb::SBCompileUnit const *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBCompileUnit::GetSupportFileAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCompileUnit,0))){ + SWIG_fail_ptr("SBCompileUnit_GetSupportFileAtIndex",1,SWIGTYPE_p_lldb__SBCompileUnit); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = ((lldb::SBCompileUnit const *)arg1)->GetSupportFileAtIndex(arg2); + { + lldb::SBFileSpec * resultptr = new lldb::SBFileSpec(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCompileUnit_GetNumSupportFiles(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBCompileUnit::GetNumSupportFiles",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCompileUnit::GetNumSupportFiles",1,"lldb::SBCompileUnit const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCompileUnit,0))){ + SWIG_fail_ptr("SBCompileUnit_GetNumSupportFiles",1,SWIGTYPE_p_lldb__SBCompileUnit); + } + + result = (uint32_t)((lldb::SBCompileUnit const *)arg1)->GetNumSupportFiles(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCompileUnit_FindSupportFileIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + uint32_t arg2 ; + lldb::SBFileSpec *arg3 = 0 ; + bool arg4 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBCompileUnit::FindSupportFileIndex",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCompileUnit::FindSupportFileIndex",1,"lldb::SBCompileUnit *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBCompileUnit::FindSupportFileIndex",2,"uint32_t"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBCompileUnit::FindSupportFileIndex",3,"lldb::SBFileSpec const &"); + if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBCompileUnit::FindSupportFileIndex",4,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCompileUnit,0))){ + SWIG_fail_ptr("SBCompileUnit_FindSupportFileIndex",1,SWIGTYPE_p_lldb__SBCompileUnit); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBCompileUnit_FindSupportFileIndex",3,SWIGTYPE_p_lldb__SBFileSpec); + } + + arg4 = (lua_toboolean(L, 4)!=0); + result = (uint32_t)(arg1)->FindSupportFileIndex(arg2,(lldb::SBFileSpec const &)*arg3,arg4); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCompileUnit_GetTypes__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + uint32_t arg2 ; + lldb::SBTypeList result; + + SWIG_check_num_args("lldb::SBCompileUnit::GetTypes",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCompileUnit::GetTypes",1,"lldb::SBCompileUnit *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBCompileUnit::GetTypes",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCompileUnit,0))){ + SWIG_fail_ptr("SBCompileUnit_GetTypes",1,SWIGTYPE_p_lldb__SBCompileUnit); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetTypes(arg2); + { + lldb::SBTypeList * resultptr = new lldb::SBTypeList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCompileUnit_GetTypes__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + lldb::SBTypeList result; + + SWIG_check_num_args("lldb::SBCompileUnit::GetTypes",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCompileUnit::GetTypes",1,"lldb::SBCompileUnit *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCompileUnit,0))){ + SWIG_fail_ptr("SBCompileUnit_GetTypes",1,SWIGTYPE_p_lldb__SBCompileUnit); + } + + result = (arg1)->GetTypes(); + { + lldb::SBTypeList * resultptr = new lldb::SBTypeList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCompileUnit_GetTypes(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCompileUnit, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBCompileUnit_GetTypes__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBCompileUnit, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_SBCompileUnit_GetTypes__SWIG_0(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBCompileUnit_GetTypes'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBCompileUnit::GetTypes(uint32_t)\n" + " lldb::SBCompileUnit::GetTypes()\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBCompileUnit_GetLanguage(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + lldb::LanguageType result; + + SWIG_check_num_args("lldb::SBCompileUnit::GetLanguage",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCompileUnit::GetLanguage",1,"lldb::SBCompileUnit *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCompileUnit,0))){ + SWIG_fail_ptr("SBCompileUnit_GetLanguage",1,SWIGTYPE_p_lldb__SBCompileUnit); + } + + result = (lldb::LanguageType)(arg1)->GetLanguage(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCompileUnit___eq(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + lldb::SBCompileUnit *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCompileUnit::operator ==",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCompileUnit::operator ==",1,"lldb::SBCompileUnit const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBCompileUnit::operator ==",2,"lldb::SBCompileUnit const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCompileUnit,0))){ + SWIG_fail_ptr("SBCompileUnit___eq",1,SWIGTYPE_p_lldb__SBCompileUnit); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBCompileUnit,0))){ + SWIG_fail_ptr("SBCompileUnit___eq",2,SWIGTYPE_p_lldb__SBCompileUnit); + } + + result = (bool)((lldb::SBCompileUnit const *)arg1)->operator ==((lldb::SBCompileUnit const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCompileUnit_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBCompileUnit::GetDescription",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCompileUnit::GetDescription",1,"lldb::SBCompileUnit *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBCompileUnit::GetDescription",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCompileUnit,0))){ + SWIG_fail_ptr("SBCompileUnit_GetDescription",1,SWIGTYPE_p_lldb__SBCompileUnit); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBCompileUnit_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)(arg1)->GetDescription(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBCompileUnit___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBCompileUnit::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBCompileUnit::__repr__",1,"lldb::SBCompileUnit *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBCompileUnit,0))){ + SWIG_fail_ptr("SBCompileUnit___tostring",1,SWIGTYPE_p_lldb__SBCompileUnit); + } + + result = lldb_SBCompileUnit___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBCompileUnit(void *obj) { +lldb::SBCompileUnit *arg1 = (lldb::SBCompileUnit *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBCompileUnit(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBCompileUnit); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBCompileUnit_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBCompileUnit_methods[]= { + { "IsValid", _wrap_SBCompileUnit_IsValid}, + { "GetFileSpec", _wrap_SBCompileUnit_GetFileSpec}, + { "GetNumLineEntries", _wrap_SBCompileUnit_GetNumLineEntries}, + { "GetLineEntryAtIndex", _wrap_SBCompileUnit_GetLineEntryAtIndex}, + { "FindLineEntryIndex", _wrap_SBCompileUnit_FindLineEntryIndex}, + { "GetSupportFileAtIndex", _wrap_SBCompileUnit_GetSupportFileAtIndex}, + { "GetNumSupportFiles", _wrap_SBCompileUnit_GetNumSupportFiles}, + { "FindSupportFileIndex", _wrap_SBCompileUnit_FindSupportFileIndex}, + { "GetTypes", _wrap_SBCompileUnit_GetTypes}, + { "GetLanguage", _wrap_SBCompileUnit_GetLanguage}, + { "__eq", _wrap_SBCompileUnit___eq}, + { "GetDescription", _wrap_SBCompileUnit_GetDescription}, + { "__tostring", _wrap_SBCompileUnit___tostring}, + {0,0} +}; +static swig_lua_method swig_SBCompileUnit_meta[] = { + { "__eq", _wrap_SBCompileUnit___eq}, + { "__tostring", _wrap_SBCompileUnit___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBCompileUnit_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBCompileUnit_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBCompileUnit_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBCompileUnit_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBCompileUnit_Sf_SwigStatic = { + "SBCompileUnit", + swig_SBCompileUnit_Sf_SwigStatic_methods, + swig_SBCompileUnit_Sf_SwigStatic_attributes, + swig_SBCompileUnit_Sf_SwigStatic_constants, + swig_SBCompileUnit_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBCompileUnit_bases[] = {0}; +static const char *swig_SBCompileUnit_base_names[] = {0}; +static swig_lua_class _wrap_class_SBCompileUnit = { "SBCompileUnit", "SBCompileUnit", &SWIGTYPE_p_lldb__SBCompileUnit,_proxy__wrap_new_SBCompileUnit, swig_delete_SBCompileUnit, swig_SBCompileUnit_methods, swig_SBCompileUnit_attributes, &swig_SBCompileUnit_Sf_SwigStatic, swig_SBCompileUnit_meta, swig_SBCompileUnit_bases, swig_SBCompileUnit_base_names }; + +static int _wrap_new_SBSaveCoreOptions__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSaveCoreOptions *result = 0 ; + + SWIG_check_num_args("lldb::SBSaveCoreOptions::SBSaveCoreOptions",0,0) + result = (lldb::SBSaveCoreOptions *)new lldb::SBSaveCoreOptions(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBSaveCoreOptions,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBSaveCoreOptions__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSaveCoreOptions *arg1 = 0 ; + lldb::SBSaveCoreOptions *result = 0 ; + + SWIG_check_num_args("lldb::SBSaveCoreOptions::SBSaveCoreOptions",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBSaveCoreOptions::SBSaveCoreOptions",1,"lldb::SBSaveCoreOptions const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSaveCoreOptions,0))){ + SWIG_fail_ptr("new_SBSaveCoreOptions",1,SWIGTYPE_p_lldb__SBSaveCoreOptions); + } + + result = (lldb::SBSaveCoreOptions *)new lldb::SBSaveCoreOptions((lldb::SBSaveCoreOptions const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBSaveCoreOptions,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBSaveCoreOptions(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBSaveCoreOptions__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBSaveCoreOptions, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBSaveCoreOptions__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBSaveCoreOptions'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBSaveCoreOptions::SBSaveCoreOptions()\n" + " lldb::SBSaveCoreOptions::SBSaveCoreOptions(lldb::SBSaveCoreOptions const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBSaveCoreOptions_SetPluginName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSaveCoreOptions *arg1 = (lldb::SBSaveCoreOptions *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBSaveCoreOptions::SetPluginName",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSaveCoreOptions::SetPluginName",1,"lldb::SBSaveCoreOptions *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBSaveCoreOptions::SetPluginName",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSaveCoreOptions,0))){ + SWIG_fail_ptr("SBSaveCoreOptions_SetPluginName",1,SWIGTYPE_p_lldb__SBSaveCoreOptions); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->SetPluginName((char const *)arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSaveCoreOptions_GetPluginName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSaveCoreOptions *arg1 = (lldb::SBSaveCoreOptions *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBSaveCoreOptions::GetPluginName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSaveCoreOptions::GetPluginName",1,"lldb::SBSaveCoreOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSaveCoreOptions,0))){ + SWIG_fail_ptr("SBSaveCoreOptions_GetPluginName",1,SWIGTYPE_p_lldb__SBSaveCoreOptions); + } + + result = (char *)((lldb::SBSaveCoreOptions const *)arg1)->GetPluginName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSaveCoreOptions_SetStyle(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSaveCoreOptions *arg1 = (lldb::SBSaveCoreOptions *) 0 ; + lldb::SaveCoreStyle arg2 ; + + SWIG_check_num_args("lldb::SBSaveCoreOptions::SetStyle",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSaveCoreOptions::SetStyle",1,"lldb::SBSaveCoreOptions *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBSaveCoreOptions::SetStyle",2,"lldb::SaveCoreStyle"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSaveCoreOptions,0))){ + SWIG_fail_ptr("SBSaveCoreOptions_SetStyle",1,SWIGTYPE_p_lldb__SBSaveCoreOptions); + } + + arg2 = (lldb::SaveCoreStyle)lua_tointeger(L, 2); + (arg1)->SetStyle(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSaveCoreOptions_GetStyle(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSaveCoreOptions *arg1 = (lldb::SBSaveCoreOptions *) 0 ; + lldb::SaveCoreStyle result; + + SWIG_check_num_args("lldb::SBSaveCoreOptions::GetStyle",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSaveCoreOptions::GetStyle",1,"lldb::SBSaveCoreOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSaveCoreOptions,0))){ + SWIG_fail_ptr("SBSaveCoreOptions_GetStyle",1,SWIGTYPE_p_lldb__SBSaveCoreOptions); + } + + result = (lldb::SaveCoreStyle)((lldb::SBSaveCoreOptions const *)arg1)->GetStyle(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSaveCoreOptions_SetOutputFile(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSaveCoreOptions *arg1 = (lldb::SBSaveCoreOptions *) 0 ; + lldb::SBFileSpec arg2 ; + lldb::SBFileSpec *argp2 ; + + SWIG_check_num_args("lldb::SBSaveCoreOptions::SetOutputFile",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSaveCoreOptions::SetOutputFile",1,"lldb::SBSaveCoreOptions *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSaveCoreOptions::SetOutputFile",2,"lldb::SBFileSpec"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSaveCoreOptions,0))){ + SWIG_fail_ptr("SBSaveCoreOptions_SetOutputFile",1,SWIGTYPE_p_lldb__SBSaveCoreOptions); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBSaveCoreOptions_SetOutputFile",2,SWIGTYPE_p_lldb__SBFileSpec); + } + arg2 = *argp2; + + (arg1)->SetOutputFile(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSaveCoreOptions_GetOutputFile(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSaveCoreOptions *arg1 = (lldb::SBSaveCoreOptions *) 0 ; + lldb::SBFileSpec result; + + SWIG_check_num_args("lldb::SBSaveCoreOptions::GetOutputFile",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSaveCoreOptions::GetOutputFile",1,"lldb::SBSaveCoreOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSaveCoreOptions,0))){ + SWIG_fail_ptr("SBSaveCoreOptions_GetOutputFile",1,SWIGTYPE_p_lldb__SBSaveCoreOptions); + } + + result = ((lldb::SBSaveCoreOptions const *)arg1)->GetOutputFile(); + { + lldb::SBFileSpec * resultptr = new lldb::SBFileSpec(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSaveCoreOptions_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSaveCoreOptions *arg1 = (lldb::SBSaveCoreOptions *) 0 ; + + SWIG_check_num_args("lldb::SBSaveCoreOptions::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSaveCoreOptions::Clear",1,"lldb::SBSaveCoreOptions *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSaveCoreOptions,0))){ + SWIG_fail_ptr("SBSaveCoreOptions_Clear",1,SWIGTYPE_p_lldb__SBSaveCoreOptions); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBSaveCoreOptions(void *obj) { +lldb::SBSaveCoreOptions *arg1 = (lldb::SBSaveCoreOptions *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBSaveCoreOptions(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBSaveCoreOptions); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBSaveCoreOptions_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBSaveCoreOptions_methods[]= { + { "SetPluginName", _wrap_SBSaveCoreOptions_SetPluginName}, + { "GetPluginName", _wrap_SBSaveCoreOptions_GetPluginName}, + { "SetStyle", _wrap_SBSaveCoreOptions_SetStyle}, + { "GetStyle", _wrap_SBSaveCoreOptions_GetStyle}, + { "SetOutputFile", _wrap_SBSaveCoreOptions_SetOutputFile}, + { "GetOutputFile", _wrap_SBSaveCoreOptions_GetOutputFile}, + { "Clear", _wrap_SBSaveCoreOptions_Clear}, + {0,0} +}; +static swig_lua_method swig_SBSaveCoreOptions_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBSaveCoreOptions_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBSaveCoreOptions_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBSaveCoreOptions_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBSaveCoreOptions_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBSaveCoreOptions_Sf_SwigStatic = { + "SBSaveCoreOptions", + swig_SBSaveCoreOptions_Sf_SwigStatic_methods, + swig_SBSaveCoreOptions_Sf_SwigStatic_attributes, + swig_SBSaveCoreOptions_Sf_SwigStatic_constants, + swig_SBSaveCoreOptions_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBSaveCoreOptions_bases[] = {0}; +static const char *swig_SBSaveCoreOptions_base_names[] = {0}; +static swig_lua_class _wrap_class_SBSaveCoreOptions = { "SBSaveCoreOptions", "SBSaveCoreOptions", &SWIGTYPE_p_lldb__SBSaveCoreOptions,_proxy__wrap_new_SBSaveCoreOptions, swig_delete_SBSaveCoreOptions, swig_SBSaveCoreOptions_methods, swig_SBSaveCoreOptions_attributes, &swig_SBSaveCoreOptions_Sf_SwigStatic, swig_SBSaveCoreOptions_meta, swig_SBSaveCoreOptions_bases, swig_SBSaveCoreOptions_base_names }; + +static int _wrap_new_SBData__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBData *result = 0 ; + + SWIG_check_num_args("lldb::SBData::SBData",0,0) + result = (lldb::SBData *)new lldb::SBData(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBData,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBData__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBData *arg1 = 0 ; + lldb::SBData *result = 0 ; + + SWIG_check_num_args("lldb::SBData::SBData",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBData::SBData",1,"lldb::SBData const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("new_SBData",1,SWIGTYPE_p_lldb__SBData); + } + + result = (lldb::SBData *)new lldb::SBData((lldb::SBData const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBData,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBData(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBData__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBData, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBData__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBData'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBData::SBData()\n" + " lldb::SBData::SBData(lldb::SBData const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBData_GetAddressByteSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBData *arg1 = (lldb::SBData *) 0 ; + uint8_t result; + + SWIG_check_num_args("lldb::SBData::GetAddressByteSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::GetAddressByteSize",1,"lldb::SBData *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBData_GetAddressByteSize",1,SWIGTYPE_p_lldb__SBData); + } + + result = (uint8_t)(arg1)->GetAddressByteSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_SetAddressByteSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBData *arg1 = (lldb::SBData *) 0 ; + uint8_t arg2 ; + + SWIG_check_num_args("lldb::SBData::SetAddressByteSize",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::SetAddressByteSize",1,"lldb::SBData *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBData::SetAddressByteSize",2,"uint8_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBData_SetAddressByteSize",1,SWIGTYPE_p_lldb__SBData); + } + + arg2 = (uint8_t)lua_tointeger(L, 2); + (arg1)->SetAddressByteSize(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBData *arg1 = (lldb::SBData *) 0 ; + + SWIG_check_num_args("lldb::SBData::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::Clear",1,"lldb::SBData *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBData_Clear",1,SWIGTYPE_p_lldb__SBData); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBData *arg1 = (lldb::SBData *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBData::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::IsValid",1,"lldb::SBData *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBData_IsValid",1,SWIGTYPE_p_lldb__SBData); + } + + result = (bool)(arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_GetByteSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBData *arg1 = (lldb::SBData *) 0 ; + size_t result; + + SWIG_check_num_args("lldb::SBData::GetByteSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::GetByteSize",1,"lldb::SBData *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBData_GetByteSize",1,SWIGTYPE_p_lldb__SBData); + } + + result = (arg1)->GetByteSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_GetByteOrder(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::ByteOrder result; + + SWIG_check_num_args("lldb::SBData::GetByteOrder",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::GetByteOrder",1,"lldb::SBData *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBData_GetByteOrder",1,SWIGTYPE_p_lldb__SBData); + } + + result = (lldb::ByteOrder)(arg1)->GetByteOrder(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_SetByteOrder(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::ByteOrder arg2 ; + + SWIG_check_num_args("lldb::SBData::SetByteOrder",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::SetByteOrder",1,"lldb::SBData *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBData::SetByteOrder",2,"lldb::ByteOrder"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBData_SetByteOrder",1,SWIGTYPE_p_lldb__SBData); + } + + arg2 = (lldb::ByteOrder)lua_tointeger(L, 2); + (arg1)->SetByteOrder(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_GetFloat(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBError *arg2 = 0 ; + lldb::offset_t arg3 ; + float result; + + SWIG_check_num_args("lldb::SBData::GetFloat",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::GetFloat",1,"lldb::SBData *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::GetFloat",2,"lldb::SBError &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBData::GetFloat",3,"lldb::offset_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBData_GetFloat",1,SWIGTYPE_p_lldb__SBData); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBData_GetFloat",2,SWIGTYPE_p_lldb__SBError); + } + + arg3 = (lldb::offset_t)lua_tointeger(L, 3); + result = (float)(arg1)->GetFloat(*arg2,arg3); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_GetDouble(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBError *arg2 = 0 ; + lldb::offset_t arg3 ; + double result; + + SWIG_check_num_args("lldb::SBData::GetDouble",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::GetDouble",1,"lldb::SBData *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::GetDouble",2,"lldb::SBError &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBData::GetDouble",3,"lldb::offset_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBData_GetDouble",1,SWIGTYPE_p_lldb__SBData); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBData_GetDouble",2,SWIGTYPE_p_lldb__SBError); + } + + arg3 = (lldb::offset_t)lua_tointeger(L, 3); + result = (double)(arg1)->GetDouble(*arg2,arg3); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_GetLongDouble(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBError *arg2 = 0 ; + lldb::offset_t arg3 ; + long double result; + + SWIG_check_num_args("lldb::SBData::GetLongDouble",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::GetLongDouble",1,"lldb::SBData *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::GetLongDouble",2,"lldb::SBError &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBData::GetLongDouble",3,"lldb::offset_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBData_GetLongDouble",1,SWIGTYPE_p_lldb__SBData); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBData_GetLongDouble",2,SWIGTYPE_p_lldb__SBError); + } + + arg3 = (lldb::offset_t)lua_tointeger(L, 3); + result = (long double)(arg1)->GetLongDouble(*arg2,arg3); + { + long double * resultptr = new long double(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_long_double,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_GetAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBError *arg2 = 0 ; + lldb::offset_t arg3 ; + lldb::addr_t result; + + SWIG_check_num_args("lldb::SBData::GetAddress",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::GetAddress",1,"lldb::SBData *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::GetAddress",2,"lldb::SBError &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBData::GetAddress",3,"lldb::offset_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBData_GetAddress",1,SWIGTYPE_p_lldb__SBData); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBData_GetAddress",2,SWIGTYPE_p_lldb__SBError); + } + + arg3 = (lldb::offset_t)lua_tointeger(L, 3); + result = (lldb::addr_t)(arg1)->GetAddress(*arg2,arg3); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_GetUnsignedInt8(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBError *arg2 = 0 ; + lldb::offset_t arg3 ; + uint8_t result; + + SWIG_check_num_args("lldb::SBData::GetUnsignedInt8",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::GetUnsignedInt8",1,"lldb::SBData *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::GetUnsignedInt8",2,"lldb::SBError &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBData::GetUnsignedInt8",3,"lldb::offset_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBData_GetUnsignedInt8",1,SWIGTYPE_p_lldb__SBData); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBData_GetUnsignedInt8",2,SWIGTYPE_p_lldb__SBError); + } + + arg3 = (lldb::offset_t)lua_tointeger(L, 3); + result = (uint8_t)(arg1)->GetUnsignedInt8(*arg2,arg3); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_GetUnsignedInt16(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBError *arg2 = 0 ; + lldb::offset_t arg3 ; + uint16_t result; + + SWIG_check_num_args("lldb::SBData::GetUnsignedInt16",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::GetUnsignedInt16",1,"lldb::SBData *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::GetUnsignedInt16",2,"lldb::SBError &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBData::GetUnsignedInt16",3,"lldb::offset_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBData_GetUnsignedInt16",1,SWIGTYPE_p_lldb__SBData); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBData_GetUnsignedInt16",2,SWIGTYPE_p_lldb__SBError); + } + + arg3 = (lldb::offset_t)lua_tointeger(L, 3); + result = (uint16_t)(arg1)->GetUnsignedInt16(*arg2,arg3); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_GetUnsignedInt32(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBError *arg2 = 0 ; + lldb::offset_t arg3 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBData::GetUnsignedInt32",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::GetUnsignedInt32",1,"lldb::SBData *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::GetUnsignedInt32",2,"lldb::SBError &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBData::GetUnsignedInt32",3,"lldb::offset_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBData_GetUnsignedInt32",1,SWIGTYPE_p_lldb__SBData); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBData_GetUnsignedInt32",2,SWIGTYPE_p_lldb__SBError); + } + + arg3 = (lldb::offset_t)lua_tointeger(L, 3); + result = (uint32_t)(arg1)->GetUnsignedInt32(*arg2,arg3); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_GetUnsignedInt64(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBError *arg2 = 0 ; + lldb::offset_t arg3 ; + uint64_t result; + + SWIG_check_num_args("lldb::SBData::GetUnsignedInt64",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::GetUnsignedInt64",1,"lldb::SBData *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::GetUnsignedInt64",2,"lldb::SBError &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBData::GetUnsignedInt64",3,"lldb::offset_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBData_GetUnsignedInt64",1,SWIGTYPE_p_lldb__SBData); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBData_GetUnsignedInt64",2,SWIGTYPE_p_lldb__SBError); + } + + arg3 = (lldb::offset_t)lua_tointeger(L, 3); + result = (uint64_t)(arg1)->GetUnsignedInt64(*arg2,arg3); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_GetSignedInt8(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBError *arg2 = 0 ; + lldb::offset_t arg3 ; + int8_t result; + + SWIG_check_num_args("lldb::SBData::GetSignedInt8",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::GetSignedInt8",1,"lldb::SBData *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::GetSignedInt8",2,"lldb::SBError &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBData::GetSignedInt8",3,"lldb::offset_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBData_GetSignedInt8",1,SWIGTYPE_p_lldb__SBData); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBData_GetSignedInt8",2,SWIGTYPE_p_lldb__SBError); + } + + arg3 = (lldb::offset_t)lua_tointeger(L, 3); + result = (int8_t)(arg1)->GetSignedInt8(*arg2,arg3); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_GetSignedInt16(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBError *arg2 = 0 ; + lldb::offset_t arg3 ; + int16_t result; + + SWIG_check_num_args("lldb::SBData::GetSignedInt16",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::GetSignedInt16",1,"lldb::SBData *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::GetSignedInt16",2,"lldb::SBError &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBData::GetSignedInt16",3,"lldb::offset_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBData_GetSignedInt16",1,SWIGTYPE_p_lldb__SBData); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBData_GetSignedInt16",2,SWIGTYPE_p_lldb__SBError); + } + + arg3 = (lldb::offset_t)lua_tointeger(L, 3); + result = (int16_t)(arg1)->GetSignedInt16(*arg2,arg3); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_GetSignedInt32(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBError *arg2 = 0 ; + lldb::offset_t arg3 ; + int32_t result; + + SWIG_check_num_args("lldb::SBData::GetSignedInt32",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::GetSignedInt32",1,"lldb::SBData *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::GetSignedInt32",2,"lldb::SBError &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBData::GetSignedInt32",3,"lldb::offset_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBData_GetSignedInt32",1,SWIGTYPE_p_lldb__SBData); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBData_GetSignedInt32",2,SWIGTYPE_p_lldb__SBError); + } + + arg3 = (lldb::offset_t)lua_tointeger(L, 3); + result = (int32_t)(arg1)->GetSignedInt32(*arg2,arg3); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_GetSignedInt64(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBError *arg2 = 0 ; + lldb::offset_t arg3 ; + int64_t result; + + SWIG_check_num_args("lldb::SBData::GetSignedInt64",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::GetSignedInt64",1,"lldb::SBData *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::GetSignedInt64",2,"lldb::SBError &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBData::GetSignedInt64",3,"lldb::offset_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBData_GetSignedInt64",1,SWIGTYPE_p_lldb__SBData); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBData_GetSignedInt64",2,SWIGTYPE_p_lldb__SBError); + } + + arg3 = (lldb::offset_t)lua_tointeger(L, 3); + result = (int64_t)(arg1)->GetSignedInt64(*arg2,arg3); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_GetString(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBError *arg2 = 0 ; + lldb::offset_t arg3 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBData::GetString",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::GetString",1,"lldb::SBData *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::GetString",2,"lldb::SBError &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBData::GetString",3,"lldb::offset_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBData_GetString",1,SWIGTYPE_p_lldb__SBData); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBData_GetString",2,SWIGTYPE_p_lldb__SBError); + } + + arg3 = (lldb::offset_t)lua_tointeger(L, 3); + result = (char *)(arg1)->GetString(*arg2,arg3); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_ReadRawData(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBError *arg2 = 0 ; + lldb::offset_t arg3 ; + void *arg4 = (void *) 0 ; + size_t arg5 ; + size_t result; + + SWIG_check_num_args("lldb::SBData::ReadRawData",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::ReadRawData",1,"lldb::SBData *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::ReadRawData",2,"lldb::SBError &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBData::ReadRawData",3,"lldb::offset_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBData_ReadRawData",1,SWIGTYPE_p_lldb__SBData); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBData_ReadRawData",2,SWIGTYPE_p_lldb__SBError); + } + + arg3 = (lldb::offset_t)lua_tointeger(L, 3); + { + arg5 = luaL_checkinteger(L, 4); + if (arg5 <= 0) { + return luaL_error(L, "Positive integer expected"); + } + arg4 = (char *)malloc(arg5); + } + result = (arg1)->ReadRawData(*arg2,arg3,arg4,arg5); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + { + lua_pop(L, 1); // Blow away the previous result + if (result == 0) { + lua_pushliteral(L, ""); + } else { + lua_pushlstring(L, (const char *)arg4, result); + } + free(arg4); + // SWIG_arg was already incremented + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_GetDescription__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBStream *arg2 = 0 ; + lldb::addr_t arg3 ; + bool result; + + SWIG_check_num_args("lldb::SBData::GetDescription",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::GetDescription",1,"lldb::SBData *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::GetDescription",2,"lldb::SBStream &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBData::GetDescription",3,"lldb::addr_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBData_GetDescription",1,SWIGTYPE_p_lldb__SBData); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBData_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + arg3 = (lldb::addr_t)lua_tointeger(L, 3); + result = (bool)(arg1)->GetDescription(*arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_GetDescription__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBData::GetDescription",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::GetDescription",1,"lldb::SBData *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::GetDescription",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBData_GetDescription",1,SWIGTYPE_p_lldb__SBData); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBData_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)(arg1)->GetDescription(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_GetDescription(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBData, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBData_GetDescription__SWIG_1(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBData, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + return _wrap_SBData_GetDescription__SWIG_0(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBData_SetData(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBError *arg2 = 0 ; + void *arg3 = (void *) 0 ; + size_t arg4 ; + lldb::ByteOrder arg5 ; + uint8_t arg6 ; + + SWIG_check_num_args("lldb::SBData::SetData",5,5) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::SetData",1,"lldb::SBData *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::SetData",2,"lldb::SBError &"); + if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBData::SetData",4,"lldb::ByteOrder"); + if(!lua_isinteger(L,5)) SWIG_fail_arg("lldb::SBData::SetData",5,"uint8_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBData_SetData",1,SWIGTYPE_p_lldb__SBData); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBData_SetData",2,SWIGTYPE_p_lldb__SBError); + } + + { + arg3 = (void *)luaL_checklstring(L, 3, &arg4); + } + arg5 = (lldb::ByteOrder)lua_tointeger(L, 4); + arg6 = (uint8_t)lua_tointeger(L, 5); + (arg1)->SetData(*arg2,(void const *)arg3,arg4,arg5,arg6); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_SetDataWithOwnership(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBError *arg2 = 0 ; + void *arg3 = (void *) 0 ; + size_t arg4 ; + lldb::ByteOrder arg5 ; + uint8_t arg6 ; + + SWIG_check_num_args("lldb::SBData::SetDataWithOwnership",5,5) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::SetDataWithOwnership",1,"lldb::SBData *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::SetDataWithOwnership",2,"lldb::SBError &"); + if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBData::SetDataWithOwnership",4,"lldb::ByteOrder"); + if(!lua_isinteger(L,5)) SWIG_fail_arg("lldb::SBData::SetDataWithOwnership",5,"uint8_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBData_SetDataWithOwnership",1,SWIGTYPE_p_lldb__SBData); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBData_SetDataWithOwnership",2,SWIGTYPE_p_lldb__SBError); + } + + { + arg3 = (void *)luaL_checklstring(L, 3, &arg4); + } + arg5 = (lldb::ByteOrder)lua_tointeger(L, 4); + arg6 = (uint8_t)lua_tointeger(L, 5); + (arg1)->SetDataWithOwnership(*arg2,(void const *)arg3,arg4,arg5,arg6); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_Append(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBData *arg1 = (lldb::SBData *) 0 ; + lldb::SBData *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBData::Append",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::Append",1,"lldb::SBData *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBData::Append",2,"lldb::SBData const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBData_Append",1,SWIGTYPE_p_lldb__SBData); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBData_Append",2,SWIGTYPE_p_lldb__SBData); + } + + result = (bool)(arg1)->Append((lldb::SBData const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_CreateDataFromCString(lua_State* L) { + { + int SWIG_arg = 0; + lldb::ByteOrder arg1 ; + uint32_t arg2 ; + char *arg3 = (char *) 0 ; + lldb::SBData result; + + SWIG_check_num_args("lldb::SBData::CreateDataFromCString",3,3) + if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBData::CreateDataFromCString",1,"lldb::ByteOrder"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBData::CreateDataFromCString",2,"uint32_t"); + if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBData::CreateDataFromCString",3,"char const *"); + arg1 = (lldb::ByteOrder)lua_tointeger(L, 1); + arg2 = (uint32_t)lua_tointeger(L, 2); + arg3 = (char *)lua_tostring(L, 3); + result = lldb::SBData::CreateDataFromCString(arg1,arg2,(char const *)arg3); + { + lldb::SBData * resultptr = new lldb::SBData(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBData,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_CreateDataFromUInt64Array(lua_State* L) { + { + int SWIG_arg = 0; + lldb::ByteOrder arg1 ; + uint32_t arg2 ; + uint64_t *arg3 = (uint64_t *) 0 ; + size_t arg4 ; + lldb::SBData result; + + SWIG_check_num_args("lldb::SBData::CreateDataFromUInt64Array",3,3) + if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBData::CreateDataFromUInt64Array",1,"lldb::ByteOrder"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBData::CreateDataFromUInt64Array",2,"uint32_t"); + arg1 = (lldb::ByteOrder)lua_tointeger(L, 1); + arg2 = (uint32_t)lua_tointeger(L, 2); + { + if (lua_istable(L, 3)) { + // It should accept a table of numbers. + arg4 = lua_rawlen(L, 3); + arg3 = (uint64_t *)malloc((arg4) * sizeof(uint64_t)); + int i = 0, j = 0; + while (i++ < arg4) { + lua_rawgeti(L, 3, i); + if (!lua_isnumber(L, -1)) { + // if current element cannot be converted to number, raise an error + lua_pop(L, 1); + return luaL_error(L, "List should only contain numbers"); + } + arg3[j++] = (uint64_t) lua_tonumber(L, -1); + lua_pop(L, 1); + } + } else if (lua_isnil(L, 3)) { + // "nil" is also acceptable, equivalent as an empty table + arg3 = NULL; + arg4 = 0; + } else { + // else raise an error + return luaL_error(L, "A list of numbers expected."); + } + } + result = lldb::SBData::CreateDataFromUInt64Array(arg1,arg2,arg3,SWIG_STD_MOVE(arg4)); + { + lldb::SBData * resultptr = new lldb::SBData(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBData,1); SWIG_arg++; + } + { + free(arg3); + } + return SWIG_arg; + + fail: SWIGUNUSED; + { + free(arg3); + } + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_CreateDataFromUInt32Array(lua_State* L) { + { + int SWIG_arg = 0; + lldb::ByteOrder arg1 ; + uint32_t arg2 ; + uint32_t *arg3 = (uint32_t *) 0 ; + size_t arg4 ; + lldb::SBData result; + + SWIG_check_num_args("lldb::SBData::CreateDataFromUInt32Array",3,3) + if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBData::CreateDataFromUInt32Array",1,"lldb::ByteOrder"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBData::CreateDataFromUInt32Array",2,"uint32_t"); + arg1 = (lldb::ByteOrder)lua_tointeger(L, 1); + arg2 = (uint32_t)lua_tointeger(L, 2); + { + if (lua_istable(L, 3)) { + // It should accept a table of numbers. + arg4 = lua_rawlen(L, 3); + arg3 = (uint32_t *)malloc((arg4) * sizeof(uint32_t)); + int i = 0, j = 0; + while (i++ < arg4) { + lua_rawgeti(L, 3, i); + if (!lua_isnumber(L, -1)) { + // if current element cannot be converted to number, raise an error + lua_pop(L, 1); + return luaL_error(L, "List should only contain numbers"); + } + arg3[j++] = (uint32_t) lua_tonumber(L, -1); + lua_pop(L, 1); + } + } else if (lua_isnil(L, 3)) { + // "nil" is also acceptable, equivalent as an empty table + arg3 = NULL; + arg4 = 0; + } else { + // else raise an error + return luaL_error(L, "A list of numbers expected."); + } + } + result = lldb::SBData::CreateDataFromUInt32Array(arg1,arg2,arg3,SWIG_STD_MOVE(arg4)); + { + lldb::SBData * resultptr = new lldb::SBData(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBData,1); SWIG_arg++; + } + { + free(arg3); + } + return SWIG_arg; + + fail: SWIGUNUSED; + { + free(arg3); + } + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_CreateDataFromSInt64Array(lua_State* L) { + { + int SWIG_arg = 0; + lldb::ByteOrder arg1 ; + uint32_t arg2 ; + int64_t *arg3 = (int64_t *) 0 ; + size_t arg4 ; + lldb::SBData result; + + SWIG_check_num_args("lldb::SBData::CreateDataFromSInt64Array",3,3) + if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBData::CreateDataFromSInt64Array",1,"lldb::ByteOrder"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBData::CreateDataFromSInt64Array",2,"uint32_t"); + arg1 = (lldb::ByteOrder)lua_tointeger(L, 1); + arg2 = (uint32_t)lua_tointeger(L, 2); + { + if (lua_istable(L, 3)) { + // It should accept a table of numbers. + arg4 = lua_rawlen(L, 3); + arg3 = (int64_t *)malloc((arg4) * sizeof(int64_t)); + int i = 0, j = 0; + while (i++ < arg4) { + lua_rawgeti(L, 3, i); + if (!lua_isnumber(L, -1)) { + // if current element cannot be converted to number, raise an error + lua_pop(L, 1); + return luaL_error(L, "List should only contain numbers"); + } + arg3[j++] = (int64_t) lua_tonumber(L, -1); + lua_pop(L, 1); + } + } else if (lua_isnil(L, 3)) { + // "nil" is also acceptable, equivalent as an empty table + arg3 = NULL; + arg4 = 0; + } else { + // else raise an error + return luaL_error(L, "A list of numbers expected."); + } + } + result = lldb::SBData::CreateDataFromSInt64Array(arg1,arg2,arg3,SWIG_STD_MOVE(arg4)); + { + lldb::SBData * resultptr = new lldb::SBData(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBData,1); SWIG_arg++; + } + { + free(arg3); + } + return SWIG_arg; + + fail: SWIGUNUSED; + { + free(arg3); + } + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_CreateDataFromSInt32Array(lua_State* L) { + { + int SWIG_arg = 0; + lldb::ByteOrder arg1 ; + uint32_t arg2 ; + int32_t *arg3 = (int32_t *) 0 ; + size_t arg4 ; + lldb::SBData result; + + SWIG_check_num_args("lldb::SBData::CreateDataFromSInt32Array",3,3) + if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBData::CreateDataFromSInt32Array",1,"lldb::ByteOrder"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBData::CreateDataFromSInt32Array",2,"uint32_t"); + arg1 = (lldb::ByteOrder)lua_tointeger(L, 1); + arg2 = (uint32_t)lua_tointeger(L, 2); + { + if (lua_istable(L, 3)) { + // It should accept a table of numbers. + arg4 = lua_rawlen(L, 3); + arg3 = (int32_t *)malloc((arg4) * sizeof(int32_t)); + int i = 0, j = 0; + while (i++ < arg4) { + lua_rawgeti(L, 3, i); + if (!lua_isnumber(L, -1)) { + // if current element cannot be converted to number, raise an error + lua_pop(L, 1); + return luaL_error(L, "List should only contain numbers"); + } + arg3[j++] = (int32_t) lua_tonumber(L, -1); + lua_pop(L, 1); + } + } else if (lua_isnil(L, 3)) { + // "nil" is also acceptable, equivalent as an empty table + arg3 = NULL; + arg4 = 0; + } else { + // else raise an error + return luaL_error(L, "A list of numbers expected."); + } + } + result = lldb::SBData::CreateDataFromSInt32Array(arg1,arg2,arg3,SWIG_STD_MOVE(arg4)); + { + lldb::SBData * resultptr = new lldb::SBData(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBData,1); SWIG_arg++; + } + { + free(arg3); + } + return SWIG_arg; + + fail: SWIGUNUSED; + { + free(arg3); + } + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_CreateDataFromDoubleArray(lua_State* L) { + { + int SWIG_arg = 0; + lldb::ByteOrder arg1 ; + uint32_t arg2 ; + double *arg3 = (double *) 0 ; + size_t arg4 ; + lldb::SBData result; + + SWIG_check_num_args("lldb::SBData::CreateDataFromDoubleArray",3,3) + if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBData::CreateDataFromDoubleArray",1,"lldb::ByteOrder"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBData::CreateDataFromDoubleArray",2,"uint32_t"); + arg1 = (lldb::ByteOrder)lua_tointeger(L, 1); + arg2 = (uint32_t)lua_tointeger(L, 2); + { + if (lua_istable(L, 3)) { + // It should accept a table of numbers. + arg4 = lua_rawlen(L, 3); + arg3 = (double *)malloc((arg4) * sizeof(double)); + int i = 0, j = 0; + while (i++ < arg4) { + lua_rawgeti(L, 3, i); + if (!lua_isnumber(L, -1)) { + // if current element cannot be converted to number, raise an error + lua_pop(L, 1); + return luaL_error(L, "List should only contain numbers"); + } + arg3[j++] = (double) lua_tonumber(L, -1); + lua_pop(L, 1); + } + } else if (lua_isnil(L, 3)) { + // "nil" is also acceptable, equivalent as an empty table + arg3 = NULL; + arg4 = 0; + } else { + // else raise an error + return luaL_error(L, "A list of numbers expected."); + } + } + result = lldb::SBData::CreateDataFromDoubleArray(arg1,arg2,arg3,SWIG_STD_MOVE(arg4)); + { + lldb::SBData * resultptr = new lldb::SBData(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBData,1); SWIG_arg++; + } + { + free(arg3); + } + return SWIG_arg; + + fail: SWIGUNUSED; + { + free(arg3); + } + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_SetDataFromCString(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBData *arg1 = (lldb::SBData *) 0 ; + char *arg2 = (char *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBData::SetDataFromCString",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::SetDataFromCString",1,"lldb::SBData *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBData::SetDataFromCString",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBData_SetDataFromCString",1,SWIGTYPE_p_lldb__SBData); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (bool)(arg1)->SetDataFromCString((char const *)arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_SetDataFromUInt64Array(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBData *arg1 = (lldb::SBData *) 0 ; + uint64_t *arg2 = (uint64_t *) 0 ; + size_t arg3 ; + bool result; + + SWIG_check_num_args("lldb::SBData::SetDataFromUInt64Array",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::SetDataFromUInt64Array",1,"lldb::SBData *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBData_SetDataFromUInt64Array",1,SWIGTYPE_p_lldb__SBData); + } + + { + if (lua_istable(L, 2)) { + // It should accept a table of numbers. + arg3 = lua_rawlen(L, 2); + arg2 = (uint64_t *)malloc((arg3) * sizeof(uint64_t)); + int i = 0, j = 0; + while (i++ < arg3) { + lua_rawgeti(L, 2, i); + if (!lua_isnumber(L, -1)) { + // if current element cannot be converted to number, raise an error + lua_pop(L, 1); + return luaL_error(L, "List should only contain numbers"); + } + arg2[j++] = (uint64_t) lua_tonumber(L, -1); + lua_pop(L, 1); + } + } else if (lua_isnil(L, 2)) { + // "nil" is also acceptable, equivalent as an empty table + arg2 = NULL; + arg3 = 0; + } else { + // else raise an error + return luaL_error(L, "A list of numbers expected."); + } + } + result = (bool)(arg1)->SetDataFromUInt64Array(arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + { + free(arg2); + } + return SWIG_arg; + + fail: SWIGUNUSED; + { + free(arg2); + } + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_SetDataFromUInt32Array(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBData *arg1 = (lldb::SBData *) 0 ; + uint32_t *arg2 = (uint32_t *) 0 ; + size_t arg3 ; + bool result; + + SWIG_check_num_args("lldb::SBData::SetDataFromUInt32Array",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::SetDataFromUInt32Array",1,"lldb::SBData *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBData_SetDataFromUInt32Array",1,SWIGTYPE_p_lldb__SBData); + } + + { + if (lua_istable(L, 2)) { + // It should accept a table of numbers. + arg3 = lua_rawlen(L, 2); + arg2 = (uint32_t *)malloc((arg3) * sizeof(uint32_t)); + int i = 0, j = 0; + while (i++ < arg3) { + lua_rawgeti(L, 2, i); + if (!lua_isnumber(L, -1)) { + // if current element cannot be converted to number, raise an error + lua_pop(L, 1); + return luaL_error(L, "List should only contain numbers"); + } + arg2[j++] = (uint32_t) lua_tonumber(L, -1); + lua_pop(L, 1); + } + } else if (lua_isnil(L, 2)) { + // "nil" is also acceptable, equivalent as an empty table + arg2 = NULL; + arg3 = 0; + } else { + // else raise an error + return luaL_error(L, "A list of numbers expected."); + } + } + result = (bool)(arg1)->SetDataFromUInt32Array(arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + { + free(arg2); + } + return SWIG_arg; + + fail: SWIGUNUSED; + { + free(arg2); + } + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_SetDataFromSInt64Array(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBData *arg1 = (lldb::SBData *) 0 ; + int64_t *arg2 = (int64_t *) 0 ; + size_t arg3 ; + bool result; + + SWIG_check_num_args("lldb::SBData::SetDataFromSInt64Array",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::SetDataFromSInt64Array",1,"lldb::SBData *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBData_SetDataFromSInt64Array",1,SWIGTYPE_p_lldb__SBData); + } + + { + if (lua_istable(L, 2)) { + // It should accept a table of numbers. + arg3 = lua_rawlen(L, 2); + arg2 = (int64_t *)malloc((arg3) * sizeof(int64_t)); + int i = 0, j = 0; + while (i++ < arg3) { + lua_rawgeti(L, 2, i); + if (!lua_isnumber(L, -1)) { + // if current element cannot be converted to number, raise an error + lua_pop(L, 1); + return luaL_error(L, "List should only contain numbers"); + } + arg2[j++] = (int64_t) lua_tonumber(L, -1); + lua_pop(L, 1); + } + } else if (lua_isnil(L, 2)) { + // "nil" is also acceptable, equivalent as an empty table + arg2 = NULL; + arg3 = 0; + } else { + // else raise an error + return luaL_error(L, "A list of numbers expected."); + } + } + result = (bool)(arg1)->SetDataFromSInt64Array(arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + { + free(arg2); + } + return SWIG_arg; + + fail: SWIGUNUSED; + { + free(arg2); + } + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_SetDataFromSInt32Array(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBData *arg1 = (lldb::SBData *) 0 ; + int32_t *arg2 = (int32_t *) 0 ; + size_t arg3 ; + bool result; + + SWIG_check_num_args("lldb::SBData::SetDataFromSInt32Array",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::SetDataFromSInt32Array",1,"lldb::SBData *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBData_SetDataFromSInt32Array",1,SWIGTYPE_p_lldb__SBData); + } + + { + if (lua_istable(L, 2)) { + // It should accept a table of numbers. + arg3 = lua_rawlen(L, 2); + arg2 = (int32_t *)malloc((arg3) * sizeof(int32_t)); + int i = 0, j = 0; + while (i++ < arg3) { + lua_rawgeti(L, 2, i); + if (!lua_isnumber(L, -1)) { + // if current element cannot be converted to number, raise an error + lua_pop(L, 1); + return luaL_error(L, "List should only contain numbers"); + } + arg2[j++] = (int32_t) lua_tonumber(L, -1); + lua_pop(L, 1); + } + } else if (lua_isnil(L, 2)) { + // "nil" is also acceptable, equivalent as an empty table + arg2 = NULL; + arg3 = 0; + } else { + // else raise an error + return luaL_error(L, "A list of numbers expected."); + } + } + result = (bool)(arg1)->SetDataFromSInt32Array(arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + { + free(arg2); + } + return SWIG_arg; + + fail: SWIGUNUSED; + { + free(arg2); + } + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData_SetDataFromDoubleArray(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBData *arg1 = (lldb::SBData *) 0 ; + double *arg2 = (double *) 0 ; + size_t arg3 ; + bool result; + + SWIG_check_num_args("lldb::SBData::SetDataFromDoubleArray",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::SetDataFromDoubleArray",1,"lldb::SBData *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBData_SetDataFromDoubleArray",1,SWIGTYPE_p_lldb__SBData); + } + + { + if (lua_istable(L, 2)) { + // It should accept a table of numbers. + arg3 = lua_rawlen(L, 2); + arg2 = (double *)malloc((arg3) * sizeof(double)); + int i = 0, j = 0; + while (i++ < arg3) { + lua_rawgeti(L, 2, i); + if (!lua_isnumber(L, -1)) { + // if current element cannot be converted to number, raise an error + lua_pop(L, 1); + return luaL_error(L, "List should only contain numbers"); + } + arg2[j++] = (double) lua_tonumber(L, -1); + lua_pop(L, 1); + } + } else if (lua_isnil(L, 2)) { + // "nil" is also acceptable, equivalent as an empty table + arg2 = NULL; + arg3 = 0; + } else { + // else raise an error + return luaL_error(L, "A list of numbers expected."); + } + } + result = (bool)(arg1)->SetDataFromDoubleArray(arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + { + free(arg2); + } + return SWIG_arg; + + fail: SWIGUNUSED; + { + free(arg2); + } + } + lua_error(L); + return 0; +} + + +static int _wrap_SBData___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBData *arg1 = (lldb::SBData *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBData::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBData::__repr__",1,"lldb::SBData *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBData___tostring",1,SWIGTYPE_p_lldb__SBData); + } + + result = lldb_SBData___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBData(void *obj) { +lldb::SBData *arg1 = (lldb::SBData *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBData(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBData); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBData_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBData_methods[]= { + { "GetAddressByteSize", _wrap_SBData_GetAddressByteSize}, + { "SetAddressByteSize", _wrap_SBData_SetAddressByteSize}, + { "Clear", _wrap_SBData_Clear}, + { "IsValid", _wrap_SBData_IsValid}, + { "GetByteSize", _wrap_SBData_GetByteSize}, + { "GetByteOrder", _wrap_SBData_GetByteOrder}, + { "SetByteOrder", _wrap_SBData_SetByteOrder}, + { "GetFloat", _wrap_SBData_GetFloat}, + { "GetDouble", _wrap_SBData_GetDouble}, + { "GetLongDouble", _wrap_SBData_GetLongDouble}, + { "GetAddress", _wrap_SBData_GetAddress}, + { "GetUnsignedInt8", _wrap_SBData_GetUnsignedInt8}, + { "GetUnsignedInt16", _wrap_SBData_GetUnsignedInt16}, + { "GetUnsignedInt32", _wrap_SBData_GetUnsignedInt32}, + { "GetUnsignedInt64", _wrap_SBData_GetUnsignedInt64}, + { "GetSignedInt8", _wrap_SBData_GetSignedInt8}, + { "GetSignedInt16", _wrap_SBData_GetSignedInt16}, + { "GetSignedInt32", _wrap_SBData_GetSignedInt32}, + { "GetSignedInt64", _wrap_SBData_GetSignedInt64}, + { "GetString", _wrap_SBData_GetString}, + { "ReadRawData", _wrap_SBData_ReadRawData}, + { "GetDescription", _wrap_SBData_GetDescription}, + { "SetData", _wrap_SBData_SetData}, + { "SetDataWithOwnership", _wrap_SBData_SetDataWithOwnership}, + { "Append", _wrap_SBData_Append}, + { "SetDataFromCString", _wrap_SBData_SetDataFromCString}, + { "SetDataFromUInt64Array", _wrap_SBData_SetDataFromUInt64Array}, + { "SetDataFromUInt32Array", _wrap_SBData_SetDataFromUInt32Array}, + { "SetDataFromSInt64Array", _wrap_SBData_SetDataFromSInt64Array}, + { "SetDataFromSInt32Array", _wrap_SBData_SetDataFromSInt32Array}, + { "SetDataFromDoubleArray", _wrap_SBData_SetDataFromDoubleArray}, + { "__tostring", _wrap_SBData___tostring}, + {0,0} +}; +static swig_lua_method swig_SBData_meta[] = { + { "__tostring", _wrap_SBData___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBData_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBData_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBData_Sf_SwigStatic_methods[]= { + { "CreateDataFromCString", _wrap_SBData_CreateDataFromCString}, + { "CreateDataFromUInt64Array", _wrap_SBData_CreateDataFromUInt64Array}, + { "CreateDataFromUInt32Array", _wrap_SBData_CreateDataFromUInt32Array}, + { "CreateDataFromSInt64Array", _wrap_SBData_CreateDataFromSInt64Array}, + { "CreateDataFromSInt32Array", _wrap_SBData_CreateDataFromSInt32Array}, + { "CreateDataFromDoubleArray", _wrap_SBData_CreateDataFromDoubleArray}, + {0,0} +}; +static swig_lua_class* swig_SBData_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBData_Sf_SwigStatic = { + "SBData", + swig_SBData_Sf_SwigStatic_methods, + swig_SBData_Sf_SwigStatic_attributes, + swig_SBData_Sf_SwigStatic_constants, + swig_SBData_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBData_bases[] = {0}; +static const char *swig_SBData_base_names[] = {0}; +static swig_lua_class _wrap_class_SBData = { "SBData", "SBData", &SWIGTYPE_p_lldb__SBData,_proxy__wrap_new_SBData, swig_delete_SBData, swig_SBData_methods, swig_SBData_attributes, &swig_SBData_Sf_SwigStatic, swig_SBData_meta, swig_SBData_bases, swig_SBData_base_names }; + +static int _wrap_new_SBDebugger__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *result = 0 ; + + SWIG_check_num_args("lldb::SBDebugger::SBDebugger",0,0) + result = (lldb::SBDebugger *)new lldb::SBDebugger(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBDebugger,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBDebugger__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = 0 ; + lldb::SBDebugger *result = 0 ; + + SWIG_check_num_args("lldb::SBDebugger::SBDebugger",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBDebugger::SBDebugger",1,"lldb::SBDebugger const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("new_SBDebugger",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = (lldb::SBDebugger *)new lldb::SBDebugger((lldb::SBDebugger const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBDebugger,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBDebugger(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBDebugger__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBDebugger, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBDebugger__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBDebugger'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBDebugger::SBDebugger()\n" + " lldb::SBDebugger::SBDebugger(lldb::SBDebugger const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBDebugger_GetBroadcasterClass(lua_State* L) { + { + int SWIG_arg = 0; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBDebugger::GetBroadcasterClass",0,0) + result = (char *)lldb::SBDebugger::GetBroadcasterClass(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_SupportsLanguage(lua_State* L) { + { + int SWIG_arg = 0; + lldb::LanguageType arg1 ; + bool result; + + SWIG_check_num_args("lldb::SBDebugger::SupportsLanguage",1,1) + if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBDebugger::SupportsLanguage",1,"lldb::LanguageType"); + arg1 = (lldb::LanguageType)lua_tointeger(L, 1); + result = (bool)lldb::SBDebugger::SupportsLanguage(arg1); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetBroadcaster(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBBroadcaster result; + + SWIG_check_num_args("lldb::SBDebugger::GetBroadcaster",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetBroadcaster",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetBroadcaster",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = (arg1)->GetBroadcaster(); + { + lldb::SBBroadcaster * resultptr = new lldb::SBBroadcaster(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBroadcaster,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetProgressFromEvent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = 0 ; + uint64_t *arg2 = 0 ; + uint64_t *arg3 = 0 ; + uint64_t *arg4 = 0 ; + bool *arg5 = 0 ; + uint64_t temp2 ; + uint64_t temp3 ; + uint64_t temp4 ; + bool temp5 ; + char *result = 0 ; + + arg2 = &temp2; + arg3 = &temp3; + arg4 = &temp4; + arg5 = &temp5; + SWIG_check_num_args("lldb::SBDebugger::GetProgressFromEvent",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetProgressFromEvent",1,"lldb::SBEvent const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBDebugger_GetProgressFromEvent",1,SWIGTYPE_p_lldb__SBEvent); + } + + result = (char *)lldb::SBDebugger::GetProgressFromEvent((lldb::SBEvent const &)*arg1,*arg2,*arg3,*arg4,*arg5); + lua_pushstring(L,(const char *)result); SWIG_arg++; + lua_pushinteger(L, (lua_Integer) *arg2); SWIG_arg++; + lua_pushinteger(L, (lua_Integer) *arg3); SWIG_arg++; + lua_pushinteger(L, (lua_Integer) *arg4); SWIG_arg++; + lua_pushboolean(L, (int)((*arg5)!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetProgressDataFromEvent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = 0 ; + lldb::SBStructuredData result; + + SWIG_check_num_args("lldb::SBDebugger::GetProgressDataFromEvent",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetProgressDataFromEvent",1,"lldb::SBEvent const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBDebugger_GetProgressDataFromEvent",1,SWIGTYPE_p_lldb__SBEvent); + } + + result = lldb::SBDebugger::GetProgressDataFromEvent((lldb::SBEvent const &)*arg1); + { + lldb::SBStructuredData * resultptr = new lldb::SBStructuredData(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBStructuredData,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetDiagnosticFromEvent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = 0 ; + lldb::SBStructuredData result; + + SWIG_check_num_args("lldb::SBDebugger::GetDiagnosticFromEvent",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetDiagnosticFromEvent",1,"lldb::SBEvent const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBDebugger_GetDiagnosticFromEvent",1,SWIGTYPE_p_lldb__SBEvent); + } + + result = lldb::SBDebugger::GetDiagnosticFromEvent((lldb::SBEvent const &)*arg1); + { + lldb::SBStructuredData * resultptr = new lldb::SBStructuredData(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBStructuredData,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_Initialize(lua_State* L) { + { + int SWIG_arg = 0; + + SWIG_check_num_args("lldb::SBDebugger::Initialize",0,0) + lldb::SBDebugger::Initialize(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_InitializeWithErrorHandling(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBDebugger::InitializeWithErrorHandling",0,0) + result = lldb::SBDebugger::InitializeWithErrorHandling(); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_PrintStackTraceOnError(lua_State* L) { + { + int SWIG_arg = 0; + + SWIG_check_num_args("lldb::SBDebugger::PrintStackTraceOnError",0,0) + lldb::SBDebugger::PrintStackTraceOnError(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_PrintDiagnosticsOnError(lua_State* L) { + { + int SWIG_arg = 0; + + SWIG_check_num_args("lldb::SBDebugger::PrintDiagnosticsOnError",0,0) + lldb::SBDebugger::PrintDiagnosticsOnError(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_Terminate(lua_State* L) { + { + int SWIG_arg = 0; + + SWIG_check_num_args("lldb::SBDebugger::Terminate",0,0) + lldb::SBDebugger::Terminate(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_Create__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger result; + + SWIG_check_num_args("lldb::SBDebugger::Create",0,0) + result = lldb::SBDebugger::Create(); + { + lldb::SBDebugger * resultptr = new lldb::SBDebugger(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBDebugger,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_Create__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + bool arg1 ; + lldb::SBDebugger result; + + SWIG_check_num_args("lldb::SBDebugger::Create",1,1) + if(!lua_isboolean(L,1)) SWIG_fail_arg("lldb::SBDebugger::Create",1,"bool"); + arg1 = (lua_toboolean(L, 1)!=0); + result = lldb::SBDebugger::Create(arg1); + { + lldb::SBDebugger * resultptr = new lldb::SBDebugger(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBDebugger,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_Create__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + bool arg1 ; + lldb::LogOutputCallback arg2 = (lldb::LogOutputCallback) 0 ; + void *arg3 = (void *) 0 ; + lldb::SBDebugger result; + + SWIG_check_num_args("lldb::SBDebugger::Create",2,2) + if(!lua_isboolean(L,1)) SWIG_fail_arg("lldb::SBDebugger::Create",1,"bool"); + arg1 = (lua_toboolean(L, 1)!=0); + { + arg2 = LLDBSwigLuaCallLuaLogOutputCallback; + arg3 = (void *)L; + + luaL_checktype(L, 2, LUA_TFUNCTION); + lua_settop(L, 2); + + lua_pushlightuserdata(L, (void *)&LLDBSwigLuaCallLuaLogOutputCallback); + lua_insert(L, 2); + lua_settable(L, LUA_REGISTRYINDEX); + } + result = lldb::SBDebugger::Create(arg1,arg2,arg3); + { + lldb::SBDebugger * resultptr = new lldb::SBDebugger(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBDebugger,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_Create(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_SBDebugger_Create__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + _v = lua_isboolean(L,argv[0]); + } + if (_v) { + return _wrap_SBDebugger_Create__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + _v = lua_isboolean(L,argv[0]); + } + if (_v) { + { + void *ptr; + if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_f_p_q_const__char_p_void__void, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + if (argc <= 2) { + return _wrap_SBDebugger_Create__SWIG_2(L); + } + { + void *ptr; + if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, 0, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBDebugger_Create__SWIG_2(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBDebugger_Destroy(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = 0 ; + + SWIG_check_num_args("lldb::SBDebugger::Destroy",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBDebugger::Destroy",1,"lldb::SBDebugger &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_Destroy",1,SWIGTYPE_p_lldb__SBDebugger); + } + + lldb::SBDebugger::Destroy(*arg1); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_MemoryPressureDetected(lua_State* L) { + { + int SWIG_arg = 0; + + SWIG_check_num_args("lldb::SBDebugger::MemoryPressureDetected",0,0) + lldb::SBDebugger::MemoryPressureDetected(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBDebugger::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::IsValid",1,"lldb::SBDebugger const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_IsValid",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = (bool)((lldb::SBDebugger const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + + SWIG_check_num_args("lldb::SBDebugger::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::Clear",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_Clear",1,SWIGTYPE_p_lldb__SBDebugger); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetSetting__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBStructuredData result; + + SWIG_check_num_args("lldb::SBDebugger::GetSetting",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetSetting",1,"lldb::SBDebugger *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBDebugger::GetSetting",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetSetting",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->GetSetting((char const *)arg2); + { + lldb::SBStructuredData * resultptr = new lldb::SBStructuredData(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBStructuredData,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetSetting__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBStructuredData result; + + SWIG_check_num_args("lldb::SBDebugger::GetSetting",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetSetting",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetSetting",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = (arg1)->GetSetting(); + { + lldb::SBStructuredData * resultptr = new lldb::SBStructuredData(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBStructuredData,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetSetting(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBDebugger, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBDebugger_GetSetting__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBDebugger, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + return _wrap_SBDebugger_GetSetting__SWIG_0(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBDebugger_GetSetting'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBDebugger::GetSetting(char const *)\n" + " lldb::SBDebugger::GetSetting()\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBDebugger_SetAsync(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBDebugger::SetAsync",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetAsync",1,"lldb::SBDebugger *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBDebugger::SetAsync",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_SetAsync",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetAsync(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetAsync(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBDebugger::GetAsync",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetAsync",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetAsync",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = (bool)(arg1)->GetAsync(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_SkipLLDBInitFiles(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBDebugger::SkipLLDBInitFiles",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SkipLLDBInitFiles",1,"lldb::SBDebugger *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBDebugger::SkipLLDBInitFiles",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_SkipLLDBInitFiles",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SkipLLDBInitFiles(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_SkipAppInitFiles(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBDebugger::SkipAppInitFiles",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SkipAppInitFiles",1,"lldb::SBDebugger *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBDebugger::SkipAppInitFiles",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_SkipAppInitFiles",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SkipAppInitFiles(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_SetInputString(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBDebugger::SetInputString",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetInputString",1,"lldb::SBDebugger *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBDebugger::SetInputString",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_SetInputString",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->SetInputString((char const *)arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_SetInputFile__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBFile arg2 ; + lldb::SBFile *argp2 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBDebugger::SetInputFile",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetInputFile",1,"lldb::SBDebugger *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBDebugger::SetInputFile",2,"lldb::SBFile"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_SetInputFile",1,SWIGTYPE_p_lldb__SBDebugger); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBFile,0))){ + SWIG_fail_ptr("SBDebugger_SetInputFile",2,SWIGTYPE_p_lldb__SBFile); + } + arg2 = *argp2; + + result = (arg1)->SetInputFile(arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_SetOutputFile__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBFile arg2 ; + lldb::SBFile *argp2 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBDebugger::SetOutputFile",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetOutputFile",1,"lldb::SBDebugger *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBDebugger::SetOutputFile",2,"lldb::SBFile"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_SetOutputFile",1,SWIGTYPE_p_lldb__SBDebugger); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBFile,0))){ + SWIG_fail_ptr("SBDebugger_SetOutputFile",2,SWIGTYPE_p_lldb__SBFile); + } + arg2 = *argp2; + + result = (arg1)->SetOutputFile(arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_SetErrorFile__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBFile arg2 ; + lldb::SBFile *argp2 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBDebugger::SetErrorFile",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetErrorFile",1,"lldb::SBDebugger *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBDebugger::SetErrorFile",2,"lldb::SBFile"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_SetErrorFile",1,SWIGTYPE_p_lldb__SBDebugger); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBFile,0))){ + SWIG_fail_ptr("SBDebugger_SetErrorFile",2,SWIGTYPE_p_lldb__SBFile); + } + arg2 = *argp2; + + result = (arg1)->SetErrorFile(arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_SetInputFile__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBDebugger::SetInputFile",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetInputFile",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_SetInputFile",1,SWIGTYPE_p_lldb__SBDebugger); + } + + { + luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 2, LUA_FILEHANDLE); + lldb::FileSP file_sp; + file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false); + if (!file_sp->IsValid()) + return luaL_error(L, "Invalid file"); + arg2 = file_sp; + } + result = (arg1)->SetInputFile(arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_SetInputFile(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBDebugger, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBDebugger_SetInputFile__SWIG_0(L); + } + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBDebugger, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = (lua_isuserdata(L, argv[1])) && + (luaL_testudata(L, argv[1], LUA_FILEHANDLE) != nullptr); + } + if (_v) { + return _wrap_SBDebugger_SetInputFile__SWIG_1(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBDebugger_SetOutputFile__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBDebugger::SetOutputFile",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetOutputFile",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_SetOutputFile",1,SWIGTYPE_p_lldb__SBDebugger); + } + + { + luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 2, LUA_FILEHANDLE); + lldb::FileSP file_sp; + file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false); + if (!file_sp->IsValid()) + return luaL_error(L, "Invalid file"); + arg2 = file_sp; + } + result = (arg1)->SetOutputFile(arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_SetOutputFile(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBDebugger, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBDebugger_SetOutputFile__SWIG_0(L); + } + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBDebugger, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = (lua_isuserdata(L, argv[1])) && + (luaL_testudata(L, argv[1], LUA_FILEHANDLE) != nullptr); + } + if (_v) { + return _wrap_SBDebugger_SetOutputFile__SWIG_1(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBDebugger_SetErrorFile__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBDebugger::SetErrorFile",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetErrorFile",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_SetErrorFile",1,SWIGTYPE_p_lldb__SBDebugger); + } + + { + luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 2, LUA_FILEHANDLE); + lldb::FileSP file_sp; + file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false); + if (!file_sp->IsValid()) + return luaL_error(L, "Invalid file"); + arg2 = file_sp; + } + result = (arg1)->SetErrorFile(arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_SetErrorFile(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBDebugger, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBDebugger_SetErrorFile__SWIG_0(L); + } + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBDebugger, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = (lua_isuserdata(L, argv[1])) && + (luaL_testudata(L, argv[1], LUA_FILEHANDLE) != nullptr); + } + if (_v) { + return _wrap_SBDebugger_SetErrorFile__SWIG_1(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBDebugger_GetInputFile(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBFile result; + + SWIG_check_num_args("lldb::SBDebugger::GetInputFile",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetInputFile",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetInputFile",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = (arg1)->GetInputFile(); + { + lldb::SBFile * resultptr = new lldb::SBFile(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFile,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetOutputFile(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBFile result; + + SWIG_check_num_args("lldb::SBDebugger::GetOutputFile",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetOutputFile",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetOutputFile",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = (arg1)->GetOutputFile(); + { + lldb::SBFile * resultptr = new lldb::SBFile(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFile,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetErrorFile(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBFile result; + + SWIG_check_num_args("lldb::SBDebugger::GetErrorFile",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetErrorFile",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetErrorFile",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = (arg1)->GetErrorFile(); + { + lldb::SBFile * resultptr = new lldb::SBFile(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFile,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_SaveInputTerminalState(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + + SWIG_check_num_args("lldb::SBDebugger::SaveInputTerminalState",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SaveInputTerminalState",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_SaveInputTerminalState",1,SWIGTYPE_p_lldb__SBDebugger); + } + + (arg1)->SaveInputTerminalState(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_RestoreInputTerminalState(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + + SWIG_check_num_args("lldb::SBDebugger::RestoreInputTerminalState",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::RestoreInputTerminalState",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_RestoreInputTerminalState",1,SWIGTYPE_p_lldb__SBDebugger); + } + + (arg1)->RestoreInputTerminalState(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetCommandInterpreter(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBCommandInterpreter result; + + SWIG_check_num_args("lldb::SBDebugger::GetCommandInterpreter",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetCommandInterpreter",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetCommandInterpreter",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = (arg1)->GetCommandInterpreter(); + { + lldb::SBCommandInterpreter * resultptr = new lldb::SBCommandInterpreter(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBCommandInterpreter,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_HandleCommand(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBDebugger::HandleCommand",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::HandleCommand",1,"lldb::SBDebugger *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBDebugger::HandleCommand",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_HandleCommand",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->HandleCommand((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_RequestInterrupt(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + + SWIG_check_num_args("lldb::SBDebugger::RequestInterrupt",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::RequestInterrupt",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_RequestInterrupt",1,SWIGTYPE_p_lldb__SBDebugger); + } + + (arg1)->RequestInterrupt(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_CancelInterruptRequest(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + + SWIG_check_num_args("lldb::SBDebugger::CancelInterruptRequest",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::CancelInterruptRequest",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_CancelInterruptRequest",1,SWIGTYPE_p_lldb__SBDebugger); + } + + (arg1)->CancelInterruptRequest(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_InterruptRequested(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBDebugger::InterruptRequested",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::InterruptRequested",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_InterruptRequested",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = (bool)(arg1)->InterruptRequested(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetListener(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBListener result; + + SWIG_check_num_args("lldb::SBDebugger::GetListener",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetListener",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetListener",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = (arg1)->GetListener(); + { + lldb::SBListener * resultptr = new lldb::SBListener(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBListener,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_HandleProcessEvent__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBProcess *arg2 = 0 ; + lldb::SBEvent *arg3 = 0 ; + lldb::SBFile arg4 ; + lldb::SBFile arg5 ; + lldb::SBFile *argp4 ; + lldb::SBFile *argp5 ; + + SWIG_check_num_args("lldb::SBDebugger::HandleProcessEvent",5,5) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::HandleProcessEvent",1,"lldb::SBDebugger *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBDebugger::HandleProcessEvent",2,"lldb::SBProcess const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBDebugger::HandleProcessEvent",3,"lldb::SBEvent const &"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBDebugger::HandleProcessEvent",4,"lldb::SBFile"); + if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBDebugger::HandleProcessEvent",5,"lldb::SBFile"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_HandleProcessEvent",1,SWIGTYPE_p_lldb__SBDebugger); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBDebugger_HandleProcessEvent",2,SWIGTYPE_p_lldb__SBProcess); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBDebugger_HandleProcessEvent",3,SWIGTYPE_p_lldb__SBEvent); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_lldb__SBFile,0))){ + SWIG_fail_ptr("SBDebugger_HandleProcessEvent",4,SWIGTYPE_p_lldb__SBFile); + } + arg4 = *argp4; + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&argp5,SWIGTYPE_p_lldb__SBFile,0))){ + SWIG_fail_ptr("SBDebugger_HandleProcessEvent",5,SWIGTYPE_p_lldb__SBFile); + } + arg5 = *argp5; + + (arg1)->HandleProcessEvent((lldb::SBProcess const &)*arg2,(lldb::SBEvent const &)*arg3,arg4,arg5); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_HandleProcessEvent__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 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 ; + + SWIG_check_num_args("lldb::SBDebugger::HandleProcessEvent",5,5) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::HandleProcessEvent",1,"lldb::SBDebugger *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBDebugger::HandleProcessEvent",2,"lldb::SBProcess const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBDebugger::HandleProcessEvent",3,"lldb::SBEvent const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_HandleProcessEvent",1,SWIGTYPE_p_lldb__SBDebugger); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBDebugger_HandleProcessEvent",2,SWIGTYPE_p_lldb__SBProcess); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBDebugger_HandleProcessEvent",3,SWIGTYPE_p_lldb__SBEvent); + } + + { + luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 4, LUA_FILEHANDLE); + lldb::FileSP file_sp; + file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false); + if (!file_sp->IsValid()) + return luaL_error(L, "Invalid file"); + arg4 = file_sp; + } + { + luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 5, LUA_FILEHANDLE); + lldb::FileSP file_sp; + file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false); + if (!file_sp->IsValid()) + return luaL_error(L, "Invalid file"); + arg5 = file_sp; + } + (arg1)->HandleProcessEvent((lldb::SBProcess const &)*arg2,(lldb::SBEvent const &)*arg3,arg4,arg5); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_HandleProcessEvent(lua_State* L) { + int argc; + int argv[6]={ + 1,2,3,4,5,6 + }; + + argc = lua_gettop(L); + if (argc == 5) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBDebugger, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBEvent, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBDebugger_HandleProcessEvent__SWIG_0(L); + } + } + } + } + } + } + if (argc == 5) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBDebugger, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBEvent, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = (lua_isuserdata(L, argv[3])) && + (luaL_testudata(L, argv[3], LUA_FILEHANDLE) != nullptr); + } + if (_v) { + { + _v = (lua_isuserdata(L, argv[4])) && + (luaL_testudata(L, argv[4], LUA_FILEHANDLE) != nullptr); + } + if (_v) { + return _wrap_SBDebugger_HandleProcessEvent__SWIG_1(L); + } + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBDebugger_CreateTarget__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + char *arg4 = (char *) 0 ; + bool arg5 ; + lldb::SBError *arg6 = 0 ; + lldb::SBTarget result; + + SWIG_check_num_args("lldb::SBDebugger::CreateTarget",6,6) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::CreateTarget",1,"lldb::SBDebugger *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBDebugger::CreateTarget",2,"char const *"); + if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBDebugger::CreateTarget",3,"char const *"); + if(!SWIG_lua_isnilstring(L,4)) SWIG_fail_arg("lldb::SBDebugger::CreateTarget",4,"char const *"); + if(!lua_isboolean(L,5)) SWIG_fail_arg("lldb::SBDebugger::CreateTarget",5,"bool"); + if(!lua_isuserdata(L,6)) SWIG_fail_arg("lldb::SBDebugger::CreateTarget",6,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_CreateTarget",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (char *)lua_tostring(L, 3); + arg4 = (char *)lua_tostring(L, 4); + arg5 = (lua_toboolean(L, 5)!=0); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBDebugger_CreateTarget",6,SWIGTYPE_p_lldb__SBError); + } + + result = (arg1)->CreateTarget((char const *)arg2,(char const *)arg3,(char const *)arg4,arg5,*arg6); + { + lldb::SBTarget * resultptr = new lldb::SBTarget(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTarget,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_CreateTargetWithFileAndTargetTriple(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + lldb::SBTarget result; + + SWIG_check_num_args("lldb::SBDebugger::CreateTargetWithFileAndTargetTriple",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::CreateTargetWithFileAndTargetTriple",1,"lldb::SBDebugger *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBDebugger::CreateTargetWithFileAndTargetTriple",2,"char const *"); + if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBDebugger::CreateTargetWithFileAndTargetTriple",3,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_CreateTargetWithFileAndTargetTriple",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (char *)lua_tostring(L, 3); + result = (arg1)->CreateTargetWithFileAndTargetTriple((char const *)arg2,(char const *)arg3); + { + lldb::SBTarget * resultptr = new lldb::SBTarget(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTarget,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_CreateTargetWithFileAndArch(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + lldb::SBTarget result; + + SWIG_check_num_args("lldb::SBDebugger::CreateTargetWithFileAndArch",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::CreateTargetWithFileAndArch",1,"lldb::SBDebugger *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBDebugger::CreateTargetWithFileAndArch",2,"char const *"); + if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBDebugger::CreateTargetWithFileAndArch",3,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_CreateTargetWithFileAndArch",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (char *)lua_tostring(L, 3); + result = (arg1)->CreateTargetWithFileAndArch((char const *)arg2,(char const *)arg3); + { + lldb::SBTarget * resultptr = new lldb::SBTarget(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTarget,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_CreateTarget__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBTarget result; + + SWIG_check_num_args("lldb::SBDebugger::CreateTarget",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::CreateTarget",1,"lldb::SBDebugger *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBDebugger::CreateTarget",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_CreateTarget",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->CreateTarget((char const *)arg2); + { + lldb::SBTarget * resultptr = new lldb::SBTarget(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTarget,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_CreateTarget(lua_State* L) { + int argc; + int argv[7]={ + 1,2,3,4,5,6,7 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBDebugger, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + return _wrap_SBDebugger_CreateTarget__SWIG_1(L); + } + } + } + if (argc == 6) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBDebugger, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[2]); + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[3]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[4]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[5])==0 || SWIG_ConvertPtr(L,argv[5], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBDebugger_CreateTarget__SWIG_0(L); + } + } + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBDebugger_GetDummyTarget(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBTarget result; + + SWIG_check_num_args("lldb::SBDebugger::GetDummyTarget",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetDummyTarget",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetDummyTarget",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = (arg1)->GetDummyTarget(); + { + lldb::SBTarget * resultptr = new lldb::SBTarget(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTarget,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_DeleteTarget(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBTarget *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBDebugger::DeleteTarget",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::DeleteTarget",1,"lldb::SBDebugger *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBDebugger::DeleteTarget",2,"lldb::SBTarget &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_DeleteTarget",1,SWIGTYPE_p_lldb__SBDebugger); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBDebugger_DeleteTarget",2,SWIGTYPE_p_lldb__SBTarget); + } + + result = (bool)(arg1)->DeleteTarget(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetTargetAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + uint32_t arg2 ; + lldb::SBTarget result; + + SWIG_check_num_args("lldb::SBDebugger::GetTargetAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetTargetAtIndex",1,"lldb::SBDebugger *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBDebugger::GetTargetAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetTargetAtIndex",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetTargetAtIndex(arg2); + { + lldb::SBTarget * resultptr = new lldb::SBTarget(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTarget,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetIndexOfTarget(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBTarget arg2 ; + lldb::SBTarget *argp2 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBDebugger::GetIndexOfTarget",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetIndexOfTarget",1,"lldb::SBDebugger *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBDebugger::GetIndexOfTarget",2,"lldb::SBTarget"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetIndexOfTarget",1,SWIGTYPE_p_lldb__SBDebugger); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBDebugger_GetIndexOfTarget",2,SWIGTYPE_p_lldb__SBTarget); + } + arg2 = *argp2; + + result = (uint32_t)(arg1)->GetIndexOfTarget(arg2); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_FindTargetWithProcessID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::pid_t arg2 ; + lldb::SBTarget result; + + SWIG_check_num_args("lldb::SBDebugger::FindTargetWithProcessID",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::FindTargetWithProcessID",1,"lldb::SBDebugger *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBDebugger::FindTargetWithProcessID",2,"lldb::pid_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_FindTargetWithProcessID",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (lldb::pid_t)lua_tointeger(L, 2); + result = (arg1)->FindTargetWithProcessID(arg2); + { + lldb::SBTarget * resultptr = new lldb::SBTarget(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTarget,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_FindTargetWithFileAndArch(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + lldb::SBTarget result; + + SWIG_check_num_args("lldb::SBDebugger::FindTargetWithFileAndArch",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::FindTargetWithFileAndArch",1,"lldb::SBDebugger *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBDebugger::FindTargetWithFileAndArch",2,"char const *"); + if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBDebugger::FindTargetWithFileAndArch",3,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_FindTargetWithFileAndArch",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (char *)lua_tostring(L, 3); + result = (arg1)->FindTargetWithFileAndArch((char const *)arg2,(char const *)arg3); + { + lldb::SBTarget * resultptr = new lldb::SBTarget(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTarget,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetNumTargets(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBDebugger::GetNumTargets",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetNumTargets",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetNumTargets",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = (uint32_t)(arg1)->GetNumTargets(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetSelectedTarget(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBTarget result; + + SWIG_check_num_args("lldb::SBDebugger::GetSelectedTarget",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetSelectedTarget",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetSelectedTarget",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = (arg1)->GetSelectedTarget(); + { + lldb::SBTarget * resultptr = new lldb::SBTarget(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTarget,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_SetSelectedTarget(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBTarget *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBDebugger::SetSelectedTarget",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetSelectedTarget",1,"lldb::SBDebugger *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBDebugger::SetSelectedTarget",2,"lldb::SBTarget &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_SetSelectedTarget",1,SWIGTYPE_p_lldb__SBDebugger); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBDebugger_SetSelectedTarget",2,SWIGTYPE_p_lldb__SBTarget); + } + + (arg1)->SetSelectedTarget(*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetSelectedPlatform(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBPlatform result; + + SWIG_check_num_args("lldb::SBDebugger::GetSelectedPlatform",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetSelectedPlatform",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetSelectedPlatform",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = (arg1)->GetSelectedPlatform(); + { + lldb::SBPlatform * resultptr = new lldb::SBPlatform(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBPlatform,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_SetSelectedPlatform(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBPlatform *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBDebugger::SetSelectedPlatform",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetSelectedPlatform",1,"lldb::SBDebugger *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBDebugger::SetSelectedPlatform",2,"lldb::SBPlatform &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_SetSelectedPlatform",1,SWIGTYPE_p_lldb__SBDebugger); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBPlatform,0))){ + SWIG_fail_ptr("SBDebugger_SetSelectedPlatform",2,SWIGTYPE_p_lldb__SBPlatform); + } + + (arg1)->SetSelectedPlatform(*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetNumPlatforms(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBDebugger::GetNumPlatforms",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetNumPlatforms",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetNumPlatforms",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = (uint32_t)(arg1)->GetNumPlatforms(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetPlatformAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + uint32_t arg2 ; + lldb::SBPlatform result; + + SWIG_check_num_args("lldb::SBDebugger::GetPlatformAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetPlatformAtIndex",1,"lldb::SBDebugger *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBDebugger::GetPlatformAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetPlatformAtIndex",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetPlatformAtIndex(arg2); + { + lldb::SBPlatform * resultptr = new lldb::SBPlatform(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBPlatform,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetNumAvailablePlatforms(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBDebugger::GetNumAvailablePlatforms",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetNumAvailablePlatforms",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetNumAvailablePlatforms",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = (uint32_t)(arg1)->GetNumAvailablePlatforms(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetAvailablePlatformInfoAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + uint32_t arg2 ; + lldb::SBStructuredData result; + + SWIG_check_num_args("lldb::SBDebugger::GetAvailablePlatformInfoAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetAvailablePlatformInfoAtIndex",1,"lldb::SBDebugger *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBDebugger::GetAvailablePlatformInfoAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetAvailablePlatformInfoAtIndex",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetAvailablePlatformInfoAtIndex(arg2); + { + lldb::SBStructuredData * resultptr = new lldb::SBStructuredData(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBStructuredData,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetSourceManager(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + SwigValueWrapper< lldb::SBSourceManager > result; + + SWIG_check_num_args("lldb::SBDebugger::GetSourceManager",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetSourceManager",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetSourceManager",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = (arg1)->GetSourceManager(); + { + lldb::SBSourceManager * resultptr = new lldb::SBSourceManager(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSourceManager,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_SetCurrentPlatform(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBDebugger::SetCurrentPlatform",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetCurrentPlatform",1,"lldb::SBDebugger *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBDebugger::SetCurrentPlatform",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_SetCurrentPlatform",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->SetCurrentPlatform((char const *)arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_SetCurrentPlatformSDKRoot(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + char *arg2 = (char *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBDebugger::SetCurrentPlatformSDKRoot",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetCurrentPlatformSDKRoot",1,"lldb::SBDebugger *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBDebugger::SetCurrentPlatformSDKRoot",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_SetCurrentPlatformSDKRoot",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (bool)(arg1)->SetCurrentPlatformSDKRoot((char const *)arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_SetUseExternalEditor(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + bool arg2 ; + bool result; + + SWIG_check_num_args("lldb::SBDebugger::SetUseExternalEditor",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetUseExternalEditor",1,"lldb::SBDebugger *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBDebugger::SetUseExternalEditor",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_SetUseExternalEditor",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (lua_toboolean(L, 2)!=0); + result = (bool)(arg1)->SetUseExternalEditor(arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetUseExternalEditor(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBDebugger::GetUseExternalEditor",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetUseExternalEditor",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetUseExternalEditor",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = (bool)(arg1)->GetUseExternalEditor(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_SetUseColor(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + bool arg2 ; + bool result; + + SWIG_check_num_args("lldb::SBDebugger::SetUseColor",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetUseColor",1,"lldb::SBDebugger *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBDebugger::SetUseColor",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_SetUseColor",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (lua_toboolean(L, 2)!=0); + result = (bool)(arg1)->SetUseColor(arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetUseColor(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBDebugger::GetUseColor",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetUseColor",1,"lldb::SBDebugger const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetUseColor",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = (bool)((lldb::SBDebugger const *)arg1)->GetUseColor(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_SetUseSourceCache(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + bool arg2 ; + bool result; + + SWIG_check_num_args("lldb::SBDebugger::SetUseSourceCache",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetUseSourceCache",1,"lldb::SBDebugger *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBDebugger::SetUseSourceCache",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_SetUseSourceCache",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (lua_toboolean(L, 2)!=0); + result = (bool)(arg1)->SetUseSourceCache(arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetUseSourceCache(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBDebugger::GetUseSourceCache",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetUseSourceCache",1,"lldb::SBDebugger const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetUseSourceCache",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = (bool)((lldb::SBDebugger const *)arg1)->GetUseSourceCache(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetDefaultArchitecture(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + size_t arg2 ; + bool result; + + SWIG_check_num_args("lldb::SBDebugger::GetDefaultArchitecture",2,2) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetDefaultArchitecture",1,"char *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBDebugger::GetDefaultArchitecture",2,"size_t"); + arg1 = (char *)lua_tostring(L, 1); + arg2 = (size_t)lua_tointeger(L, 2); + result = (bool)lldb::SBDebugger::GetDefaultArchitecture(arg1,SWIG_STD_MOVE(arg2)); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_SetDefaultArchitecture(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBDebugger::SetDefaultArchitecture",1,1) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetDefaultArchitecture",1,"char const *"); + arg1 = (char *)lua_tostring(L, 1); + result = (bool)lldb::SBDebugger::SetDefaultArchitecture((char const *)arg1); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetScriptingLanguage(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + char *arg2 = (char *) 0 ; + lldb::ScriptLanguage result; + + SWIG_check_num_args("lldb::SBDebugger::GetScriptingLanguage",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetScriptingLanguage",1,"lldb::SBDebugger *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBDebugger::GetScriptingLanguage",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetScriptingLanguage",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (lldb::ScriptLanguage)(arg1)->GetScriptingLanguage((char const *)arg2); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetScriptInterpreterInfo(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::ScriptLanguage arg2 ; + lldb::SBStructuredData result; + + SWIG_check_num_args("lldb::SBDebugger::GetScriptInterpreterInfo",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetScriptInterpreterInfo",1,"lldb::SBDebugger *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBDebugger::GetScriptInterpreterInfo",2,"lldb::ScriptLanguage"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetScriptInterpreterInfo",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (lldb::ScriptLanguage)lua_tointeger(L, 2); + result = (arg1)->GetScriptInterpreterInfo(arg2); + { + lldb::SBStructuredData * resultptr = new lldb::SBStructuredData(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBStructuredData,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetVersionString(lua_State* L) { + { + int SWIG_arg = 0; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBDebugger::GetVersionString",0,0) + result = (char *)lldb::SBDebugger::GetVersionString(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_StateAsCString(lua_State* L) { + { + int SWIG_arg = 0; + lldb::StateType arg1 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBDebugger::StateAsCString",1,1) + if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBDebugger::StateAsCString",1,"lldb::StateType"); + arg1 = (lldb::StateType)lua_tointeger(L, 1); + result = (char *)lldb::SBDebugger::StateAsCString(arg1); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetBuildConfiguration(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStructuredData result; + + SWIG_check_num_args("lldb::SBDebugger::GetBuildConfiguration",0,0) + result = lldb::SBDebugger::GetBuildConfiguration(); + { + lldb::SBStructuredData * resultptr = new lldb::SBStructuredData(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBStructuredData,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_StateIsRunningState(lua_State* L) { + { + int SWIG_arg = 0; + lldb::StateType arg1 ; + bool result; + + SWIG_check_num_args("lldb::SBDebugger::StateIsRunningState",1,1) + if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBDebugger::StateIsRunningState",1,"lldb::StateType"); + arg1 = (lldb::StateType)lua_tointeger(L, 1); + result = (bool)lldb::SBDebugger::StateIsRunningState(arg1); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_StateIsStoppedState(lua_State* L) { + { + int SWIG_arg = 0; + lldb::StateType arg1 ; + bool result; + + SWIG_check_num_args("lldb::SBDebugger::StateIsStoppedState",1,1) + if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBDebugger::StateIsStoppedState",1,"lldb::StateType"); + arg1 = (lldb::StateType)lua_tointeger(L, 1); + result = (bool)lldb::SBDebugger::StateIsStoppedState(arg1); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_EnableLog(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + char *arg2 = (char *) 0 ; + char **arg3 = (char **) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBDebugger::EnableLog",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::EnableLog",1,"lldb::SBDebugger *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBDebugger::EnableLog",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_EnableLog",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (char *)lua_tostring(L, 2); + { + if (lua_istable(L, 3)) { + size_t size = lua_rawlen(L, 3); + arg3 = (char **)malloc((size + 1) * sizeof(char *)); + int i = 0, j = 0; + while (i++ < size) { + lua_rawgeti(L, 3, i); + if (!lua_isstring(L, -1)) { + // if current element cannot be converted to string, raise an error + lua_pop(L, 1); + return luaL_error(L, "List should only contain strings"); + } + arg3[j++] = (char *)lua_tostring(L, -1); + lua_pop(L, 1); + } + arg3[j] = 0; + } else if (lua_isnil(L, 3)) { + // "nil" is also acceptable, equivalent as an empty table + arg3 = NULL; + } else { + return luaL_error(L, "A list of strings expected"); + } + } + result = (bool)(arg1)->EnableLog((char const *)arg2,(char const **)arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + { + free((char *) arg3); + } + return SWIG_arg; + + fail: SWIGUNUSED; + { + free((char *) arg3); + } + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_SetLoggingCallback(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::LogOutputCallback arg2 = (lldb::LogOutputCallback) 0 ; + void *arg3 = (void *) 0 ; + + SWIG_check_num_args("lldb::SBDebugger::SetLoggingCallback",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetLoggingCallback",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_SetLoggingCallback",1,SWIGTYPE_p_lldb__SBDebugger); + } + + { + arg2 = LLDBSwigLuaCallLuaLogOutputCallback; + arg3 = (void *)L; + + luaL_checktype(L, 2, LUA_TFUNCTION); + lua_settop(L, 2); + + lua_pushlightuserdata(L, (void *)&LLDBSwigLuaCallLuaLogOutputCallback); + lua_insert(L, 2); + lua_settable(L, LUA_REGISTRYINDEX); + } + (arg1)->SetLoggingCallback(arg2,arg3); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_SetDestroyCallback(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebuggerDestroyCallback arg2 = (lldb::SBDebuggerDestroyCallback) 0 ; + void *arg3 = (void *) 0 ; + + SWIG_check_num_args("lldb::SBDebugger::SetDestroyCallback",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetDestroyCallback",1,"lldb::SBDebugger *"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("lldb::SBDebugger::SetDestroyCallback",2,"lldb::SBDebuggerDestroyCallback"); + if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("lldb::SBDebugger::SetDestroyCallback",3,"void *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_SetDestroyCallback",1,SWIGTYPE_p_lldb__SBDebugger); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_f_unsigned_long_long_p_void__void,0))){ + SWIG_fail_ptr("SBDebugger_SetDestroyCallback",2,SWIGTYPE_p_f_unsigned_long_long_p_void__void); + } + + arg3=(void *)SWIG_MustGetPtr(L,3,0,0,3,"SBDebugger_SetDestroyCallback"); + (arg1)->SetDestroyCallback(arg2,arg3); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_AddDestroyCallback(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBDebuggerDestroyCallback arg2 = (lldb::SBDebuggerDestroyCallback) 0 ; + void *arg3 = (void *) 0 ; + lldb::callback_token_t result; + + SWIG_check_num_args("lldb::SBDebugger::AddDestroyCallback",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::AddDestroyCallback",1,"lldb::SBDebugger *"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("lldb::SBDebugger::AddDestroyCallback",2,"lldb::SBDebuggerDestroyCallback"); + if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("lldb::SBDebugger::AddDestroyCallback",3,"void *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_AddDestroyCallback",1,SWIGTYPE_p_lldb__SBDebugger); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_f_unsigned_long_long_p_void__void,0))){ + SWIG_fail_ptr("SBDebugger_AddDestroyCallback",2,SWIGTYPE_p_f_unsigned_long_long_p_void__void); + } + + arg3=(void *)SWIG_MustGetPtr(L,3,0,0,3,"SBDebugger_AddDestroyCallback"); + result = (lldb::callback_token_t)(arg1)->AddDestroyCallback(arg2,arg3); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_RemoveDestroyCallback(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::callback_token_t arg2 ; + bool result; + + SWIG_check_num_args("lldb::SBDebugger::RemoveDestroyCallback",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::RemoveDestroyCallback",1,"lldb::SBDebugger *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBDebugger::RemoveDestroyCallback",2,"lldb::callback_token_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_RemoveDestroyCallback",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (lldb::callback_token_t)lua_tointeger(L, 2); + result = (bool)(arg1)->RemoveDestroyCallback(arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_DispatchInput(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + void *arg2 = (void *) 0 ; + size_t arg3 ; + + SWIG_check_num_args("lldb::SBDebugger::DispatchInput",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::DispatchInput",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_DispatchInput",1,SWIGTYPE_p_lldb__SBDebugger); + } + + { + arg2 = (void *)luaL_checklstring(L, 2, &arg3); + } + (arg1)->DispatchInput((void const *)arg2,arg3); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_DispatchInputInterrupt(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + + SWIG_check_num_args("lldb::SBDebugger::DispatchInputInterrupt",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::DispatchInputInterrupt",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_DispatchInputInterrupt",1,SWIGTYPE_p_lldb__SBDebugger); + } + + (arg1)->DispatchInputInterrupt(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_DispatchInputEndOfFile(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + + SWIG_check_num_args("lldb::SBDebugger::DispatchInputEndOfFile",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::DispatchInputEndOfFile",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_DispatchInputEndOfFile",1,SWIGTYPE_p_lldb__SBDebugger); + } + + (arg1)->DispatchInputEndOfFile(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetInstanceName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBDebugger::GetInstanceName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetInstanceName",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetInstanceName",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = (char *)(arg1)->GetInstanceName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_FindDebuggerWithID(lua_State* L) { + { + int SWIG_arg = 0; + int arg1 ; + lldb::SBDebugger result; + + SWIG_check_num_args("lldb::SBDebugger::FindDebuggerWithID",1,1) + if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBDebugger::FindDebuggerWithID",1,"int"); + arg1 = (int)lua_tointeger(L, 1); + result = lldb::SBDebugger::FindDebuggerWithID(arg1); + { + lldb::SBDebugger * resultptr = new lldb::SBDebugger(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBDebugger,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_SetInternalVariable(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBDebugger::SetInternalVariable",3,3) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetInternalVariable",1,"char const *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBDebugger::SetInternalVariable",2,"char const *"); + if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBDebugger::SetInternalVariable",3,"char const *"); + arg1 = (char *)lua_tostring(L, 1); + arg2 = (char *)lua_tostring(L, 2); + arg3 = (char *)lua_tostring(L, 3); + result = lldb::SBDebugger::SetInternalVariable((char const *)arg1,(char const *)arg2,(char const *)arg3); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetInternalVariableValue(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBStringList result; + + SWIG_check_num_args("lldb::SBDebugger::GetInternalVariableValue",2,2) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetInternalVariableValue",1,"char const *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBDebugger::GetInternalVariableValue",2,"char const *"); + arg1 = (char *)lua_tostring(L, 1); + arg2 = (char *)lua_tostring(L, 2); + result = lldb::SBDebugger::GetInternalVariableValue((char const *)arg1,(char const *)arg2); + { + lldb::SBStringList * resultptr = new lldb::SBStringList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBStringList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBDebugger::GetDescription",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetDescription",1,"lldb::SBDebugger *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBDebugger::GetDescription",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetDescription",1,SWIGTYPE_p_lldb__SBDebugger); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBDebugger_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)(arg1)->GetDescription(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetTerminalWidth(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBDebugger::GetTerminalWidth",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetTerminalWidth",1,"lldb::SBDebugger const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetTerminalWidth",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = (uint32_t)((lldb::SBDebugger const *)arg1)->GetTerminalWidth(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_SetTerminalWidth(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + uint32_t arg2 ; + + SWIG_check_num_args("lldb::SBDebugger::SetTerminalWidth",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetTerminalWidth",1,"lldb::SBDebugger *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBDebugger::SetTerminalWidth",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_SetTerminalWidth",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + (arg1)->SetTerminalWidth(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::user_id_t result; + + SWIG_check_num_args("lldb::SBDebugger::GetID",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetID",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetID",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = (lldb::user_id_t)(arg1)->GetID(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetPrompt(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBDebugger::GetPrompt",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetPrompt",1,"lldb::SBDebugger const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetPrompt",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = (char *)((lldb::SBDebugger const *)arg1)->GetPrompt(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_SetPrompt(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBDebugger::SetPrompt",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetPrompt",1,"lldb::SBDebugger *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBDebugger::SetPrompt",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_SetPrompt",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetPrompt((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetReproducerPath(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBDebugger::GetReproducerPath",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetReproducerPath",1,"lldb::SBDebugger const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetReproducerPath",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = (char *)((lldb::SBDebugger const *)arg1)->GetReproducerPath(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetScriptLanguage(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::ScriptLanguage result; + + SWIG_check_num_args("lldb::SBDebugger::GetScriptLanguage",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetScriptLanguage",1,"lldb::SBDebugger const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetScriptLanguage",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = (lldb::ScriptLanguage)((lldb::SBDebugger const *)arg1)->GetScriptLanguage(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_SetScriptLanguage(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::ScriptLanguage arg2 ; + + SWIG_check_num_args("lldb::SBDebugger::SetScriptLanguage",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetScriptLanguage",1,"lldb::SBDebugger *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBDebugger::SetScriptLanguage",2,"lldb::ScriptLanguage"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_SetScriptLanguage",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (lldb::ScriptLanguage)lua_tointeger(L, 2); + (arg1)->SetScriptLanguage(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetREPLLanguage(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::LanguageType result; + + SWIG_check_num_args("lldb::SBDebugger::GetREPLLanguage",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetREPLLanguage",1,"lldb::SBDebugger const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetREPLLanguage",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = (lldb::LanguageType)((lldb::SBDebugger const *)arg1)->GetREPLLanguage(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_SetREPLLanguage(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::LanguageType arg2 ; + + SWIG_check_num_args("lldb::SBDebugger::SetREPLLanguage",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetREPLLanguage",1,"lldb::SBDebugger *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBDebugger::SetREPLLanguage",2,"lldb::LanguageType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_SetREPLLanguage",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (lldb::LanguageType)lua_tointeger(L, 2); + (arg1)->SetREPLLanguage(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetCloseInputOnEOF(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBDebugger::GetCloseInputOnEOF",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetCloseInputOnEOF",1,"lldb::SBDebugger const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetCloseInputOnEOF",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = (bool)((lldb::SBDebugger const *)arg1)->GetCloseInputOnEOF(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_SetCloseInputOnEOF(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBDebugger::SetCloseInputOnEOF",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::SetCloseInputOnEOF",1,"lldb::SBDebugger *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBDebugger::SetCloseInputOnEOF",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_SetCloseInputOnEOF",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetCloseInputOnEOF(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetCategory__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBTypeCategory result; + + SWIG_check_num_args("lldb::SBDebugger::GetCategory",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetCategory",1,"lldb::SBDebugger *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBDebugger::GetCategory",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetCategory",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->GetCategory((char const *)arg2); + { + lldb::SBTypeCategory * resultptr = new lldb::SBTypeCategory(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeCategory,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetCategory__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::LanguageType arg2 ; + lldb::SBTypeCategory result; + + SWIG_check_num_args("lldb::SBDebugger::GetCategory",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetCategory",1,"lldb::SBDebugger *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBDebugger::GetCategory",2,"lldb::LanguageType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetCategory",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (lldb::LanguageType)lua_tointeger(L, 2); + result = (arg1)->GetCategory(arg2); + { + lldb::SBTypeCategory * resultptr = new lldb::SBTypeCategory(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeCategory,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetCategory(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBDebugger, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_SBDebugger_GetCategory__SWIG_1(L); + } + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBDebugger, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + return _wrap_SBDebugger_GetCategory__SWIG_0(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBDebugger_CreateCategory(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBTypeCategory result; + + SWIG_check_num_args("lldb::SBDebugger::CreateCategory",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::CreateCategory",1,"lldb::SBDebugger *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBDebugger::CreateCategory",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_CreateCategory",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->CreateCategory((char const *)arg2); + { + lldb::SBTypeCategory * resultptr = new lldb::SBTypeCategory(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeCategory,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_DeleteCategory(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + char *arg2 = (char *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBDebugger::DeleteCategory",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::DeleteCategory",1,"lldb::SBDebugger *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBDebugger::DeleteCategory",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_DeleteCategory",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (bool)(arg1)->DeleteCategory((char const *)arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetNumCategories(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBDebugger::GetNumCategories",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetNumCategories",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetNumCategories",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = (uint32_t)(arg1)->GetNumCategories(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetCategoryAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + uint32_t arg2 ; + lldb::SBTypeCategory result; + + SWIG_check_num_args("lldb::SBDebugger::GetCategoryAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetCategoryAtIndex",1,"lldb::SBDebugger *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBDebugger::GetCategoryAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetCategoryAtIndex",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetCategoryAtIndex(arg2); + { + lldb::SBTypeCategory * resultptr = new lldb::SBTypeCategory(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeCategory,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetDefaultCategory(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBTypeCategory result; + + SWIG_check_num_args("lldb::SBDebugger::GetDefaultCategory",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetDefaultCategory",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetDefaultCategory",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = (arg1)->GetDefaultCategory(); + { + lldb::SBTypeCategory * resultptr = new lldb::SBTypeCategory(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeCategory,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetFormatForType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBTypeNameSpecifier arg2 ; + lldb::SBTypeNameSpecifier *argp2 ; + lldb::SBTypeFormat result; + + SWIG_check_num_args("lldb::SBDebugger::GetFormatForType",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetFormatForType",1,"lldb::SBDebugger *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBDebugger::GetFormatForType",2,"lldb::SBTypeNameSpecifier"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetFormatForType",1,SWIGTYPE_p_lldb__SBDebugger); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){ + SWIG_fail_ptr("SBDebugger_GetFormatForType",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier); + } + arg2 = *argp2; + + result = (arg1)->GetFormatForType(arg2); + { + lldb::SBTypeFormat * resultptr = new lldb::SBTypeFormat(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeFormat,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetSummaryForType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBTypeNameSpecifier arg2 ; + lldb::SBTypeNameSpecifier *argp2 ; + lldb::SBTypeSummary result; + + SWIG_check_num_args("lldb::SBDebugger::GetSummaryForType",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetSummaryForType",1,"lldb::SBDebugger *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBDebugger::GetSummaryForType",2,"lldb::SBTypeNameSpecifier"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetSummaryForType",1,SWIGTYPE_p_lldb__SBDebugger); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){ + SWIG_fail_ptr("SBDebugger_GetSummaryForType",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier); + } + arg2 = *argp2; + + result = (arg1)->GetSummaryForType(arg2); + { + lldb::SBTypeSummary * resultptr = new lldb::SBTypeSummary(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSummary,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetFilterForType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBTypeNameSpecifier arg2 ; + lldb::SBTypeNameSpecifier *argp2 ; + lldb::SBTypeFilter result; + + SWIG_check_num_args("lldb::SBDebugger::GetFilterForType",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetFilterForType",1,"lldb::SBDebugger *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBDebugger::GetFilterForType",2,"lldb::SBTypeNameSpecifier"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetFilterForType",1,SWIGTYPE_p_lldb__SBDebugger); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){ + SWIG_fail_ptr("SBDebugger_GetFilterForType",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier); + } + arg2 = *argp2; + + result = (arg1)->GetFilterForType(arg2); + { + lldb::SBTypeFilter * resultptr = new lldb::SBTypeFilter(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeFilter,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetSyntheticForType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBTypeNameSpecifier arg2 ; + lldb::SBTypeNameSpecifier *argp2 ; + lldb::SBTypeSynthetic result; + + SWIG_check_num_args("lldb::SBDebugger::GetSyntheticForType",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetSyntheticForType",1,"lldb::SBDebugger *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBDebugger::GetSyntheticForType",2,"lldb::SBTypeNameSpecifier"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetSyntheticForType",1,SWIGTYPE_p_lldb__SBDebugger); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){ + SWIG_fail_ptr("SBDebugger_GetSyntheticForType",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier); + } + arg2 = *argp2; + + result = (arg1)->GetSyntheticForType(arg2); + { + lldb::SBTypeSynthetic * resultptr = new lldb::SBTypeSynthetic(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSynthetic,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_RunCommandInterpreter(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + bool arg2 ; + bool arg3 ; + lldb::SBCommandInterpreterRunOptions *arg4 = 0 ; + int *arg5 = 0 ; + bool *arg6 = 0 ; + bool *arg7 = 0 ; + int temp5 ; + bool temp6 ; + bool temp7 ; + + SWIG_check_num_args("lldb::SBDebugger::RunCommandInterpreter",7,7) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::RunCommandInterpreter",1,"lldb::SBDebugger *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBDebugger::RunCommandInterpreter",2,"bool"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBDebugger::RunCommandInterpreter",3,"bool"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBDebugger::RunCommandInterpreter",4,"lldb::SBCommandInterpreterRunOptions &"); + if(!lua_isinteger(L,5)) SWIG_fail_arg("lldb::SBDebugger::RunCommandInterpreter",5,"int &"); + if(!lua_isboolean(L,6)) SWIG_fail_arg("lldb::SBDebugger::RunCommandInterpreter",6,"bool &"); + if(!lua_isboolean(L,7)) SWIG_fail_arg("lldb::SBDebugger::RunCommandInterpreter",7,"bool &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_RunCommandInterpreter",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (lua_toboolean(L, 2)!=0); + arg3 = (lua_toboolean(L, 3)!=0); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions,0))){ + SWIG_fail_ptr("SBDebugger_RunCommandInterpreter",4,SWIGTYPE_p_lldb__SBCommandInterpreterRunOptions); + } + + temp5 = (int)lua_tointeger(L,5); + arg5 = &temp5; + temp6 = (lua_toboolean(L,6)!=0); + arg6 = &temp6; + temp7 = (lua_toboolean(L,7)!=0); + arg7 = &temp7; + (arg1)->RunCommandInterpreter(arg2,arg3,*arg4,*arg5,*arg6,*arg7); + + lua_pushinteger(L, (lua_Integer) *arg5); SWIG_arg++; + lua_pushboolean(L, (int)((*arg6)!=0)); SWIG_arg++; + lua_pushboolean(L, (int)((*arg7)!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_RunREPL(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::LanguageType arg2 ; + char *arg3 = (char *) 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBDebugger::RunREPL",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::RunREPL",1,"lldb::SBDebugger *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBDebugger::RunREPL",2,"lldb::LanguageType"); + if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBDebugger::RunREPL",3,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_RunREPL",1,SWIGTYPE_p_lldb__SBDebugger); + } + + arg2 = (lldb::LanguageType)lua_tointeger(L, 2); + arg3 = (char *)lua_tostring(L, 3); + result = (arg1)->RunREPL(arg2,(char const *)arg3); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_LoadTraceFromFile(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + lldb::SBError *arg2 = 0 ; + lldb::SBFileSpec *arg3 = 0 ; + lldb::SBTrace result; + + SWIG_check_num_args("lldb::SBDebugger::LoadTraceFromFile",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::LoadTraceFromFile",1,"lldb::SBDebugger *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBDebugger::LoadTraceFromFile",2,"lldb::SBError &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBDebugger::LoadTraceFromFile",3,"lldb::SBFileSpec const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_LoadTraceFromFile",1,SWIGTYPE_p_lldb__SBDebugger); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBDebugger_LoadTraceFromFile",2,SWIGTYPE_p_lldb__SBError); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBDebugger_LoadTraceFromFile",3,SWIGTYPE_p_lldb__SBFileSpec); + } + + result = (arg1)->LoadTraceFromFile(*arg2,(lldb::SBFileSpec const &)*arg3); + { + lldb::SBTrace * resultptr = new lldb::SBTrace(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTrace,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBDebugger::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::__repr__",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger___tostring",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = lldb_SBDebugger___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetInputFileHandle(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + SwigValueWrapper< std::shared_ptr< lldb_private::File > > result; + + SWIG_check_num_args("lldb::SBDebugger::GetInputFileHandle",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetInputFileHandle",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetInputFileHandle",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = lldb_SBDebugger_GetInputFileHandle(arg1); + { + lldb::FileSP sp = result; + if (sp && sp->IsValid()) { + luaL_Stream *p = (luaL_Stream *)lua_newuserdata(L, sizeof(luaL_Stream)); + p->closef = &LLDBSwigLuaCloseFileHandle; + p->f = sp->GetStream(); + luaL_setmetatable(L, LUA_FILEHANDLE); + SWIG_arg++; + } + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetOutputFileHandle(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + SwigValueWrapper< std::shared_ptr< lldb_private::File > > result; + + SWIG_check_num_args("lldb::SBDebugger::GetOutputFileHandle",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetOutputFileHandle",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetOutputFileHandle",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = lldb_SBDebugger_GetOutputFileHandle(arg1); + { + lldb::FileSP sp = result; + if (sp && sp->IsValid()) { + luaL_Stream *p = (luaL_Stream *)lua_newuserdata(L, sizeof(luaL_Stream)); + p->closef = &LLDBSwigLuaCloseFileHandle; + p->f = sp->GetStream(); + luaL_setmetatable(L, LUA_FILEHANDLE); + SWIG_arg++; + } + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDebugger_GetErrorFileHandle(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = (lldb::SBDebugger *) 0 ; + SwigValueWrapper< std::shared_ptr< lldb_private::File > > result; + + SWIG_check_num_args("lldb::SBDebugger::GetErrorFileHandle",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDebugger::GetErrorFileHandle",1,"lldb::SBDebugger *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBDebugger_GetErrorFileHandle",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = lldb_SBDebugger_GetErrorFileHandle(arg1); + { + lldb::FileSP sp = result; + if (sp && sp->IsValid()) { + luaL_Stream *p = (luaL_Stream *)lua_newuserdata(L, sizeof(luaL_Stream)); + p->closef = &LLDBSwigLuaCloseFileHandle; + p->f = sp->GetStream(); + luaL_setmetatable(L, LUA_FILEHANDLE); + SWIG_arg++; + } + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBDebugger(void *obj) { +lldb::SBDebugger *arg1 = (lldb::SBDebugger *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBDebugger(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBDebugger); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBDebugger_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBDebugger_methods[]= { + { "GetBroadcaster", _wrap_SBDebugger_GetBroadcaster}, + { "IsValid", _wrap_SBDebugger_IsValid}, + { "Clear", _wrap_SBDebugger_Clear}, + { "GetSetting", _wrap_SBDebugger_GetSetting}, + { "SetAsync", _wrap_SBDebugger_SetAsync}, + { "GetAsync", _wrap_SBDebugger_GetAsync}, + { "SkipLLDBInitFiles", _wrap_SBDebugger_SkipLLDBInitFiles}, + { "SkipAppInitFiles", _wrap_SBDebugger_SkipAppInitFiles}, + { "SetInputString", _wrap_SBDebugger_SetInputString}, + { "SetInputFile", _wrap_SBDebugger_SetInputFile}, + { "SetOutputFile", _wrap_SBDebugger_SetOutputFile}, + { "SetErrorFile", _wrap_SBDebugger_SetErrorFile}, + { "GetInputFile", _wrap_SBDebugger_GetInputFile}, + { "GetOutputFile", _wrap_SBDebugger_GetOutputFile}, + { "GetErrorFile", _wrap_SBDebugger_GetErrorFile}, + { "SaveInputTerminalState", _wrap_SBDebugger_SaveInputTerminalState}, + { "RestoreInputTerminalState", _wrap_SBDebugger_RestoreInputTerminalState}, + { "GetCommandInterpreter", _wrap_SBDebugger_GetCommandInterpreter}, + { "HandleCommand", _wrap_SBDebugger_HandleCommand}, + { "RequestInterrupt", _wrap_SBDebugger_RequestInterrupt}, + { "CancelInterruptRequest", _wrap_SBDebugger_CancelInterruptRequest}, + { "InterruptRequested", _wrap_SBDebugger_InterruptRequested}, + { "GetListener", _wrap_SBDebugger_GetListener}, + { "HandleProcessEvent", _wrap_SBDebugger_HandleProcessEvent}, + { "CreateTargetWithFileAndTargetTriple", _wrap_SBDebugger_CreateTargetWithFileAndTargetTriple}, + { "CreateTargetWithFileAndArch", _wrap_SBDebugger_CreateTargetWithFileAndArch}, + { "CreateTarget", _wrap_SBDebugger_CreateTarget}, + { "GetDummyTarget", _wrap_SBDebugger_GetDummyTarget}, + { "DeleteTarget", _wrap_SBDebugger_DeleteTarget}, + { "GetTargetAtIndex", _wrap_SBDebugger_GetTargetAtIndex}, + { "GetIndexOfTarget", _wrap_SBDebugger_GetIndexOfTarget}, + { "FindTargetWithProcessID", _wrap_SBDebugger_FindTargetWithProcessID}, + { "FindTargetWithFileAndArch", _wrap_SBDebugger_FindTargetWithFileAndArch}, + { "GetNumTargets", _wrap_SBDebugger_GetNumTargets}, + { "GetSelectedTarget", _wrap_SBDebugger_GetSelectedTarget}, + { "SetSelectedTarget", _wrap_SBDebugger_SetSelectedTarget}, + { "GetSelectedPlatform", _wrap_SBDebugger_GetSelectedPlatform}, + { "SetSelectedPlatform", _wrap_SBDebugger_SetSelectedPlatform}, + { "GetNumPlatforms", _wrap_SBDebugger_GetNumPlatforms}, + { "GetPlatformAtIndex", _wrap_SBDebugger_GetPlatformAtIndex}, + { "GetNumAvailablePlatforms", _wrap_SBDebugger_GetNumAvailablePlatforms}, + { "GetAvailablePlatformInfoAtIndex", _wrap_SBDebugger_GetAvailablePlatformInfoAtIndex}, + { "GetSourceManager", _wrap_SBDebugger_GetSourceManager}, + { "SetCurrentPlatform", _wrap_SBDebugger_SetCurrentPlatform}, + { "SetCurrentPlatformSDKRoot", _wrap_SBDebugger_SetCurrentPlatformSDKRoot}, + { "SetUseExternalEditor", _wrap_SBDebugger_SetUseExternalEditor}, + { "GetUseExternalEditor", _wrap_SBDebugger_GetUseExternalEditor}, + { "SetUseColor", _wrap_SBDebugger_SetUseColor}, + { "GetUseColor", _wrap_SBDebugger_GetUseColor}, + { "SetUseSourceCache", _wrap_SBDebugger_SetUseSourceCache}, + { "GetUseSourceCache", _wrap_SBDebugger_GetUseSourceCache}, + { "GetScriptingLanguage", _wrap_SBDebugger_GetScriptingLanguage}, + { "GetScriptInterpreterInfo", _wrap_SBDebugger_GetScriptInterpreterInfo}, + { "EnableLog", _wrap_SBDebugger_EnableLog}, + { "SetLoggingCallback", _wrap_SBDebugger_SetLoggingCallback}, + { "SetDestroyCallback", _wrap_SBDebugger_SetDestroyCallback}, + { "AddDestroyCallback", _wrap_SBDebugger_AddDestroyCallback}, + { "RemoveDestroyCallback", _wrap_SBDebugger_RemoveDestroyCallback}, + { "DispatchInput", _wrap_SBDebugger_DispatchInput}, + { "DispatchInputInterrupt", _wrap_SBDebugger_DispatchInputInterrupt}, + { "DispatchInputEndOfFile", _wrap_SBDebugger_DispatchInputEndOfFile}, + { "GetInstanceName", _wrap_SBDebugger_GetInstanceName}, + { "GetDescription", _wrap_SBDebugger_GetDescription}, + { "GetTerminalWidth", _wrap_SBDebugger_GetTerminalWidth}, + { "SetTerminalWidth", _wrap_SBDebugger_SetTerminalWidth}, + { "GetID", _wrap_SBDebugger_GetID}, + { "GetPrompt", _wrap_SBDebugger_GetPrompt}, + { "SetPrompt", _wrap_SBDebugger_SetPrompt}, + { "GetReproducerPath", _wrap_SBDebugger_GetReproducerPath}, + { "GetScriptLanguage", _wrap_SBDebugger_GetScriptLanguage}, + { "SetScriptLanguage", _wrap_SBDebugger_SetScriptLanguage}, + { "GetREPLLanguage", _wrap_SBDebugger_GetREPLLanguage}, + { "SetREPLLanguage", _wrap_SBDebugger_SetREPLLanguage}, + { "GetCloseInputOnEOF", _wrap_SBDebugger_GetCloseInputOnEOF}, + { "SetCloseInputOnEOF", _wrap_SBDebugger_SetCloseInputOnEOF}, + { "GetCategory", _wrap_SBDebugger_GetCategory}, + { "CreateCategory", _wrap_SBDebugger_CreateCategory}, + { "DeleteCategory", _wrap_SBDebugger_DeleteCategory}, + { "GetNumCategories", _wrap_SBDebugger_GetNumCategories}, + { "GetCategoryAtIndex", _wrap_SBDebugger_GetCategoryAtIndex}, + { "GetDefaultCategory", _wrap_SBDebugger_GetDefaultCategory}, + { "GetFormatForType", _wrap_SBDebugger_GetFormatForType}, + { "GetSummaryForType", _wrap_SBDebugger_GetSummaryForType}, + { "GetFilterForType", _wrap_SBDebugger_GetFilterForType}, + { "GetSyntheticForType", _wrap_SBDebugger_GetSyntheticForType}, + { "RunCommandInterpreter", _wrap_SBDebugger_RunCommandInterpreter}, + { "RunREPL", _wrap_SBDebugger_RunREPL}, + { "LoadTraceFromFile", _wrap_SBDebugger_LoadTraceFromFile}, + { "__tostring", _wrap_SBDebugger___tostring}, + { "GetInputFileHandle", _wrap_SBDebugger_GetInputFileHandle}, + { "GetOutputFileHandle", _wrap_SBDebugger_GetOutputFileHandle}, + { "GetErrorFileHandle", _wrap_SBDebugger_GetErrorFileHandle}, + {0,0} +}; +static swig_lua_method swig_SBDebugger_meta[] = { + { "__tostring", _wrap_SBDebugger___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBDebugger_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBDebugger_Sf_SwigStatic_constants[]= { + {SWIG_LUA_CONSTTAB_INT("eBroadcastBitProgress", (lldb::SBDebugger::eBroadcastBitProgress))}, + {SWIG_LUA_CONSTTAB_INT("eBroadcastBitWarning", (lldb::SBDebugger::eBroadcastBitWarning))}, + {SWIG_LUA_CONSTTAB_INT("eBroadcastBitError", (lldb::SBDebugger::eBroadcastBitError))}, + {SWIG_LUA_CONSTTAB_INT("eBroadcastBitProgressCategory", (lldb::SBDebugger::eBroadcastBitProgressCategory))}, + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBDebugger_Sf_SwigStatic_methods[]= { + { "GetBroadcasterClass", _wrap_SBDebugger_GetBroadcasterClass}, + { "SupportsLanguage", _wrap_SBDebugger_SupportsLanguage}, + { "GetProgressFromEvent", _wrap_SBDebugger_GetProgressFromEvent}, + { "GetProgressDataFromEvent", _wrap_SBDebugger_GetProgressDataFromEvent}, + { "GetDiagnosticFromEvent", _wrap_SBDebugger_GetDiagnosticFromEvent}, + { "Initialize", _wrap_SBDebugger_Initialize}, + { "InitializeWithErrorHandling", _wrap_SBDebugger_InitializeWithErrorHandling}, + { "PrintStackTraceOnError", _wrap_SBDebugger_PrintStackTraceOnError}, + { "PrintDiagnosticsOnError", _wrap_SBDebugger_PrintDiagnosticsOnError}, + { "Terminate", _wrap_SBDebugger_Terminate}, + { "Create", _wrap_SBDebugger_Create}, + { "Destroy", _wrap_SBDebugger_Destroy}, + { "MemoryPressureDetected", _wrap_SBDebugger_MemoryPressureDetected}, + { "GetDefaultArchitecture", _wrap_SBDebugger_GetDefaultArchitecture}, + { "SetDefaultArchitecture", _wrap_SBDebugger_SetDefaultArchitecture}, + { "GetVersionString", _wrap_SBDebugger_GetVersionString}, + { "StateAsCString", _wrap_SBDebugger_StateAsCString}, + { "GetBuildConfiguration", _wrap_SBDebugger_GetBuildConfiguration}, + { "StateIsRunningState", _wrap_SBDebugger_StateIsRunningState}, + { "StateIsStoppedState", _wrap_SBDebugger_StateIsStoppedState}, + { "FindDebuggerWithID", _wrap_SBDebugger_FindDebuggerWithID}, + { "SetInternalVariable", _wrap_SBDebugger_SetInternalVariable}, + { "GetInternalVariableValue", _wrap_SBDebugger_GetInternalVariableValue}, + {0,0} +}; +static swig_lua_class* swig_SBDebugger_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBDebugger_Sf_SwigStatic = { + "SBDebugger", + swig_SBDebugger_Sf_SwigStatic_methods, + swig_SBDebugger_Sf_SwigStatic_attributes, + swig_SBDebugger_Sf_SwigStatic_constants, + swig_SBDebugger_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBDebugger_bases[] = {0}; +static const char *swig_SBDebugger_base_names[] = {0}; +static swig_lua_class _wrap_class_SBDebugger = { "SBDebugger", "SBDebugger", &SWIGTYPE_p_lldb__SBDebugger,_proxy__wrap_new_SBDebugger, swig_delete_SBDebugger, swig_SBDebugger_methods, swig_SBDebugger_attributes, &swig_SBDebugger_Sf_SwigStatic, swig_SBDebugger_meta, swig_SBDebugger_bases, swig_SBDebugger_base_names }; + +static int _wrap_new_SBDeclaration__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDeclaration *result = 0 ; + + SWIG_check_num_args("lldb::SBDeclaration::SBDeclaration",0,0) + result = (lldb::SBDeclaration *)new lldb::SBDeclaration(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBDeclaration,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBDeclaration__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDeclaration *arg1 = 0 ; + lldb::SBDeclaration *result = 0 ; + + SWIG_check_num_args("lldb::SBDeclaration::SBDeclaration",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBDeclaration::SBDeclaration",1,"lldb::SBDeclaration const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDeclaration,0))){ + SWIG_fail_ptr("new_SBDeclaration",1,SWIGTYPE_p_lldb__SBDeclaration); + } + + result = (lldb::SBDeclaration *)new lldb::SBDeclaration((lldb::SBDeclaration const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBDeclaration,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBDeclaration(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBDeclaration__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBDeclaration, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBDeclaration__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBDeclaration'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBDeclaration::SBDeclaration()\n" + " lldb::SBDeclaration::SBDeclaration(lldb::SBDeclaration const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBDeclaration_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDeclaration *arg1 = (lldb::SBDeclaration *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBDeclaration::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDeclaration::IsValid",1,"lldb::SBDeclaration const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDeclaration,0))){ + SWIG_fail_ptr("SBDeclaration_IsValid",1,SWIGTYPE_p_lldb__SBDeclaration); + } + + result = (bool)((lldb::SBDeclaration const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDeclaration_GetFileSpec(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDeclaration *arg1 = (lldb::SBDeclaration *) 0 ; + lldb::SBFileSpec result; + + SWIG_check_num_args("lldb::SBDeclaration::GetFileSpec",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDeclaration::GetFileSpec",1,"lldb::SBDeclaration const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDeclaration,0))){ + SWIG_fail_ptr("SBDeclaration_GetFileSpec",1,SWIGTYPE_p_lldb__SBDeclaration); + } + + result = ((lldb::SBDeclaration const *)arg1)->GetFileSpec(); + { + lldb::SBFileSpec * resultptr = new lldb::SBFileSpec(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDeclaration_GetLine(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDeclaration *arg1 = (lldb::SBDeclaration *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBDeclaration::GetLine",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDeclaration::GetLine",1,"lldb::SBDeclaration const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDeclaration,0))){ + SWIG_fail_ptr("SBDeclaration_GetLine",1,SWIGTYPE_p_lldb__SBDeclaration); + } + + result = (uint32_t)((lldb::SBDeclaration const *)arg1)->GetLine(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDeclaration_GetColumn(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDeclaration *arg1 = (lldb::SBDeclaration *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBDeclaration::GetColumn",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDeclaration::GetColumn",1,"lldb::SBDeclaration const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDeclaration,0))){ + SWIG_fail_ptr("SBDeclaration_GetColumn",1,SWIGTYPE_p_lldb__SBDeclaration); + } + + result = (uint32_t)((lldb::SBDeclaration const *)arg1)->GetColumn(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDeclaration_SetFileSpec(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDeclaration *arg1 = (lldb::SBDeclaration *) 0 ; + lldb::SBFileSpec arg2 ; + lldb::SBFileSpec *argp2 ; + + SWIG_check_num_args("lldb::SBDeclaration::SetFileSpec",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDeclaration::SetFileSpec",1,"lldb::SBDeclaration *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBDeclaration::SetFileSpec",2,"lldb::SBFileSpec"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDeclaration,0))){ + SWIG_fail_ptr("SBDeclaration_SetFileSpec",1,SWIGTYPE_p_lldb__SBDeclaration); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBDeclaration_SetFileSpec",2,SWIGTYPE_p_lldb__SBFileSpec); + } + arg2 = *argp2; + + (arg1)->SetFileSpec(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDeclaration_SetLine(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDeclaration *arg1 = (lldb::SBDeclaration *) 0 ; + uint32_t arg2 ; + + SWIG_check_num_args("lldb::SBDeclaration::SetLine",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDeclaration::SetLine",1,"lldb::SBDeclaration *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBDeclaration::SetLine",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDeclaration,0))){ + SWIG_fail_ptr("SBDeclaration_SetLine",1,SWIGTYPE_p_lldb__SBDeclaration); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + (arg1)->SetLine(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDeclaration_SetColumn(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDeclaration *arg1 = (lldb::SBDeclaration *) 0 ; + uint32_t arg2 ; + + SWIG_check_num_args("lldb::SBDeclaration::SetColumn",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDeclaration::SetColumn",1,"lldb::SBDeclaration *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBDeclaration::SetColumn",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDeclaration,0))){ + SWIG_fail_ptr("SBDeclaration_SetColumn",1,SWIGTYPE_p_lldb__SBDeclaration); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + (arg1)->SetColumn(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDeclaration___eq(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDeclaration *arg1 = (lldb::SBDeclaration *) 0 ; + lldb::SBDeclaration *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBDeclaration::operator ==",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDeclaration::operator ==",1,"lldb::SBDeclaration const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBDeclaration::operator ==",2,"lldb::SBDeclaration const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDeclaration,0))){ + SWIG_fail_ptr("SBDeclaration___eq",1,SWIGTYPE_p_lldb__SBDeclaration); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBDeclaration,0))){ + SWIG_fail_ptr("SBDeclaration___eq",2,SWIGTYPE_p_lldb__SBDeclaration); + } + + result = (bool)((lldb::SBDeclaration const *)arg1)->operator ==((lldb::SBDeclaration const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDeclaration_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDeclaration *arg1 = (lldb::SBDeclaration *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBDeclaration::GetDescription",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDeclaration::GetDescription",1,"lldb::SBDeclaration *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBDeclaration::GetDescription",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDeclaration,0))){ + SWIG_fail_ptr("SBDeclaration_GetDescription",1,SWIGTYPE_p_lldb__SBDeclaration); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBDeclaration_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)(arg1)->GetDescription(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBDeclaration___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDeclaration *arg1 = (lldb::SBDeclaration *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBDeclaration::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBDeclaration::__repr__",1,"lldb::SBDeclaration *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDeclaration,0))){ + SWIG_fail_ptr("SBDeclaration___tostring",1,SWIGTYPE_p_lldb__SBDeclaration); + } + + result = lldb_SBDeclaration___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBDeclaration(void *obj) { +lldb::SBDeclaration *arg1 = (lldb::SBDeclaration *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBDeclaration(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBDeclaration); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBDeclaration_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBDeclaration_methods[]= { + { "IsValid", _wrap_SBDeclaration_IsValid}, + { "GetFileSpec", _wrap_SBDeclaration_GetFileSpec}, + { "GetLine", _wrap_SBDeclaration_GetLine}, + { "GetColumn", _wrap_SBDeclaration_GetColumn}, + { "SetFileSpec", _wrap_SBDeclaration_SetFileSpec}, + { "SetLine", _wrap_SBDeclaration_SetLine}, + { "SetColumn", _wrap_SBDeclaration_SetColumn}, + { "__eq", _wrap_SBDeclaration___eq}, + { "GetDescription", _wrap_SBDeclaration_GetDescription}, + { "__tostring", _wrap_SBDeclaration___tostring}, + {0,0} +}; +static swig_lua_method swig_SBDeclaration_meta[] = { + { "__eq", _wrap_SBDeclaration___eq}, + { "__tostring", _wrap_SBDeclaration___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBDeclaration_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBDeclaration_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBDeclaration_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBDeclaration_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBDeclaration_Sf_SwigStatic = { + "SBDeclaration", + swig_SBDeclaration_Sf_SwigStatic_methods, + swig_SBDeclaration_Sf_SwigStatic_attributes, + swig_SBDeclaration_Sf_SwigStatic_constants, + swig_SBDeclaration_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBDeclaration_bases[] = {0}; +static const char *swig_SBDeclaration_base_names[] = {0}; +static swig_lua_class _wrap_class_SBDeclaration = { "SBDeclaration", "SBDeclaration", &SWIGTYPE_p_lldb__SBDeclaration,_proxy__wrap_new_SBDeclaration, swig_delete_SBDeclaration, swig_SBDeclaration_methods, swig_SBDeclaration_attributes, &swig_SBDeclaration_Sf_SwigStatic, swig_SBDeclaration_meta, swig_SBDeclaration_bases, swig_SBDeclaration_base_names }; + +static int _wrap_new_SBError__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBError *result = 0 ; + + SWIG_check_num_args("lldb::SBError::SBError",0,0) + result = (lldb::SBError *)new lldb::SBError(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBError__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBError *arg1 = 0 ; + lldb::SBError *result = 0 ; + + SWIG_check_num_args("lldb::SBError::SBError",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBError::SBError",1,"lldb::SBError const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("new_SBError",1,SWIGTYPE_p_lldb__SBError); + } + + result = (lldb::SBError *)new lldb::SBError((lldb::SBError const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBError__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + lldb::SBError *result = 0 ; + + SWIG_check_num_args("lldb::SBError::SBError",1,1) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBError::SBError",1,"char const *"); + arg1 = (char *)lua_tostring(L, 1); + result = (lldb::SBError *)new lldb::SBError((char const *)arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBError(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBError__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBError__SWIG_1(L); + } + } + if (argc == 1) { + int _v = 0; + { + _v = SWIG_lua_isnilstring(L,argv[0]); + } + if (_v) { + return _wrap_new_SBError__SWIG_2(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBError_GetCString(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBError *arg1 = (lldb::SBError *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBError::GetCString",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBError::GetCString",1,"lldb::SBError const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBError_GetCString",1,SWIGTYPE_p_lldb__SBError); + } + + result = (char *)((lldb::SBError const *)arg1)->GetCString(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBError_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBError *arg1 = (lldb::SBError *) 0 ; + + SWIG_check_num_args("lldb::SBError::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBError::Clear",1,"lldb::SBError *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBError_Clear",1,SWIGTYPE_p_lldb__SBError); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBError_Fail(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBError *arg1 = (lldb::SBError *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBError::Fail",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBError::Fail",1,"lldb::SBError const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBError_Fail",1,SWIGTYPE_p_lldb__SBError); + } + + result = (bool)((lldb::SBError const *)arg1)->Fail(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBError_Success(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBError *arg1 = (lldb::SBError *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBError::Success",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBError::Success",1,"lldb::SBError const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBError_Success",1,SWIGTYPE_p_lldb__SBError); + } + + result = (bool)((lldb::SBError const *)arg1)->Success(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBError_GetError(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBError *arg1 = (lldb::SBError *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBError::GetError",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBError::GetError",1,"lldb::SBError const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBError_GetError",1,SWIGTYPE_p_lldb__SBError); + } + + result = (uint32_t)((lldb::SBError const *)arg1)->GetError(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBError_GetType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBError *arg1 = (lldb::SBError *) 0 ; + lldb::ErrorType result; + + SWIG_check_num_args("lldb::SBError::GetType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBError::GetType",1,"lldb::SBError const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBError_GetType",1,SWIGTYPE_p_lldb__SBError); + } + + result = (lldb::ErrorType)((lldb::SBError const *)arg1)->GetType(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBError_SetError(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBError *arg1 = (lldb::SBError *) 0 ; + uint32_t arg2 ; + lldb::ErrorType arg3 ; + + SWIG_check_num_args("lldb::SBError::SetError",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBError::SetError",1,"lldb::SBError *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBError::SetError",2,"uint32_t"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBError::SetError",3,"lldb::ErrorType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBError_SetError",1,SWIGTYPE_p_lldb__SBError); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + arg3 = (lldb::ErrorType)lua_tointeger(L, 3); + (arg1)->SetError(arg2,arg3); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBError_SetErrorToErrno(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBError *arg1 = (lldb::SBError *) 0 ; + + SWIG_check_num_args("lldb::SBError::SetErrorToErrno",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBError::SetErrorToErrno",1,"lldb::SBError *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBError_SetErrorToErrno",1,SWIGTYPE_p_lldb__SBError); + } + + (arg1)->SetErrorToErrno(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBError_SetErrorToGenericError(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBError *arg1 = (lldb::SBError *) 0 ; + + SWIG_check_num_args("lldb::SBError::SetErrorToGenericError",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBError::SetErrorToGenericError",1,"lldb::SBError *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBError_SetErrorToGenericError",1,SWIGTYPE_p_lldb__SBError); + } + + (arg1)->SetErrorToGenericError(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBError_SetErrorString(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBError *arg1 = (lldb::SBError *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBError::SetErrorString",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBError::SetErrorString",1,"lldb::SBError *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBError::SetErrorString",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBError_SetErrorString",1,SWIGTYPE_p_lldb__SBError); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetErrorString((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBError_SetErrorStringWithFormat__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBError *arg1 = (lldb::SBError *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + char *arg4 = (char *) 0 ; + char *arg5 = (char *) 0 ; + int result; + + SWIG_check_num_args("lldb::SBError::SetErrorStringWithFormat",5,5) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBError::SetErrorStringWithFormat",1,"lldb::SBError *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBError::SetErrorStringWithFormat",2,"char const *"); + if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBError::SetErrorStringWithFormat",3,"char *"); + if(!SWIG_lua_isnilstring(L,4)) SWIG_fail_arg("lldb::SBError::SetErrorStringWithFormat",4,"char *"); + if(!SWIG_lua_isnilstring(L,5)) SWIG_fail_arg("lldb::SBError::SetErrorStringWithFormat",5,"char *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBError_SetErrorStringWithFormat",1,SWIGTYPE_p_lldb__SBError); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (char *)lua_tostring(L, 3); + arg4 = (char *)lua_tostring(L, 4); + arg5 = (char *)lua_tostring(L, 5); + result = (int)(arg1)->SetErrorStringWithFormat((char const *)arg2,arg3,arg4,arg5); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBError_SetErrorStringWithFormat__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBError *arg1 = (lldb::SBError *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + char *arg4 = (char *) 0 ; + int result; + + SWIG_check_num_args("lldb::SBError::SetErrorStringWithFormat",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBError::SetErrorStringWithFormat",1,"lldb::SBError *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBError::SetErrorStringWithFormat",2,"char const *"); + if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBError::SetErrorStringWithFormat",3,"char *"); + if(!SWIG_lua_isnilstring(L,4)) SWIG_fail_arg("lldb::SBError::SetErrorStringWithFormat",4,"char *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBError_SetErrorStringWithFormat",1,SWIGTYPE_p_lldb__SBError); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (char *)lua_tostring(L, 3); + arg4 = (char *)lua_tostring(L, 4); + result = (int)(arg1)->SetErrorStringWithFormat((char const *)arg2,arg3,arg4); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBError_SetErrorStringWithFormat__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBError *arg1 = (lldb::SBError *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + int result; + + SWIG_check_num_args("lldb::SBError::SetErrorStringWithFormat",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBError::SetErrorStringWithFormat",1,"lldb::SBError *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBError::SetErrorStringWithFormat",2,"char const *"); + if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBError::SetErrorStringWithFormat",3,"char *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBError_SetErrorStringWithFormat",1,SWIGTYPE_p_lldb__SBError); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (char *)lua_tostring(L, 3); + result = (int)(arg1)->SetErrorStringWithFormat((char const *)arg2,arg3); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBError_SetErrorStringWithFormat__SWIG_3(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBError *arg1 = (lldb::SBError *) 0 ; + char *arg2 = (char *) 0 ; + int result; + + SWIG_check_num_args("lldb::SBError::SetErrorStringWithFormat",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBError::SetErrorStringWithFormat",1,"lldb::SBError *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBError::SetErrorStringWithFormat",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBError_SetErrorStringWithFormat",1,SWIGTYPE_p_lldb__SBError); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (int)(arg1)->SetErrorStringWithFormat((char const *)arg2); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBError_SetErrorStringWithFormat(lua_State* L) { + int argc; + int argv[6]={ + 1,2,3,4,5,6 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBError, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + return _wrap_SBError_SetErrorStringWithFormat__SWIG_3(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBError, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[2]); + } + if (_v) { + return _wrap_SBError_SetErrorStringWithFormat__SWIG_2(L); + } + } + } + } + if (argc == 4) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBError, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[2]); + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[3]); + } + if (_v) { + return _wrap_SBError_SetErrorStringWithFormat__SWIG_1(L); + } + } + } + } + } + if (argc == 5) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBError, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[2]); + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[3]); + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[4]); + } + if (_v) { + return _wrap_SBError_SetErrorStringWithFormat__SWIG_0(L); + } + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBError_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBError *arg1 = (lldb::SBError *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBError::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBError::IsValid",1,"lldb::SBError const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBError_IsValid",1,SWIGTYPE_p_lldb__SBError); + } + + result = (bool)((lldb::SBError const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBError_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBError *arg1 = (lldb::SBError *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBError::GetDescription",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBError::GetDescription",1,"lldb::SBError *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBError::GetDescription",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBError_GetDescription",1,SWIGTYPE_p_lldb__SBError); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBError_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)(arg1)->GetDescription(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBError___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBError *arg1 = (lldb::SBError *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBError::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBError::__repr__",1,"lldb::SBError *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBError___tostring",1,SWIGTYPE_p_lldb__SBError); + } + + result = lldb_SBError___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBError(void *obj) { +lldb::SBError *arg1 = (lldb::SBError *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBError(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBError); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBError_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBError_methods[]= { + { "GetCString", _wrap_SBError_GetCString}, + { "Clear", _wrap_SBError_Clear}, + { "Fail", _wrap_SBError_Fail}, + { "Success", _wrap_SBError_Success}, + { "GetError", _wrap_SBError_GetError}, + { "GetType", _wrap_SBError_GetType}, + { "SetError", _wrap_SBError_SetError}, + { "SetErrorToErrno", _wrap_SBError_SetErrorToErrno}, + { "SetErrorToGenericError", _wrap_SBError_SetErrorToGenericError}, + { "SetErrorString", _wrap_SBError_SetErrorString}, + { "SetErrorStringWithFormat", _wrap_SBError_SetErrorStringWithFormat}, + { "IsValid", _wrap_SBError_IsValid}, + { "GetDescription", _wrap_SBError_GetDescription}, + { "__tostring", _wrap_SBError___tostring}, + {0,0} +}; +static swig_lua_method swig_SBError_meta[] = { + { "__tostring", _wrap_SBError___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBError_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBError_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBError_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBError_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBError_Sf_SwigStatic = { + "SBError", + swig_SBError_Sf_SwigStatic_methods, + swig_SBError_Sf_SwigStatic_attributes, + swig_SBError_Sf_SwigStatic_constants, + swig_SBError_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBError_bases[] = {0}; +static const char *swig_SBError_base_names[] = {0}; +static swig_lua_class _wrap_class_SBError = { "SBError", "SBError", &SWIGTYPE_p_lldb__SBError,_proxy__wrap_new_SBError, swig_delete_SBError, swig_SBError_methods, swig_SBError_attributes, &swig_SBError_Sf_SwigStatic, swig_SBError_meta, swig_SBError_bases, swig_SBError_base_names }; + +static int _wrap_new_SBEnvironment__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEnvironment *result = 0 ; + + SWIG_check_num_args("lldb::SBEnvironment::SBEnvironment",0,0) + result = (lldb::SBEnvironment *)new lldb::SBEnvironment(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBEnvironment,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBEnvironment__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEnvironment *arg1 = 0 ; + lldb::SBEnvironment *result = 0 ; + + SWIG_check_num_args("lldb::SBEnvironment::SBEnvironment",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBEnvironment::SBEnvironment",1,"lldb::SBEnvironment const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEnvironment,0))){ + SWIG_fail_ptr("new_SBEnvironment",1,SWIGTYPE_p_lldb__SBEnvironment); + } + + result = (lldb::SBEnvironment *)new lldb::SBEnvironment((lldb::SBEnvironment const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBEnvironment,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBEnvironment(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBEnvironment__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBEnvironment, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBEnvironment__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBEnvironment'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBEnvironment::SBEnvironment()\n" + " lldb::SBEnvironment::SBEnvironment(lldb::SBEnvironment const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBEnvironment_Get(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEnvironment *arg1 = (lldb::SBEnvironment *) 0 ; + char *arg2 = (char *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBEnvironment::Get",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEnvironment::Get",1,"lldb::SBEnvironment *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBEnvironment::Get",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEnvironment,0))){ + SWIG_fail_ptr("SBEnvironment_Get",1,SWIGTYPE_p_lldb__SBEnvironment); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (char *)(arg1)->Get((char const *)arg2); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBEnvironment_GetNumValues(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEnvironment *arg1 = (lldb::SBEnvironment *) 0 ; + size_t result; + + SWIG_check_num_args("lldb::SBEnvironment::GetNumValues",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEnvironment::GetNumValues",1,"lldb::SBEnvironment *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEnvironment,0))){ + SWIG_fail_ptr("SBEnvironment_GetNumValues",1,SWIGTYPE_p_lldb__SBEnvironment); + } + + result = (arg1)->GetNumValues(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBEnvironment_GetNameAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEnvironment *arg1 = (lldb::SBEnvironment *) 0 ; + size_t arg2 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBEnvironment::GetNameAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEnvironment::GetNameAtIndex",1,"lldb::SBEnvironment *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBEnvironment::GetNameAtIndex",2,"size_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEnvironment,0))){ + SWIG_fail_ptr("SBEnvironment_GetNameAtIndex",1,SWIGTYPE_p_lldb__SBEnvironment); + } + + arg2 = (size_t)lua_tointeger(L, 2); + result = (char *)(arg1)->GetNameAtIndex(arg2); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBEnvironment_GetValueAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEnvironment *arg1 = (lldb::SBEnvironment *) 0 ; + size_t arg2 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBEnvironment::GetValueAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEnvironment::GetValueAtIndex",1,"lldb::SBEnvironment *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBEnvironment::GetValueAtIndex",2,"size_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEnvironment,0))){ + SWIG_fail_ptr("SBEnvironment_GetValueAtIndex",1,SWIGTYPE_p_lldb__SBEnvironment); + } + + arg2 = (size_t)lua_tointeger(L, 2); + result = (char *)(arg1)->GetValueAtIndex(arg2); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBEnvironment_GetEntries(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEnvironment *arg1 = (lldb::SBEnvironment *) 0 ; + lldb::SBStringList result; + + SWIG_check_num_args("lldb::SBEnvironment::GetEntries",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEnvironment::GetEntries",1,"lldb::SBEnvironment *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEnvironment,0))){ + SWIG_fail_ptr("SBEnvironment_GetEntries",1,SWIGTYPE_p_lldb__SBEnvironment); + } + + result = (arg1)->GetEntries(); + { + lldb::SBStringList * resultptr = new lldb::SBStringList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBStringList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBEnvironment_PutEntry(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEnvironment *arg1 = (lldb::SBEnvironment *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBEnvironment::PutEntry",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEnvironment::PutEntry",1,"lldb::SBEnvironment *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBEnvironment::PutEntry",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEnvironment,0))){ + SWIG_fail_ptr("SBEnvironment_PutEntry",1,SWIGTYPE_p_lldb__SBEnvironment); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->PutEntry((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBEnvironment_SetEntries(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEnvironment *arg1 = (lldb::SBEnvironment *) 0 ; + lldb::SBStringList *arg2 = 0 ; + bool arg3 ; + + SWIG_check_num_args("lldb::SBEnvironment::SetEntries",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEnvironment::SetEntries",1,"lldb::SBEnvironment *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBEnvironment::SetEntries",2,"lldb::SBStringList const &"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBEnvironment::SetEntries",3,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEnvironment,0))){ + SWIG_fail_ptr("SBEnvironment_SetEntries",1,SWIGTYPE_p_lldb__SBEnvironment); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStringList,0))){ + SWIG_fail_ptr("SBEnvironment_SetEntries",2,SWIGTYPE_p_lldb__SBStringList); + } + + arg3 = (lua_toboolean(L, 3)!=0); + (arg1)->SetEntries((lldb::SBStringList const &)*arg2,arg3); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBEnvironment_Set(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEnvironment *arg1 = (lldb::SBEnvironment *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + bool arg4 ; + bool result; + + SWIG_check_num_args("lldb::SBEnvironment::Set",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEnvironment::Set",1,"lldb::SBEnvironment *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBEnvironment::Set",2,"char const *"); + if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBEnvironment::Set",3,"char const *"); + if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBEnvironment::Set",4,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEnvironment,0))){ + SWIG_fail_ptr("SBEnvironment_Set",1,SWIGTYPE_p_lldb__SBEnvironment); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (char *)lua_tostring(L, 3); + arg4 = (lua_toboolean(L, 4)!=0); + result = (bool)(arg1)->Set((char const *)arg2,(char const *)arg3,arg4); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBEnvironment_Unset(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEnvironment *arg1 = (lldb::SBEnvironment *) 0 ; + char *arg2 = (char *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBEnvironment::Unset",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEnvironment::Unset",1,"lldb::SBEnvironment *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBEnvironment::Unset",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEnvironment,0))){ + SWIG_fail_ptr("SBEnvironment_Unset",1,SWIGTYPE_p_lldb__SBEnvironment); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (bool)(arg1)->Unset((char const *)arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBEnvironment_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEnvironment *arg1 = (lldb::SBEnvironment *) 0 ; + + SWIG_check_num_args("lldb::SBEnvironment::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEnvironment::Clear",1,"lldb::SBEnvironment *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEnvironment,0))){ + SWIG_fail_ptr("SBEnvironment_Clear",1,SWIGTYPE_p_lldb__SBEnvironment); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBEnvironment(void *obj) { +lldb::SBEnvironment *arg1 = (lldb::SBEnvironment *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBEnvironment(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBEnvironment); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBEnvironment_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBEnvironment_methods[]= { + { "Get", _wrap_SBEnvironment_Get}, + { "GetNumValues", _wrap_SBEnvironment_GetNumValues}, + { "GetNameAtIndex", _wrap_SBEnvironment_GetNameAtIndex}, + { "GetValueAtIndex", _wrap_SBEnvironment_GetValueAtIndex}, + { "GetEntries", _wrap_SBEnvironment_GetEntries}, + { "PutEntry", _wrap_SBEnvironment_PutEntry}, + { "SetEntries", _wrap_SBEnvironment_SetEntries}, + { "Set", _wrap_SBEnvironment_Set}, + { "Unset", _wrap_SBEnvironment_Unset}, + { "Clear", _wrap_SBEnvironment_Clear}, + {0,0} +}; +static swig_lua_method swig_SBEnvironment_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBEnvironment_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBEnvironment_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBEnvironment_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBEnvironment_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBEnvironment_Sf_SwigStatic = { + "SBEnvironment", + swig_SBEnvironment_Sf_SwigStatic_methods, + swig_SBEnvironment_Sf_SwigStatic_attributes, + swig_SBEnvironment_Sf_SwigStatic_constants, + swig_SBEnvironment_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBEnvironment_bases[] = {0}; +static const char *swig_SBEnvironment_base_names[] = {0}; +static swig_lua_class _wrap_class_SBEnvironment = { "SBEnvironment", "SBEnvironment", &SWIGTYPE_p_lldb__SBEnvironment,_proxy__wrap_new_SBEnvironment, swig_delete_SBEnvironment, swig_SBEnvironment_methods, swig_SBEnvironment_attributes, &swig_SBEnvironment_Sf_SwigStatic, swig_SBEnvironment_meta, swig_SBEnvironment_bases, swig_SBEnvironment_base_names }; + +static int _wrap_new_SBEvent__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *result = 0 ; + + SWIG_check_num_args("lldb::SBEvent::SBEvent",0,0) + result = (lldb::SBEvent *)new lldb::SBEvent(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBEvent,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBEvent__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = 0 ; + lldb::SBEvent *result = 0 ; + + SWIG_check_num_args("lldb::SBEvent::SBEvent",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBEvent::SBEvent",1,"lldb::SBEvent const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("new_SBEvent",1,SWIGTYPE_p_lldb__SBEvent); + } + + result = (lldb::SBEvent *)new lldb::SBEvent((lldb::SBEvent const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBEvent,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBEvent__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + uint32_t arg1 ; + char *arg2 = (char *) 0 ; + uint32_t arg3 ; + lldb::SBEvent *result = 0 ; + + SWIG_check_num_args("lldb::SBEvent::SBEvent",2,2) + if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBEvent::SBEvent",1,"uint32_t"); + arg1 = (uint32_t)lua_tointeger(L, 1); + { + arg2 = (char *)luaL_checklstring(L, 2, (size_t *)&arg3); + } + result = (lldb::SBEvent *)new lldb::SBEvent(arg1,(char const *)arg2,arg3); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBEvent,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBEvent(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBEvent__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBEvent, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBEvent__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + _v = lua_isnumber(L,argv[0]); + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + if (argc <= 2) { + return _wrap_new_SBEvent__SWIG_2(L); + } + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + return _wrap_new_SBEvent__SWIG_2(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBEvent_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = (lldb::SBEvent *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBEvent::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEvent::IsValid",1,"lldb::SBEvent const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBEvent_IsValid",1,SWIGTYPE_p_lldb__SBEvent); + } + + result = (bool)((lldb::SBEvent const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBEvent_GetDataFlavor(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = (lldb::SBEvent *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBEvent::GetDataFlavor",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEvent::GetDataFlavor",1,"lldb::SBEvent *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBEvent_GetDataFlavor",1,SWIGTYPE_p_lldb__SBEvent); + } + + result = (char *)(arg1)->GetDataFlavor(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBEvent_GetType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = (lldb::SBEvent *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBEvent::GetType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEvent::GetType",1,"lldb::SBEvent const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBEvent_GetType",1,SWIGTYPE_p_lldb__SBEvent); + } + + result = (uint32_t)((lldb::SBEvent const *)arg1)->GetType(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBEvent_GetBroadcaster(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = (lldb::SBEvent *) 0 ; + lldb::SBBroadcaster result; + + SWIG_check_num_args("lldb::SBEvent::GetBroadcaster",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEvent::GetBroadcaster",1,"lldb::SBEvent const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBEvent_GetBroadcaster",1,SWIGTYPE_p_lldb__SBEvent); + } + + result = ((lldb::SBEvent const *)arg1)->GetBroadcaster(); + { + lldb::SBBroadcaster * resultptr = new lldb::SBBroadcaster(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBroadcaster,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBEvent_GetBroadcasterClass(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = (lldb::SBEvent *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBEvent::GetBroadcasterClass",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEvent::GetBroadcasterClass",1,"lldb::SBEvent const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBEvent_GetBroadcasterClass",1,SWIGTYPE_p_lldb__SBEvent); + } + + result = (char *)((lldb::SBEvent const *)arg1)->GetBroadcasterClass(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBEvent_BroadcasterMatchesRef(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = (lldb::SBEvent *) 0 ; + lldb::SBBroadcaster *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBEvent::BroadcasterMatchesRef",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEvent::BroadcasterMatchesRef",1,"lldb::SBEvent *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBEvent::BroadcasterMatchesRef",2,"lldb::SBBroadcaster const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBEvent_BroadcasterMatchesRef",1,SWIGTYPE_p_lldb__SBEvent); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBBroadcaster,0))){ + SWIG_fail_ptr("SBEvent_BroadcasterMatchesRef",2,SWIGTYPE_p_lldb__SBBroadcaster); + } + + result = (bool)(arg1)->BroadcasterMatchesRef((lldb::SBBroadcaster const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBEvent_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = (lldb::SBEvent *) 0 ; + + SWIG_check_num_args("lldb::SBEvent::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEvent::Clear",1,"lldb::SBEvent *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBEvent_Clear",1,SWIGTYPE_p_lldb__SBEvent); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBEvent_GetCStringFromEvent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBEvent::GetCStringFromEvent",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBEvent::GetCStringFromEvent",1,"lldb::SBEvent const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBEvent_GetCStringFromEvent",1,SWIGTYPE_p_lldb__SBEvent); + } + + result = (char *)lldb::SBEvent::GetCStringFromEvent((lldb::SBEvent const &)*arg1); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBEvent_GetDescription__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = (lldb::SBEvent *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBEvent::GetDescription",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEvent::GetDescription",1,"lldb::SBEvent *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBEvent::GetDescription",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBEvent_GetDescription",1,SWIGTYPE_p_lldb__SBEvent); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBEvent_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)(arg1)->GetDescription(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBEvent_GetDescription__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = (lldb::SBEvent *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBEvent::GetDescription",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBEvent::GetDescription",1,"lldb::SBEvent const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBEvent::GetDescription",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBEvent_GetDescription",1,SWIGTYPE_p_lldb__SBEvent); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBEvent_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)((lldb::SBEvent const *)arg1)->GetDescription(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBEvent_GetDescription(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBEvent, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBEvent_GetDescription__SWIG_0(L); + } + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBEvent, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBEvent_GetDescription__SWIG_1(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static void swig_delete_SBEvent(void *obj) { +lldb::SBEvent *arg1 = (lldb::SBEvent *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBEvent(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBEvent); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBEvent_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBEvent_methods[]= { + { "IsValid", _wrap_SBEvent_IsValid}, + { "GetDataFlavor", _wrap_SBEvent_GetDataFlavor}, + { "GetType", _wrap_SBEvent_GetType}, + { "GetBroadcaster", _wrap_SBEvent_GetBroadcaster}, + { "GetBroadcasterClass", _wrap_SBEvent_GetBroadcasterClass}, + { "BroadcasterMatchesRef", _wrap_SBEvent_BroadcasterMatchesRef}, + { "Clear", _wrap_SBEvent_Clear}, + { "GetDescription", _wrap_SBEvent_GetDescription}, + {0,0} +}; +static swig_lua_method swig_SBEvent_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBEvent_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBEvent_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBEvent_Sf_SwigStatic_methods[]= { + { "GetCStringFromEvent", _wrap_SBEvent_GetCStringFromEvent}, + {0,0} +}; +static swig_lua_class* swig_SBEvent_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBEvent_Sf_SwigStatic = { + "SBEvent", + swig_SBEvent_Sf_SwigStatic_methods, + swig_SBEvent_Sf_SwigStatic_attributes, + swig_SBEvent_Sf_SwigStatic_constants, + swig_SBEvent_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBEvent_bases[] = {0}; +static const char *swig_SBEvent_base_names[] = {0}; +static swig_lua_class _wrap_class_SBEvent = { "SBEvent", "SBEvent", &SWIGTYPE_p_lldb__SBEvent,_proxy__wrap_new_SBEvent, swig_delete_SBEvent, swig_SBEvent_methods, swig_SBEvent_attributes, &swig_SBEvent_Sf_SwigStatic, swig_SBEvent_meta, swig_SBEvent_bases, swig_SBEvent_base_names }; + +static int _wrap_new_SBExecutionContext__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExecutionContext *result = 0 ; + + SWIG_check_num_args("lldb::SBExecutionContext::SBExecutionContext",0,0) + result = (lldb::SBExecutionContext *)new lldb::SBExecutionContext(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBExecutionContext,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBExecutionContext__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExecutionContext *arg1 = 0 ; + lldb::SBExecutionContext *result = 0 ; + + SWIG_check_num_args("lldb::SBExecutionContext::SBExecutionContext",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBExecutionContext::SBExecutionContext",1,"lldb::SBExecutionContext const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExecutionContext,0))){ + SWIG_fail_ptr("new_SBExecutionContext",1,SWIGTYPE_p_lldb__SBExecutionContext); + } + + result = (lldb::SBExecutionContext *)new lldb::SBExecutionContext((lldb::SBExecutionContext const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBExecutionContext,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBExecutionContext__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = 0 ; + lldb::SBExecutionContext *result = 0 ; + + SWIG_check_num_args("lldb::SBExecutionContext::SBExecutionContext",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBExecutionContext::SBExecutionContext",1,"lldb::SBTarget const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("new_SBExecutionContext",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = (lldb::SBExecutionContext *)new lldb::SBExecutionContext((lldb::SBTarget const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBExecutionContext,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBExecutionContext__SWIG_3(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = 0 ; + lldb::SBExecutionContext *result = 0 ; + + SWIG_check_num_args("lldb::SBExecutionContext::SBExecutionContext",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBExecutionContext::SBExecutionContext",1,"lldb::SBProcess const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("new_SBExecutionContext",1,SWIGTYPE_p_lldb__SBProcess); + } + + result = (lldb::SBExecutionContext *)new lldb::SBExecutionContext((lldb::SBProcess const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBExecutionContext,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBExecutionContext__SWIG_4(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread arg1 ; + lldb::SBThread *argp1 ; + lldb::SBExecutionContext *result = 0 ; + + SWIG_check_num_args("lldb::SBExecutionContext::SBExecutionContext",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBExecutionContext::SBExecutionContext",1,"lldb::SBThread"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&argp1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("new_SBExecutionContext",1,SWIGTYPE_p_lldb__SBThread); + } + arg1 = *argp1; + + result = (lldb::SBExecutionContext *)new lldb::SBExecutionContext(arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBExecutionContext,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBExecutionContext__SWIG_5(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = 0 ; + lldb::SBExecutionContext *result = 0 ; + + SWIG_check_num_args("lldb::SBExecutionContext::SBExecutionContext",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBExecutionContext::SBExecutionContext",1,"lldb::SBFrame const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("new_SBExecutionContext",1,SWIGTYPE_p_lldb__SBFrame); + } + + result = (lldb::SBExecutionContext *)new lldb::SBExecutionContext((lldb::SBFrame const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBExecutionContext,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBExecutionContext(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBExecutionContext__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExecutionContext, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBExecutionContext__SWIG_1(L); + } + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBExecutionContext__SWIG_2(L); + } + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBExecutionContext__SWIG_3(L); + } + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBExecutionContext__SWIG_4(L); + } + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBExecutionContext__SWIG_5(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBExecutionContext_GetTarget(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExecutionContext *arg1 = (lldb::SBExecutionContext *) 0 ; + lldb::SBTarget result; + + SWIG_check_num_args("lldb::SBExecutionContext::GetTarget",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExecutionContext::GetTarget",1,"lldb::SBExecutionContext const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExecutionContext,0))){ + SWIG_fail_ptr("SBExecutionContext_GetTarget",1,SWIGTYPE_p_lldb__SBExecutionContext); + } + + result = ((lldb::SBExecutionContext const *)arg1)->GetTarget(); + { + lldb::SBTarget * resultptr = new lldb::SBTarget(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTarget,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExecutionContext_GetProcess(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExecutionContext *arg1 = (lldb::SBExecutionContext *) 0 ; + lldb::SBProcess result; + + SWIG_check_num_args("lldb::SBExecutionContext::GetProcess",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExecutionContext::GetProcess",1,"lldb::SBExecutionContext const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExecutionContext,0))){ + SWIG_fail_ptr("SBExecutionContext_GetProcess",1,SWIGTYPE_p_lldb__SBExecutionContext); + } + + result = ((lldb::SBExecutionContext const *)arg1)->GetProcess(); + { + lldb::SBProcess * resultptr = new lldb::SBProcess(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExecutionContext_GetThread(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExecutionContext *arg1 = (lldb::SBExecutionContext *) 0 ; + lldb::SBThread result; + + SWIG_check_num_args("lldb::SBExecutionContext::GetThread",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExecutionContext::GetThread",1,"lldb::SBExecutionContext const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExecutionContext,0))){ + SWIG_fail_ptr("SBExecutionContext_GetThread",1,SWIGTYPE_p_lldb__SBExecutionContext); + } + + result = ((lldb::SBExecutionContext const *)arg1)->GetThread(); + { + lldb::SBThread * resultptr = new lldb::SBThread(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThread,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExecutionContext_GetFrame(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExecutionContext *arg1 = (lldb::SBExecutionContext *) 0 ; + lldb::SBFrame result; + + SWIG_check_num_args("lldb::SBExecutionContext::GetFrame",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExecutionContext::GetFrame",1,"lldb::SBExecutionContext const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExecutionContext,0))){ + SWIG_fail_ptr("SBExecutionContext_GetFrame",1,SWIGTYPE_p_lldb__SBExecutionContext); + } + + result = ((lldb::SBExecutionContext const *)arg1)->GetFrame(); + { + lldb::SBFrame * resultptr = new lldb::SBFrame(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFrame,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBExecutionContext(void *obj) { +lldb::SBExecutionContext *arg1 = (lldb::SBExecutionContext *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBExecutionContext(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBExecutionContext); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBExecutionContext_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBExecutionContext_methods[]= { + { "GetTarget", _wrap_SBExecutionContext_GetTarget}, + { "GetProcess", _wrap_SBExecutionContext_GetProcess}, + { "GetThread", _wrap_SBExecutionContext_GetThread}, + { "GetFrame", _wrap_SBExecutionContext_GetFrame}, + {0,0} +}; +static swig_lua_method swig_SBExecutionContext_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBExecutionContext_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBExecutionContext_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBExecutionContext_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBExecutionContext_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBExecutionContext_Sf_SwigStatic = { + "SBExecutionContext", + swig_SBExecutionContext_Sf_SwigStatic_methods, + swig_SBExecutionContext_Sf_SwigStatic_attributes, + swig_SBExecutionContext_Sf_SwigStatic_constants, + swig_SBExecutionContext_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBExecutionContext_bases[] = {0}; +static const char *swig_SBExecutionContext_base_names[] = {0}; +static swig_lua_class _wrap_class_SBExecutionContext = { "SBExecutionContext", "SBExecutionContext", &SWIGTYPE_p_lldb__SBExecutionContext,_proxy__wrap_new_SBExecutionContext, swig_delete_SBExecutionContext, swig_SBExecutionContext_methods, swig_SBExecutionContext_attributes, &swig_SBExecutionContext_Sf_SwigStatic, swig_SBExecutionContext_meta, swig_SBExecutionContext_bases, swig_SBExecutionContext_base_names }; + +static int _wrap_new_SBExpressionOptions__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *result = 0 ; + + SWIG_check_num_args("lldb::SBExpressionOptions::SBExpressionOptions",0,0) + result = (lldb::SBExpressionOptions *)new lldb::SBExpressionOptions(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBExpressionOptions,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBExpressionOptions__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = 0 ; + lldb::SBExpressionOptions *result = 0 ; + + SWIG_check_num_args("lldb::SBExpressionOptions::SBExpressionOptions",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SBExpressionOptions",1,"lldb::SBExpressionOptions const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("new_SBExpressionOptions",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + result = (lldb::SBExpressionOptions *)new lldb::SBExpressionOptions((lldb::SBExpressionOptions const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBExpressionOptions,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBExpressionOptions(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBExpressionOptions__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBExpressionOptions__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBExpressionOptions'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBExpressionOptions::SBExpressionOptions()\n" + " lldb::SBExpressionOptions::SBExpressionOptions(lldb::SBExpressionOptions const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBExpressionOptions_GetCoerceResultToId(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBExpressionOptions::GetCoerceResultToId",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::GetCoerceResultToId",1,"lldb::SBExpressionOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_GetCoerceResultToId",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + result = (bool)((lldb::SBExpressionOptions const *)arg1)->GetCoerceResultToId(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetCoerceResultToId__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBExpressionOptions::SetCoerceResultToId",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetCoerceResultToId",1,"lldb::SBExpressionOptions *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBExpressionOptions::SetCoerceResultToId",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_SetCoerceResultToId",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetCoerceResultToId(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetCoerceResultToId__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + + SWIG_check_num_args("lldb::SBExpressionOptions::SetCoerceResultToId",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetCoerceResultToId",1,"lldb::SBExpressionOptions *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_SetCoerceResultToId",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + (arg1)->SetCoerceResultToId(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetCoerceResultToId(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBExpressionOptions_SetCoerceResultToId__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[1]); + } + if (_v) { + return _wrap_SBExpressionOptions_SetCoerceResultToId__SWIG_0(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBExpressionOptions_SetCoerceResultToId'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBExpressionOptions::SetCoerceResultToId(bool)\n" + " lldb::SBExpressionOptions::SetCoerceResultToId()\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBExpressionOptions_GetUnwindOnError(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBExpressionOptions::GetUnwindOnError",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::GetUnwindOnError",1,"lldb::SBExpressionOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_GetUnwindOnError",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + result = (bool)((lldb::SBExpressionOptions const *)arg1)->GetUnwindOnError(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetUnwindOnError__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBExpressionOptions::SetUnwindOnError",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetUnwindOnError",1,"lldb::SBExpressionOptions *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBExpressionOptions::SetUnwindOnError",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_SetUnwindOnError",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetUnwindOnError(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetUnwindOnError__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + + SWIG_check_num_args("lldb::SBExpressionOptions::SetUnwindOnError",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetUnwindOnError",1,"lldb::SBExpressionOptions *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_SetUnwindOnError",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + (arg1)->SetUnwindOnError(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetUnwindOnError(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBExpressionOptions_SetUnwindOnError__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[1]); + } + if (_v) { + return _wrap_SBExpressionOptions_SetUnwindOnError__SWIG_0(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBExpressionOptions_SetUnwindOnError'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBExpressionOptions::SetUnwindOnError(bool)\n" + " lldb::SBExpressionOptions::SetUnwindOnError()\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBExpressionOptions_GetIgnoreBreakpoints(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBExpressionOptions::GetIgnoreBreakpoints",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::GetIgnoreBreakpoints",1,"lldb::SBExpressionOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_GetIgnoreBreakpoints",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + result = (bool)((lldb::SBExpressionOptions const *)arg1)->GetIgnoreBreakpoints(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetIgnoreBreakpoints__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBExpressionOptions::SetIgnoreBreakpoints",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetIgnoreBreakpoints",1,"lldb::SBExpressionOptions *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBExpressionOptions::SetIgnoreBreakpoints",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_SetIgnoreBreakpoints",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetIgnoreBreakpoints(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetIgnoreBreakpoints__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + + SWIG_check_num_args("lldb::SBExpressionOptions::SetIgnoreBreakpoints",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetIgnoreBreakpoints",1,"lldb::SBExpressionOptions *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_SetIgnoreBreakpoints",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + (arg1)->SetIgnoreBreakpoints(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetIgnoreBreakpoints(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBExpressionOptions_SetIgnoreBreakpoints__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[1]); + } + if (_v) { + return _wrap_SBExpressionOptions_SetIgnoreBreakpoints__SWIG_0(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBExpressionOptions_SetIgnoreBreakpoints'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBExpressionOptions::SetIgnoreBreakpoints(bool)\n" + " lldb::SBExpressionOptions::SetIgnoreBreakpoints()\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBExpressionOptions_GetFetchDynamicValue(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::DynamicValueType result; + + SWIG_check_num_args("lldb::SBExpressionOptions::GetFetchDynamicValue",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::GetFetchDynamicValue",1,"lldb::SBExpressionOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_GetFetchDynamicValue",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + result = (lldb::DynamicValueType)((lldb::SBExpressionOptions const *)arg1)->GetFetchDynamicValue(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetFetchDynamicValue__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::DynamicValueType arg2 ; + + SWIG_check_num_args("lldb::SBExpressionOptions::SetFetchDynamicValue",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetFetchDynamicValue",1,"lldb::SBExpressionOptions *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBExpressionOptions::SetFetchDynamicValue",2,"lldb::DynamicValueType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_SetFetchDynamicValue",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + arg2 = (lldb::DynamicValueType)lua_tointeger(L, 2); + (arg1)->SetFetchDynamicValue(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetFetchDynamicValue__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + + SWIG_check_num_args("lldb::SBExpressionOptions::SetFetchDynamicValue",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetFetchDynamicValue",1,"lldb::SBExpressionOptions *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_SetFetchDynamicValue",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + (arg1)->SetFetchDynamicValue(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetFetchDynamicValue(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBExpressionOptions_SetFetchDynamicValue__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_SBExpressionOptions_SetFetchDynamicValue__SWIG_0(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBExpressionOptions_SetFetchDynamicValue'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBExpressionOptions::SetFetchDynamicValue(lldb::DynamicValueType)\n" + " lldb::SBExpressionOptions::SetFetchDynamicValue()\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBExpressionOptions_GetTimeoutInMicroSeconds(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBExpressionOptions::GetTimeoutInMicroSeconds",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::GetTimeoutInMicroSeconds",1,"lldb::SBExpressionOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_GetTimeoutInMicroSeconds",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + result = (uint32_t)((lldb::SBExpressionOptions const *)arg1)->GetTimeoutInMicroSeconds(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetTimeoutInMicroSeconds__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + uint32_t arg2 ; + + SWIG_check_num_args("lldb::SBExpressionOptions::SetTimeoutInMicroSeconds",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetTimeoutInMicroSeconds",1,"lldb::SBExpressionOptions *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBExpressionOptions::SetTimeoutInMicroSeconds",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_SetTimeoutInMicroSeconds",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + (arg1)->SetTimeoutInMicroSeconds(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetTimeoutInMicroSeconds__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + + SWIG_check_num_args("lldb::SBExpressionOptions::SetTimeoutInMicroSeconds",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetTimeoutInMicroSeconds",1,"lldb::SBExpressionOptions *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_SetTimeoutInMicroSeconds",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + (arg1)->SetTimeoutInMicroSeconds(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetTimeoutInMicroSeconds(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBExpressionOptions_SetTimeoutInMicroSeconds__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_SBExpressionOptions_SetTimeoutInMicroSeconds__SWIG_0(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBExpressionOptions_SetTimeoutInMicroSeconds'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBExpressionOptions::SetTimeoutInMicroSeconds(uint32_t)\n" + " lldb::SBExpressionOptions::SetTimeoutInMicroSeconds()\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBExpressionOptions_GetOneThreadTimeoutInMicroSeconds(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBExpressionOptions::GetOneThreadTimeoutInMicroSeconds",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::GetOneThreadTimeoutInMicroSeconds",1,"lldb::SBExpressionOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_GetOneThreadTimeoutInMicroSeconds",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + result = (uint32_t)((lldb::SBExpressionOptions const *)arg1)->GetOneThreadTimeoutInMicroSeconds(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + uint32_t arg2 ; + + SWIG_check_num_args("lldb::SBExpressionOptions::SetOneThreadTimeoutInMicroSeconds",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetOneThreadTimeoutInMicroSeconds",1,"lldb::SBExpressionOptions *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBExpressionOptions::SetOneThreadTimeoutInMicroSeconds",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + (arg1)->SetOneThreadTimeoutInMicroSeconds(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + + SWIG_check_num_args("lldb::SBExpressionOptions::SetOneThreadTimeoutInMicroSeconds",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetOneThreadTimeoutInMicroSeconds",1,"lldb::SBExpressionOptions *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + (arg1)->SetOneThreadTimeoutInMicroSeconds(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds__SWIG_0(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBExpressionOptions::SetOneThreadTimeoutInMicroSeconds(uint32_t)\n" + " lldb::SBExpressionOptions::SetOneThreadTimeoutInMicroSeconds()\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBExpressionOptions_GetTryAllThreads(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBExpressionOptions::GetTryAllThreads",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::GetTryAllThreads",1,"lldb::SBExpressionOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_GetTryAllThreads",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + result = (bool)((lldb::SBExpressionOptions const *)arg1)->GetTryAllThreads(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetTryAllThreads__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBExpressionOptions::SetTryAllThreads",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetTryAllThreads",1,"lldb::SBExpressionOptions *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBExpressionOptions::SetTryAllThreads",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_SetTryAllThreads",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetTryAllThreads(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetTryAllThreads__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + + SWIG_check_num_args("lldb::SBExpressionOptions::SetTryAllThreads",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetTryAllThreads",1,"lldb::SBExpressionOptions *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_SetTryAllThreads",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + (arg1)->SetTryAllThreads(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetTryAllThreads(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBExpressionOptions_SetTryAllThreads__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[1]); + } + if (_v) { + return _wrap_SBExpressionOptions_SetTryAllThreads__SWIG_0(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBExpressionOptions_SetTryAllThreads'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBExpressionOptions::SetTryAllThreads(bool)\n" + " lldb::SBExpressionOptions::SetTryAllThreads()\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBExpressionOptions_GetStopOthers(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBExpressionOptions::GetStopOthers",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::GetStopOthers",1,"lldb::SBExpressionOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_GetStopOthers",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + result = (bool)((lldb::SBExpressionOptions const *)arg1)->GetStopOthers(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetStopOthers__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBExpressionOptions::SetStopOthers",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetStopOthers",1,"lldb::SBExpressionOptions *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBExpressionOptions::SetStopOthers",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_SetStopOthers",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetStopOthers(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetStopOthers__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + + SWIG_check_num_args("lldb::SBExpressionOptions::SetStopOthers",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetStopOthers",1,"lldb::SBExpressionOptions *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_SetStopOthers",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + (arg1)->SetStopOthers(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetStopOthers(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBExpressionOptions_SetStopOthers__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[1]); + } + if (_v) { + return _wrap_SBExpressionOptions_SetStopOthers__SWIG_0(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBExpressionOptions_SetStopOthers'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBExpressionOptions::SetStopOthers(bool)\n" + " lldb::SBExpressionOptions::SetStopOthers()\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBExpressionOptions_GetTrapExceptions(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBExpressionOptions::GetTrapExceptions",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::GetTrapExceptions",1,"lldb::SBExpressionOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_GetTrapExceptions",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + result = (bool)((lldb::SBExpressionOptions const *)arg1)->GetTrapExceptions(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetTrapExceptions__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBExpressionOptions::SetTrapExceptions",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetTrapExceptions",1,"lldb::SBExpressionOptions *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBExpressionOptions::SetTrapExceptions",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_SetTrapExceptions",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetTrapExceptions(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetTrapExceptions__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + + SWIG_check_num_args("lldb::SBExpressionOptions::SetTrapExceptions",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetTrapExceptions",1,"lldb::SBExpressionOptions *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_SetTrapExceptions",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + (arg1)->SetTrapExceptions(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetTrapExceptions(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBExpressionOptions_SetTrapExceptions__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[1]); + } + if (_v) { + return _wrap_SBExpressionOptions_SetTrapExceptions__SWIG_0(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBExpressionOptions_SetTrapExceptions'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBExpressionOptions::SetTrapExceptions(bool)\n" + " lldb::SBExpressionOptions::SetTrapExceptions()\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBExpressionOptions_SetLanguage__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::LanguageType arg2 ; + + SWIG_check_num_args("lldb::SBExpressionOptions::SetLanguage",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetLanguage",1,"lldb::SBExpressionOptions *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBExpressionOptions::SetLanguage",2,"lldb::LanguageType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_SetLanguage",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + arg2 = (lldb::LanguageType)lua_tointeger(L, 2); + (arg1)->SetLanguage(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetLanguage__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + lldb::SBSourceLanguageName arg2 ; + uint32_t arg3 ; + + SWIG_check_num_args("lldb::SBExpressionOptions::SetLanguage",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetLanguage",1,"lldb::SBExpressionOptions *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBExpressionOptions::SetLanguage",2,"lldb::SBSourceLanguageName"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBExpressionOptions::SetLanguage",3,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_SetLanguage",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + arg2 = (lldb::SBSourceLanguageName)lua_tointeger(L, 2); + arg3 = (uint32_t)lua_tointeger(L, 3); + (arg1)->SetLanguage(arg2,arg3); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetLanguage(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_SBExpressionOptions_SetLanguage__SWIG_0(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + return _wrap_SBExpressionOptions_SetLanguage__SWIG_1(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBExpressionOptions_GetGenerateDebugInfo(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBExpressionOptions::GetGenerateDebugInfo",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::GetGenerateDebugInfo",1,"lldb::SBExpressionOptions *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_GetGenerateDebugInfo",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + result = (bool)(arg1)->GetGenerateDebugInfo(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetGenerateDebugInfo__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBExpressionOptions::SetGenerateDebugInfo",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetGenerateDebugInfo",1,"lldb::SBExpressionOptions *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBExpressionOptions::SetGenerateDebugInfo",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_SetGenerateDebugInfo",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetGenerateDebugInfo(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetGenerateDebugInfo__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + + SWIG_check_num_args("lldb::SBExpressionOptions::SetGenerateDebugInfo",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetGenerateDebugInfo",1,"lldb::SBExpressionOptions *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_SetGenerateDebugInfo",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + (arg1)->SetGenerateDebugInfo(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetGenerateDebugInfo(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBExpressionOptions_SetGenerateDebugInfo__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[1]); + } + if (_v) { + return _wrap_SBExpressionOptions_SetGenerateDebugInfo__SWIG_0(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBExpressionOptions_SetGenerateDebugInfo'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBExpressionOptions::SetGenerateDebugInfo(bool)\n" + " lldb::SBExpressionOptions::SetGenerateDebugInfo()\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBExpressionOptions_GetSuppressPersistentResult(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBExpressionOptions::GetSuppressPersistentResult",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::GetSuppressPersistentResult",1,"lldb::SBExpressionOptions *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_GetSuppressPersistentResult",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + result = (bool)(arg1)->GetSuppressPersistentResult(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetSuppressPersistentResult__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBExpressionOptions::SetSuppressPersistentResult",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetSuppressPersistentResult",1,"lldb::SBExpressionOptions *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBExpressionOptions::SetSuppressPersistentResult",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_SetSuppressPersistentResult",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetSuppressPersistentResult(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetSuppressPersistentResult__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + + SWIG_check_num_args("lldb::SBExpressionOptions::SetSuppressPersistentResult",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetSuppressPersistentResult",1,"lldb::SBExpressionOptions *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_SetSuppressPersistentResult",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + (arg1)->SetSuppressPersistentResult(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetSuppressPersistentResult(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBExpressionOptions_SetSuppressPersistentResult__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[1]); + } + if (_v) { + return _wrap_SBExpressionOptions_SetSuppressPersistentResult__SWIG_0(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBExpressionOptions_SetSuppressPersistentResult'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBExpressionOptions::SetSuppressPersistentResult(bool)\n" + " lldb::SBExpressionOptions::SetSuppressPersistentResult()\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBExpressionOptions_GetPrefix(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBExpressionOptions::GetPrefix",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::GetPrefix",1,"lldb::SBExpressionOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_GetPrefix",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + result = (char *)((lldb::SBExpressionOptions const *)arg1)->GetPrefix(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetPrefix(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBExpressionOptions::SetPrefix",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetPrefix",1,"lldb::SBExpressionOptions *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBExpressionOptions::SetPrefix",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_SetPrefix",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetPrefix((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetAutoApplyFixIts__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBExpressionOptions::SetAutoApplyFixIts",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetAutoApplyFixIts",1,"lldb::SBExpressionOptions *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBExpressionOptions::SetAutoApplyFixIts",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_SetAutoApplyFixIts",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetAutoApplyFixIts(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetAutoApplyFixIts__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + + SWIG_check_num_args("lldb::SBExpressionOptions::SetAutoApplyFixIts",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetAutoApplyFixIts",1,"lldb::SBExpressionOptions *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_SetAutoApplyFixIts",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + (arg1)->SetAutoApplyFixIts(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetAutoApplyFixIts(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBExpressionOptions_SetAutoApplyFixIts__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[1]); + } + if (_v) { + return _wrap_SBExpressionOptions_SetAutoApplyFixIts__SWIG_0(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBExpressionOptions_SetAutoApplyFixIts'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBExpressionOptions::SetAutoApplyFixIts(bool)\n" + " lldb::SBExpressionOptions::SetAutoApplyFixIts()\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBExpressionOptions_GetAutoApplyFixIts(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBExpressionOptions::GetAutoApplyFixIts",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::GetAutoApplyFixIts",1,"lldb::SBExpressionOptions *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_GetAutoApplyFixIts",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + result = (bool)(arg1)->GetAutoApplyFixIts(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetRetriesWithFixIts(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + uint64_t arg2 ; + + SWIG_check_num_args("lldb::SBExpressionOptions::SetRetriesWithFixIts",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetRetriesWithFixIts",1,"lldb::SBExpressionOptions *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBExpressionOptions::SetRetriesWithFixIts",2,"uint64_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_SetRetriesWithFixIts",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + arg2 = (uint64_t)lua_tointeger(L, 2); + (arg1)->SetRetriesWithFixIts(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_GetRetriesWithFixIts(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + uint64_t result; + + SWIG_check_num_args("lldb::SBExpressionOptions::GetRetriesWithFixIts",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::GetRetriesWithFixIts",1,"lldb::SBExpressionOptions *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_GetRetriesWithFixIts",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + result = (uint64_t)(arg1)->GetRetriesWithFixIts(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_GetTopLevel(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBExpressionOptions::GetTopLevel",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::GetTopLevel",1,"lldb::SBExpressionOptions *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_GetTopLevel",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + result = (bool)(arg1)->GetTopLevel(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetTopLevel__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBExpressionOptions::SetTopLevel",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetTopLevel",1,"lldb::SBExpressionOptions *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBExpressionOptions::SetTopLevel",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_SetTopLevel",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetTopLevel(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetTopLevel__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + + SWIG_check_num_args("lldb::SBExpressionOptions::SetTopLevel",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetTopLevel",1,"lldb::SBExpressionOptions *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_SetTopLevel",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + (arg1)->SetTopLevel(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetTopLevel(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBExpressionOptions_SetTopLevel__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[1]); + } + if (_v) { + return _wrap_SBExpressionOptions_SetTopLevel__SWIG_0(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBExpressionOptions_SetTopLevel'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBExpressionOptions::SetTopLevel(bool)\n" + " lldb::SBExpressionOptions::SetTopLevel()\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBExpressionOptions_GetAllowJIT(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBExpressionOptions::GetAllowJIT",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::GetAllowJIT",1,"lldb::SBExpressionOptions *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_GetAllowJIT",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + result = (bool)(arg1)->GetAllowJIT(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBExpressionOptions_SetAllowJIT(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBExpressionOptions::SetAllowJIT",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBExpressionOptions::SetAllowJIT",1,"lldb::SBExpressionOptions *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBExpressionOptions::SetAllowJIT",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBExpressionOptions_SetAllowJIT",1,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetAllowJIT(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBExpressionOptions(void *obj) { +lldb::SBExpressionOptions *arg1 = (lldb::SBExpressionOptions *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBExpressionOptions(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBExpressionOptions); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBExpressionOptions_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBExpressionOptions_methods[]= { + { "GetCoerceResultToId", _wrap_SBExpressionOptions_GetCoerceResultToId}, + { "SetCoerceResultToId", _wrap_SBExpressionOptions_SetCoerceResultToId}, + { "GetUnwindOnError", _wrap_SBExpressionOptions_GetUnwindOnError}, + { "SetUnwindOnError", _wrap_SBExpressionOptions_SetUnwindOnError}, + { "GetIgnoreBreakpoints", _wrap_SBExpressionOptions_GetIgnoreBreakpoints}, + { "SetIgnoreBreakpoints", _wrap_SBExpressionOptions_SetIgnoreBreakpoints}, + { "GetFetchDynamicValue", _wrap_SBExpressionOptions_GetFetchDynamicValue}, + { "SetFetchDynamicValue", _wrap_SBExpressionOptions_SetFetchDynamicValue}, + { "GetTimeoutInMicroSeconds", _wrap_SBExpressionOptions_GetTimeoutInMicroSeconds}, + { "SetTimeoutInMicroSeconds", _wrap_SBExpressionOptions_SetTimeoutInMicroSeconds}, + { "GetOneThreadTimeoutInMicroSeconds", _wrap_SBExpressionOptions_GetOneThreadTimeoutInMicroSeconds}, + { "SetOneThreadTimeoutInMicroSeconds", _wrap_SBExpressionOptions_SetOneThreadTimeoutInMicroSeconds}, + { "GetTryAllThreads", _wrap_SBExpressionOptions_GetTryAllThreads}, + { "SetTryAllThreads", _wrap_SBExpressionOptions_SetTryAllThreads}, + { "GetStopOthers", _wrap_SBExpressionOptions_GetStopOthers}, + { "SetStopOthers", _wrap_SBExpressionOptions_SetStopOthers}, + { "GetTrapExceptions", _wrap_SBExpressionOptions_GetTrapExceptions}, + { "SetTrapExceptions", _wrap_SBExpressionOptions_SetTrapExceptions}, + { "SetLanguage", _wrap_SBExpressionOptions_SetLanguage}, + { "GetGenerateDebugInfo", _wrap_SBExpressionOptions_GetGenerateDebugInfo}, + { "SetGenerateDebugInfo", _wrap_SBExpressionOptions_SetGenerateDebugInfo}, + { "GetSuppressPersistentResult", _wrap_SBExpressionOptions_GetSuppressPersistentResult}, + { "SetSuppressPersistentResult", _wrap_SBExpressionOptions_SetSuppressPersistentResult}, + { "GetPrefix", _wrap_SBExpressionOptions_GetPrefix}, + { "SetPrefix", _wrap_SBExpressionOptions_SetPrefix}, + { "SetAutoApplyFixIts", _wrap_SBExpressionOptions_SetAutoApplyFixIts}, + { "GetAutoApplyFixIts", _wrap_SBExpressionOptions_GetAutoApplyFixIts}, + { "SetRetriesWithFixIts", _wrap_SBExpressionOptions_SetRetriesWithFixIts}, + { "GetRetriesWithFixIts", _wrap_SBExpressionOptions_GetRetriesWithFixIts}, + { "GetTopLevel", _wrap_SBExpressionOptions_GetTopLevel}, + { "SetTopLevel", _wrap_SBExpressionOptions_SetTopLevel}, + { "GetAllowJIT", _wrap_SBExpressionOptions_GetAllowJIT}, + { "SetAllowJIT", _wrap_SBExpressionOptions_SetAllowJIT}, + {0,0} +}; +static swig_lua_method swig_SBExpressionOptions_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBExpressionOptions_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBExpressionOptions_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBExpressionOptions_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBExpressionOptions_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBExpressionOptions_Sf_SwigStatic = { + "SBExpressionOptions", + swig_SBExpressionOptions_Sf_SwigStatic_methods, + swig_SBExpressionOptions_Sf_SwigStatic_attributes, + swig_SBExpressionOptions_Sf_SwigStatic_constants, + swig_SBExpressionOptions_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBExpressionOptions_bases[] = {0}; +static const char *swig_SBExpressionOptions_base_names[] = {0}; +static swig_lua_class _wrap_class_SBExpressionOptions = { "SBExpressionOptions", "SBExpressionOptions", &SWIGTYPE_p_lldb__SBExpressionOptions,_proxy__wrap_new_SBExpressionOptions, swig_delete_SBExpressionOptions, swig_SBExpressionOptions_methods, swig_SBExpressionOptions_attributes, &swig_SBExpressionOptions_Sf_SwigStatic, swig_SBExpressionOptions_meta, swig_SBExpressionOptions_bases, swig_SBExpressionOptions_base_names }; + +static int _wrap_new_SBFile__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFile *result = 0 ; + + SWIG_check_num_args("lldb::SBFile::SBFile",0,0) + result = (lldb::SBFile *)new lldb::SBFile(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBFile,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBFile__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg1 ; + lldb::SBFile *result = 0 ; + + SWIG_check_num_args("lldb::SBFile::SBFile",1,1) + { + luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 1, LUA_FILEHANDLE); + lldb::FileSP file_sp; + file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false); + if (!file_sp->IsValid()) + return luaL_error(L, "Invalid file"); + arg1 = file_sp; + } + result = (lldb::SBFile *)new lldb::SBFile(arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBFile,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBFile__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + int arg1 ; + char *arg2 = (char *) 0 ; + bool arg3 ; + lldb::SBFile *result = 0 ; + + SWIG_check_num_args("lldb::SBFile::SBFile",3,3) + if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBFile::SBFile",1,"int"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBFile::SBFile",2,"char const *"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBFile::SBFile",3,"bool"); + arg1 = (int)lua_tointeger(L, 1); + arg2 = (char *)lua_tostring(L, 2); + arg3 = (lua_toboolean(L, 3)!=0); + result = (lldb::SBFile *)new lldb::SBFile(arg1,(char const *)arg2,arg3); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBFile,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBFile(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBFile__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + _v = (lua_isuserdata(L, argv[0])) && + (luaL_testudata(L, argv[0], LUA_FILEHANDLE) != nullptr); + } + if (_v) { + return _wrap_new_SBFile__SWIG_1(L); + } + } + if (argc == 3) { + int _v = 0; + { + _v = lua_isnumber(L,argv[0]); + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[2]); + } + if (_v) { + return _wrap_new_SBFile__SWIG_2(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBFile_Read(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFile *arg1 = (lldb::SBFile *) 0 ; + uint8_t *arg2 = (uint8_t *) 0 ; + size_t arg3 ; + size_t *arg4 = (size_t *) 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBFile::Read",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFile::Read",1,"lldb::SBFile *"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("lldb::SBFile::Read",2,"uint8_t *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBFile::Read",3,"size_t"); + if(!SWIG_isptrtype(L,4)) SWIG_fail_arg("lldb::SBFile::Read",4,"size_t *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFile,0))){ + SWIG_fail_ptr("SBFile_Read",1,SWIGTYPE_p_lldb__SBFile); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_char,0))){ + SWIG_fail_ptr("SBFile_Read",2,SWIGTYPE_p_unsigned_char); + } + + arg3 = (size_t)lua_tointeger(L, 3); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_size_t,0))){ + SWIG_fail_ptr("SBFile_Read",4,SWIGTYPE_p_size_t); + } + + result = (arg1)->Read(arg2,arg3,arg4); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFile_Write(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFile *arg1 = (lldb::SBFile *) 0 ; + uint8_t *arg2 = (uint8_t *) 0 ; + size_t arg3 ; + size_t *arg4 = (size_t *) 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBFile::Write",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFile::Write",1,"lldb::SBFile *"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("lldb::SBFile::Write",2,"uint8_t const *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBFile::Write",3,"size_t"); + if(!SWIG_isptrtype(L,4)) SWIG_fail_arg("lldb::SBFile::Write",4,"size_t *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFile,0))){ + SWIG_fail_ptr("SBFile_Write",1,SWIGTYPE_p_lldb__SBFile); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_char,0))){ + SWIG_fail_ptr("SBFile_Write",2,SWIGTYPE_p_unsigned_char); + } + + arg3 = (size_t)lua_tointeger(L, 3); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_size_t,0))){ + SWIG_fail_ptr("SBFile_Write",4,SWIGTYPE_p_size_t); + } + + result = (arg1)->Write((uint8_t const *)arg2,arg3,arg4); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFile_Flush(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFile *arg1 = (lldb::SBFile *) 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBFile::Flush",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFile::Flush",1,"lldb::SBFile *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFile,0))){ + SWIG_fail_ptr("SBFile_Flush",1,SWIGTYPE_p_lldb__SBFile); + } + + result = (arg1)->Flush(); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFile_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFile *arg1 = (lldb::SBFile *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBFile::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFile::IsValid",1,"lldb::SBFile const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFile,0))){ + SWIG_fail_ptr("SBFile_IsValid",1,SWIGTYPE_p_lldb__SBFile); + } + + result = (bool)((lldb::SBFile const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFile_Close(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFile *arg1 = (lldb::SBFile *) 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBFile::Close",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFile::Close",1,"lldb::SBFile *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFile,0))){ + SWIG_fail_ptr("SBFile_Close",1,SWIGTYPE_p_lldb__SBFile); + } + + result = (arg1)->Close(); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFile_GetFile(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFile *arg1 = (lldb::SBFile *) 0 ; + SwigValueWrapper< std::shared_ptr< lldb_private::File > > result; + + SWIG_check_num_args("lldb::SBFile::GetFile",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFile::GetFile",1,"lldb::SBFile const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFile,0))){ + SWIG_fail_ptr("SBFile_GetFile",1,SWIGTYPE_p_lldb__SBFile); + } + + result = ((lldb::SBFile const *)arg1)->GetFile(); + { + lldb::FileSP sp = result; + if (sp && sp->IsValid()) { + luaL_Stream *p = (luaL_Stream *)lua_newuserdata(L, sizeof(luaL_Stream)); + p->closef = &LLDBSwigLuaCloseFileHandle; + p->f = sp->GetStream(); + luaL_setmetatable(L, LUA_FILEHANDLE); + SWIG_arg++; + } + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFile_MakeBorrowed(lua_State* L) { + { + int SWIG_arg = 0; + SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg1 ; + lldb::SBFile result; + + SWIG_check_num_args("lldb::SBFile::lldb_SBFile_MakeBorrowed",1,1) + { + luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 1, LUA_FILEHANDLE); + lldb::FileSP file_sp; + file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false); + if (!file_sp->IsValid()) + return luaL_error(L, "Invalid file"); + arg1 = file_sp; + } + result = lldb_SBFile_MakeBorrowed(SWIG_STD_MOVE(arg1)); + { + lldb::SBFile * resultptr = new lldb::SBFile(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFile,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFile_MakeForcingIOMethods(lua_State* L) { + { + int SWIG_arg = 0; + SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg1 ; + lldb::SBFile result; + + SWIG_check_num_args("lldb::SBFile::lldb_SBFile_MakeForcingIOMethods",1,1) + { + luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 1, LUA_FILEHANDLE); + lldb::FileSP file_sp; + file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false); + if (!file_sp->IsValid()) + return luaL_error(L, "Invalid file"); + arg1 = file_sp; + } + result = lldb_SBFile_MakeForcingIOMethods(SWIG_STD_MOVE(arg1)); + { + lldb::SBFile * resultptr = new lldb::SBFile(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFile,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFile_MakeBorrowedForcingIOMethods(lua_State* L) { + { + int SWIG_arg = 0; + SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg1 ; + lldb::SBFile result; + + SWIG_check_num_args("lldb::SBFile::lldb_SBFile_MakeBorrowedForcingIOMethods",1,1) + { + luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 1, LUA_FILEHANDLE); + lldb::FileSP file_sp; + file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false); + if (!file_sp->IsValid()) + return luaL_error(L, "Invalid file"); + arg1 = file_sp; + } + result = lldb_SBFile_MakeBorrowedForcingIOMethods(SWIG_STD_MOVE(arg1)); + { + lldb::SBFile * resultptr = new lldb::SBFile(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFile,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBFile(void *obj) { +lldb::SBFile *arg1 = (lldb::SBFile *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBFile(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBFile); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBFile_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBFile_methods[]= { + { "Read", _wrap_SBFile_Read}, + { "Write", _wrap_SBFile_Write}, + { "Flush", _wrap_SBFile_Flush}, + { "IsValid", _wrap_SBFile_IsValid}, + { "Close", _wrap_SBFile_Close}, + { "GetFile", _wrap_SBFile_GetFile}, + {0,0} +}; +static swig_lua_method swig_SBFile_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBFile_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBFile_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBFile_Sf_SwigStatic_methods[]= { + { "MakeBorrowed", _wrap_SBFile_MakeBorrowed}, + { "MakeForcingIOMethods", _wrap_SBFile_MakeForcingIOMethods}, + { "MakeBorrowedForcingIOMethods", _wrap_SBFile_MakeBorrowedForcingIOMethods}, + {0,0} +}; +static swig_lua_class* swig_SBFile_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBFile_Sf_SwigStatic = { + "SBFile", + swig_SBFile_Sf_SwigStatic_methods, + swig_SBFile_Sf_SwigStatic_attributes, + swig_SBFile_Sf_SwigStatic_constants, + swig_SBFile_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBFile_bases[] = {0}; +static const char *swig_SBFile_base_names[] = {0}; +static swig_lua_class _wrap_class_SBFile = { "SBFile", "SBFile", &SWIGTYPE_p_lldb__SBFile,_proxy__wrap_new_SBFile, swig_delete_SBFile, swig_SBFile_methods, swig_SBFile_attributes, &swig_SBFile_Sf_SwigStatic, swig_SBFile_meta, swig_SBFile_bases, swig_SBFile_base_names }; + +static int _wrap_new_SBFileSpec__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFileSpec *result = 0 ; + + SWIG_check_num_args("lldb::SBFileSpec::SBFileSpec",0,0) + result = (lldb::SBFileSpec *)new lldb::SBFileSpec(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBFileSpec__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFileSpec *arg1 = 0 ; + lldb::SBFileSpec *result = 0 ; + + SWIG_check_num_args("lldb::SBFileSpec::SBFileSpec",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBFileSpec::SBFileSpec",1,"lldb::SBFileSpec const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("new_SBFileSpec",1,SWIGTYPE_p_lldb__SBFileSpec); + } + + result = (lldb::SBFileSpec *)new lldb::SBFileSpec((lldb::SBFileSpec const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBFileSpec__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + lldb::SBFileSpec *result = 0 ; + + SWIG_check_num_args("lldb::SBFileSpec::SBFileSpec",1,1) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBFileSpec::SBFileSpec",1,"char const *"); + arg1 = (char *)lua_tostring(L, 1); + result = (lldb::SBFileSpec *)new lldb::SBFileSpec((char const *)arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBFileSpec__SWIG_3(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + bool arg2 ; + lldb::SBFileSpec *result = 0 ; + + SWIG_check_num_args("lldb::SBFileSpec::SBFileSpec",2,2) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBFileSpec::SBFileSpec",1,"char const *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBFileSpec::SBFileSpec",2,"bool"); + arg1 = (char *)lua_tostring(L, 1); + arg2 = (lua_toboolean(L, 2)!=0); + result = (lldb::SBFileSpec *)new lldb::SBFileSpec((char const *)arg1,arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBFileSpec(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBFileSpec__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBFileSpec__SWIG_1(L); + } + } + if (argc == 1) { + int _v = 0; + { + _v = SWIG_lua_isnilstring(L,argv[0]); + } + if (_v) { + return _wrap_new_SBFileSpec__SWIG_2(L); + } + } + if (argc == 2) { + int _v = 0; + { + _v = SWIG_lua_isnilstring(L,argv[0]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[1]); + } + if (_v) { + return _wrap_new_SBFileSpec__SWIG_3(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBFileSpec___eq(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ; + lldb::SBFileSpec *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBFileSpec::operator ==",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpec::operator ==",1,"lldb::SBFileSpec const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBFileSpec::operator ==",2,"lldb::SBFileSpec const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBFileSpec___eq",1,SWIGTYPE_p_lldb__SBFileSpec); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBFileSpec___eq",2,SWIGTYPE_p_lldb__SBFileSpec); + } + + result = (bool)((lldb::SBFileSpec const *)arg1)->operator ==((lldb::SBFileSpec const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFileSpec_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBFileSpec::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpec::IsValid",1,"lldb::SBFileSpec const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBFileSpec_IsValid",1,SWIGTYPE_p_lldb__SBFileSpec); + } + + result = (bool)((lldb::SBFileSpec const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFileSpec_Exists(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBFileSpec::Exists",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpec::Exists",1,"lldb::SBFileSpec const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBFileSpec_Exists",1,SWIGTYPE_p_lldb__SBFileSpec); + } + + result = (bool)((lldb::SBFileSpec const *)arg1)->Exists(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFileSpec_ResolveExecutableLocation(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBFileSpec::ResolveExecutableLocation",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpec::ResolveExecutableLocation",1,"lldb::SBFileSpec *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBFileSpec_ResolveExecutableLocation",1,SWIGTYPE_p_lldb__SBFileSpec); + } + + result = (bool)(arg1)->ResolveExecutableLocation(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFileSpec_GetFilename(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBFileSpec::GetFilename",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpec::GetFilename",1,"lldb::SBFileSpec const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBFileSpec_GetFilename",1,SWIGTYPE_p_lldb__SBFileSpec); + } + + result = (char *)((lldb::SBFileSpec const *)arg1)->GetFilename(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFileSpec_GetDirectory(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBFileSpec::GetDirectory",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpec::GetDirectory",1,"lldb::SBFileSpec const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBFileSpec_GetDirectory",1,SWIGTYPE_p_lldb__SBFileSpec); + } + + result = (char *)((lldb::SBFileSpec const *)arg1)->GetDirectory(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFileSpec_SetFilename(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBFileSpec::SetFilename",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpec::SetFilename",1,"lldb::SBFileSpec *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBFileSpec::SetFilename",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBFileSpec_SetFilename",1,SWIGTYPE_p_lldb__SBFileSpec); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetFilename((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFileSpec_SetDirectory(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBFileSpec::SetDirectory",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpec::SetDirectory",1,"lldb::SBFileSpec *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBFileSpec::SetDirectory",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBFileSpec_SetDirectory",1,SWIGTYPE_p_lldb__SBFileSpec); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetDirectory((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFileSpec_GetPath(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ; + char *arg2 = (char *) 0 ; + size_t arg3 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBFileSpec::GetPath",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpec::GetPath",1,"lldb::SBFileSpec const *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBFileSpec::GetPath",2,"char *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBFileSpec::GetPath",3,"size_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBFileSpec_GetPath",1,SWIGTYPE_p_lldb__SBFileSpec); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (size_t)lua_tointeger(L, 3); + result = (uint32_t)((lldb::SBFileSpec const *)arg1)->GetPath(arg2,arg3); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFileSpec_ResolvePath(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + char *arg2 = (char *) 0 ; + size_t arg3 ; + int result; + + SWIG_check_num_args("lldb::SBFileSpec::ResolvePath",3,3) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBFileSpec::ResolvePath",1,"char const *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBFileSpec::ResolvePath",2,"char *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBFileSpec::ResolvePath",3,"size_t"); + arg1 = (char *)lua_tostring(L, 1); + arg2 = (char *)lua_tostring(L, 2); + arg3 = (size_t)lua_tointeger(L, 3); + result = (int)lldb::SBFileSpec::ResolvePath((char const *)arg1,arg2,SWIG_STD_MOVE(arg3)); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFileSpec_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBFileSpec::GetDescription",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpec::GetDescription",1,"lldb::SBFileSpec const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBFileSpec::GetDescription",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBFileSpec_GetDescription",1,SWIGTYPE_p_lldb__SBFileSpec); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBFileSpec_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)((lldb::SBFileSpec const *)arg1)->GetDescription(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFileSpec_AppendPathComponent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBFileSpec::AppendPathComponent",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpec::AppendPathComponent",1,"lldb::SBFileSpec *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBFileSpec::AppendPathComponent",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBFileSpec_AppendPathComponent",1,SWIGTYPE_p_lldb__SBFileSpec); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->AppendPathComponent((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFileSpec___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBFileSpec::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpec::__repr__",1,"lldb::SBFileSpec *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBFileSpec___tostring",1,SWIGTYPE_p_lldb__SBFileSpec); + } + + result = lldb_SBFileSpec___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBFileSpec(void *obj) { +lldb::SBFileSpec *arg1 = (lldb::SBFileSpec *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBFileSpec(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBFileSpec); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBFileSpec_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBFileSpec_methods[]= { + { "__eq", _wrap_SBFileSpec___eq}, + { "IsValid", _wrap_SBFileSpec_IsValid}, + { "Exists", _wrap_SBFileSpec_Exists}, + { "ResolveExecutableLocation", _wrap_SBFileSpec_ResolveExecutableLocation}, + { "GetFilename", _wrap_SBFileSpec_GetFilename}, + { "GetDirectory", _wrap_SBFileSpec_GetDirectory}, + { "SetFilename", _wrap_SBFileSpec_SetFilename}, + { "SetDirectory", _wrap_SBFileSpec_SetDirectory}, + { "GetPath", _wrap_SBFileSpec_GetPath}, + { "GetDescription", _wrap_SBFileSpec_GetDescription}, + { "AppendPathComponent", _wrap_SBFileSpec_AppendPathComponent}, + { "__tostring", _wrap_SBFileSpec___tostring}, + {0,0} +}; +static swig_lua_method swig_SBFileSpec_meta[] = { + { "__eq", _wrap_SBFileSpec___eq}, + { "__tostring", _wrap_SBFileSpec___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBFileSpec_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBFileSpec_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBFileSpec_Sf_SwigStatic_methods[]= { + { "ResolvePath", _wrap_SBFileSpec_ResolvePath}, + {0,0} +}; +static swig_lua_class* swig_SBFileSpec_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBFileSpec_Sf_SwigStatic = { + "SBFileSpec", + swig_SBFileSpec_Sf_SwigStatic_methods, + swig_SBFileSpec_Sf_SwigStatic_attributes, + swig_SBFileSpec_Sf_SwigStatic_constants, + swig_SBFileSpec_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBFileSpec_bases[] = {0}; +static const char *swig_SBFileSpec_base_names[] = {0}; +static swig_lua_class _wrap_class_SBFileSpec = { "SBFileSpec", "SBFileSpec", &SWIGTYPE_p_lldb__SBFileSpec,_proxy__wrap_new_SBFileSpec, swig_delete_SBFileSpec, swig_SBFileSpec_methods, swig_SBFileSpec_attributes, &swig_SBFileSpec_Sf_SwigStatic, swig_SBFileSpec_meta, swig_SBFileSpec_bases, swig_SBFileSpec_base_names }; + +static int _wrap_new_SBFileSpecList__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFileSpecList *result = 0 ; + + SWIG_check_num_args("lldb::SBFileSpecList::SBFileSpecList",0,0) + result = (lldb::SBFileSpecList *)new lldb::SBFileSpecList(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBFileSpecList,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBFileSpecList__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFileSpecList *arg1 = 0 ; + lldb::SBFileSpecList *result = 0 ; + + SWIG_check_num_args("lldb::SBFileSpecList::SBFileSpecList",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBFileSpecList::SBFileSpecList",1,"lldb::SBFileSpecList const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("new_SBFileSpecList",1,SWIGTYPE_p_lldb__SBFileSpecList); + } + + result = (lldb::SBFileSpecList *)new lldb::SBFileSpecList((lldb::SBFileSpecList const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBFileSpecList,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBFileSpecList(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBFileSpecList__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBFileSpecList__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBFileSpecList'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBFileSpecList::SBFileSpecList()\n" + " lldb::SBFileSpecList::SBFileSpecList(lldb::SBFileSpecList const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBFileSpecList_GetSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFileSpecList *arg1 = (lldb::SBFileSpecList *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBFileSpecList::GetSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpecList::GetSize",1,"lldb::SBFileSpecList const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("SBFileSpecList_GetSize",1,SWIGTYPE_p_lldb__SBFileSpecList); + } + + result = (uint32_t)((lldb::SBFileSpecList const *)arg1)->GetSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFileSpecList_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFileSpecList *arg1 = (lldb::SBFileSpecList *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBFileSpecList::GetDescription",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpecList::GetDescription",1,"lldb::SBFileSpecList const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBFileSpecList::GetDescription",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("SBFileSpecList_GetDescription",1,SWIGTYPE_p_lldb__SBFileSpecList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBFileSpecList_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)((lldb::SBFileSpecList const *)arg1)->GetDescription(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFileSpecList_Append(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFileSpecList *arg1 = (lldb::SBFileSpecList *) 0 ; + lldb::SBFileSpec *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBFileSpecList::Append",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpecList::Append",1,"lldb::SBFileSpecList *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBFileSpecList::Append",2,"lldb::SBFileSpec const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("SBFileSpecList_Append",1,SWIGTYPE_p_lldb__SBFileSpecList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBFileSpecList_Append",2,SWIGTYPE_p_lldb__SBFileSpec); + } + + (arg1)->Append((lldb::SBFileSpec const &)*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFileSpecList_AppendIfUnique(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFileSpecList *arg1 = (lldb::SBFileSpecList *) 0 ; + lldb::SBFileSpec *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBFileSpecList::AppendIfUnique",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpecList::AppendIfUnique",1,"lldb::SBFileSpecList *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBFileSpecList::AppendIfUnique",2,"lldb::SBFileSpec const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("SBFileSpecList_AppendIfUnique",1,SWIGTYPE_p_lldb__SBFileSpecList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBFileSpecList_AppendIfUnique",2,SWIGTYPE_p_lldb__SBFileSpec); + } + + result = (bool)(arg1)->AppendIfUnique((lldb::SBFileSpec const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFileSpecList_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFileSpecList *arg1 = (lldb::SBFileSpecList *) 0 ; + + SWIG_check_num_args("lldb::SBFileSpecList::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpecList::Clear",1,"lldb::SBFileSpecList *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("SBFileSpecList_Clear",1,SWIGTYPE_p_lldb__SBFileSpecList); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFileSpecList_FindFileIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFileSpecList *arg1 = (lldb::SBFileSpecList *) 0 ; + uint32_t arg2 ; + lldb::SBFileSpec *arg3 = 0 ; + bool arg4 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBFileSpecList::FindFileIndex",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpecList::FindFileIndex",1,"lldb::SBFileSpecList *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBFileSpecList::FindFileIndex",2,"uint32_t"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBFileSpecList::FindFileIndex",3,"lldb::SBFileSpec const &"); + if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBFileSpecList::FindFileIndex",4,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("SBFileSpecList_FindFileIndex",1,SWIGTYPE_p_lldb__SBFileSpecList); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBFileSpecList_FindFileIndex",3,SWIGTYPE_p_lldb__SBFileSpec); + } + + arg4 = (lua_toboolean(L, 4)!=0); + result = (uint32_t)(arg1)->FindFileIndex(arg2,(lldb::SBFileSpec const &)*arg3,arg4); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFileSpecList_GetFileSpecAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFileSpecList *arg1 = (lldb::SBFileSpecList *) 0 ; + uint32_t arg2 ; + lldb::SBFileSpec result; + + SWIG_check_num_args("lldb::SBFileSpecList::GetFileSpecAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpecList::GetFileSpecAtIndex",1,"lldb::SBFileSpecList const *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBFileSpecList::GetFileSpecAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("SBFileSpecList_GetFileSpecAtIndex",1,SWIGTYPE_p_lldb__SBFileSpecList); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = ((lldb::SBFileSpecList const *)arg1)->GetFileSpecAtIndex(arg2); + { + lldb::SBFileSpec * resultptr = new lldb::SBFileSpec(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFileSpecList___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFileSpecList *arg1 = (lldb::SBFileSpecList *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBFileSpecList::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFileSpecList::__repr__",1,"lldb::SBFileSpecList *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("SBFileSpecList___tostring",1,SWIGTYPE_p_lldb__SBFileSpecList); + } + + result = lldb_SBFileSpecList___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBFileSpecList(void *obj) { +lldb::SBFileSpecList *arg1 = (lldb::SBFileSpecList *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBFileSpecList(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBFileSpecList); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBFileSpecList_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBFileSpecList_methods[]= { + { "GetSize", _wrap_SBFileSpecList_GetSize}, + { "GetDescription", _wrap_SBFileSpecList_GetDescription}, + { "Append", _wrap_SBFileSpecList_Append}, + { "AppendIfUnique", _wrap_SBFileSpecList_AppendIfUnique}, + { "Clear", _wrap_SBFileSpecList_Clear}, + { "FindFileIndex", _wrap_SBFileSpecList_FindFileIndex}, + { "GetFileSpecAtIndex", _wrap_SBFileSpecList_GetFileSpecAtIndex}, + { "__tostring", _wrap_SBFileSpecList___tostring}, + {0,0} +}; +static swig_lua_method swig_SBFileSpecList_meta[] = { + { "__tostring", _wrap_SBFileSpecList___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBFileSpecList_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBFileSpecList_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBFileSpecList_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBFileSpecList_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBFileSpecList_Sf_SwigStatic = { + "SBFileSpecList", + swig_SBFileSpecList_Sf_SwigStatic_methods, + swig_SBFileSpecList_Sf_SwigStatic_attributes, + swig_SBFileSpecList_Sf_SwigStatic_constants, + swig_SBFileSpecList_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBFileSpecList_bases[] = {0}; +static const char *swig_SBFileSpecList_base_names[] = {0}; +static swig_lua_class _wrap_class_SBFileSpecList = { "SBFileSpecList", "SBFileSpecList", &SWIGTYPE_p_lldb__SBFileSpecList,_proxy__wrap_new_SBFileSpecList, swig_delete_SBFileSpecList, swig_SBFileSpecList_methods, swig_SBFileSpecList_attributes, &swig_SBFileSpecList_Sf_SwigStatic, swig_SBFileSpecList_meta, swig_SBFileSpecList_bases, swig_SBFileSpecList_base_names }; + +static int _wrap_new_SBFormat__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFormat *result = 0 ; + + SWIG_check_num_args("lldb::SBFormat::SBFormat",0,0) + result = (lldb::SBFormat *)new lldb::SBFormat(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBFormat,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBFormat__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + lldb::SBError *arg2 = 0 ; + lldb::SBFormat *result = 0 ; + + SWIG_check_num_args("lldb::SBFormat::SBFormat",2,2) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBFormat::SBFormat",1,"char const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBFormat::SBFormat",2,"lldb::SBError &"); + arg1 = (char *)lua_tostring(L, 1); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("new_SBFormat",2,SWIGTYPE_p_lldb__SBError); + } + + result = (lldb::SBFormat *)new lldb::SBFormat((char const *)arg1,*arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBFormat,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBFormat__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFormat *arg1 = 0 ; + lldb::SBFormat *result = 0 ; + + SWIG_check_num_args("lldb::SBFormat::SBFormat",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBFormat::SBFormat",1,"lldb::SBFormat const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFormat,0))){ + SWIG_fail_ptr("new_SBFormat",1,SWIGTYPE_p_lldb__SBFormat); + } + + result = (lldb::SBFormat *)new lldb::SBFormat((lldb::SBFormat const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBFormat,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBFormat(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBFormat__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFormat, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBFormat__SWIG_2(L); + } + } + if (argc == 2) { + int _v = 0; + { + _v = SWIG_lua_isnilstring(L,argv[0]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBFormat__SWIG_1(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static void swig_delete_SBFormat(void *obj) { +lldb::SBFormat *arg1 = (lldb::SBFormat *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBFormat(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBFormat); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBFormat_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBFormat_methods[]= { + {0,0} +}; +static swig_lua_method swig_SBFormat_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBFormat_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBFormat_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBFormat_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBFormat_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBFormat_Sf_SwigStatic = { + "SBFormat", + swig_SBFormat_Sf_SwigStatic_methods, + swig_SBFormat_Sf_SwigStatic_attributes, + swig_SBFormat_Sf_SwigStatic_constants, + swig_SBFormat_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBFormat_bases[] = {0}; +static const char *swig_SBFormat_base_names[] = {0}; +static swig_lua_class _wrap_class_SBFormat = { "SBFormat", "SBFormat", &SWIGTYPE_p_lldb__SBFormat,_proxy__wrap_new_SBFormat, swig_delete_SBFormat, swig_SBFormat_methods, swig_SBFormat_attributes, &swig_SBFormat_Sf_SwigStatic, swig_SBFormat_meta, swig_SBFormat_bases, swig_SBFormat_base_names }; + +static int _wrap_new_SBFrame__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *result = 0 ; + + SWIG_check_num_args("lldb::SBFrame::SBFrame",0,0) + result = (lldb::SBFrame *)new lldb::SBFrame(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBFrame,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBFrame__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = 0 ; + lldb::SBFrame *result = 0 ; + + SWIG_check_num_args("lldb::SBFrame::SBFrame",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBFrame::SBFrame",1,"lldb::SBFrame const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("new_SBFrame",1,SWIGTYPE_p_lldb__SBFrame); + } + + result = (lldb::SBFrame *)new lldb::SBFrame((lldb::SBFrame const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBFrame,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBFrame(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBFrame__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBFrame__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBFrame'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBFrame::SBFrame()\n" + " lldb::SBFrame::SBFrame(lldb::SBFrame const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBFrame_IsEqual(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBFrame::IsEqual",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::IsEqual",1,"lldb::SBFrame const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBFrame::IsEqual",2,"lldb::SBFrame const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_IsEqual",1,SWIGTYPE_p_lldb__SBFrame); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_IsEqual",2,SWIGTYPE_p_lldb__SBFrame); + } + + result = (bool)((lldb::SBFrame const *)arg1)->IsEqual((lldb::SBFrame const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBFrame::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::IsValid",1,"lldb::SBFrame const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_IsValid",1,SWIGTYPE_p_lldb__SBFrame); + } + + result = (bool)((lldb::SBFrame const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_GetFrameID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBFrame::GetFrameID",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetFrameID",1,"lldb::SBFrame const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_GetFrameID",1,SWIGTYPE_p_lldb__SBFrame); + } + + result = (uint32_t)((lldb::SBFrame const *)arg1)->GetFrameID(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_GetCFA(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::addr_t result; + + SWIG_check_num_args("lldb::SBFrame::GetCFA",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetCFA",1,"lldb::SBFrame const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_GetCFA",1,SWIGTYPE_p_lldb__SBFrame); + } + + result = (lldb::addr_t)((lldb::SBFrame const *)arg1)->GetCFA(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_GetPC(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::addr_t result; + + SWIG_check_num_args("lldb::SBFrame::GetPC",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetPC",1,"lldb::SBFrame const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_GetPC",1,SWIGTYPE_p_lldb__SBFrame); + } + + result = (lldb::addr_t)((lldb::SBFrame const *)arg1)->GetPC(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_SetPC(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::addr_t arg2 ; + bool result; + + SWIG_check_num_args("lldb::SBFrame::SetPC",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::SetPC",1,"lldb::SBFrame *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBFrame::SetPC",2,"lldb::addr_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_SetPC",1,SWIGTYPE_p_lldb__SBFrame); + } + + arg2 = (lldb::addr_t)lua_tointeger(L, 2); + result = (bool)(arg1)->SetPC(arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_GetSP(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::addr_t result; + + SWIG_check_num_args("lldb::SBFrame::GetSP",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetSP",1,"lldb::SBFrame const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_GetSP",1,SWIGTYPE_p_lldb__SBFrame); + } + + result = (lldb::addr_t)((lldb::SBFrame const *)arg1)->GetSP(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_GetFP(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::addr_t result; + + SWIG_check_num_args("lldb::SBFrame::GetFP",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetFP",1,"lldb::SBFrame const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_GetFP",1,SWIGTYPE_p_lldb__SBFrame); + } + + result = (lldb::addr_t)((lldb::SBFrame const *)arg1)->GetFP(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_GetPCAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBAddress result; + + SWIG_check_num_args("lldb::SBFrame::GetPCAddress",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetPCAddress",1,"lldb::SBFrame const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_GetPCAddress",1,SWIGTYPE_p_lldb__SBFrame); + } + + result = ((lldb::SBFrame const *)arg1)->GetPCAddress(); + { + lldb::SBAddress * resultptr = new lldb::SBAddress(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_GetSymbolContext(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + uint32_t arg2 ; + lldb::SBSymbolContext result; + + SWIG_check_num_args("lldb::SBFrame::GetSymbolContext",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetSymbolContext",1,"lldb::SBFrame const *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBFrame::GetSymbolContext",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_GetSymbolContext",1,SWIGTYPE_p_lldb__SBFrame); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = ((lldb::SBFrame const *)arg1)->GetSymbolContext(arg2); + { + lldb::SBSymbolContext * resultptr = new lldb::SBSymbolContext(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbolContext,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_GetModule(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBModule result; + + SWIG_check_num_args("lldb::SBFrame::GetModule",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetModule",1,"lldb::SBFrame const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_GetModule",1,SWIGTYPE_p_lldb__SBFrame); + } + + result = ((lldb::SBFrame const *)arg1)->GetModule(); + { + lldb::SBModule * resultptr = new lldb::SBModule(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBModule,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_GetCompileUnit(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBCompileUnit result; + + SWIG_check_num_args("lldb::SBFrame::GetCompileUnit",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetCompileUnit",1,"lldb::SBFrame const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_GetCompileUnit",1,SWIGTYPE_p_lldb__SBFrame); + } + + result = ((lldb::SBFrame const *)arg1)->GetCompileUnit(); + { + lldb::SBCompileUnit * resultptr = new lldb::SBCompileUnit(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBCompileUnit,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_GetFunction(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFunction result; + + SWIG_check_num_args("lldb::SBFrame::GetFunction",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetFunction",1,"lldb::SBFrame const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_GetFunction",1,SWIGTYPE_p_lldb__SBFrame); + } + + result = ((lldb::SBFrame const *)arg1)->GetFunction(); + { + lldb::SBFunction * resultptr = new lldb::SBFunction(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFunction,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_GetSymbol(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBSymbol result; + + SWIG_check_num_args("lldb::SBFrame::GetSymbol",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetSymbol",1,"lldb::SBFrame const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_GetSymbol",1,SWIGTYPE_p_lldb__SBFrame); + } + + result = ((lldb::SBFrame const *)arg1)->GetSymbol(); + { + lldb::SBSymbol * resultptr = new lldb::SBSymbol(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbol,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_GetBlock(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBBlock result; + + SWIG_check_num_args("lldb::SBFrame::GetBlock",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetBlock",1,"lldb::SBFrame const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_GetBlock",1,SWIGTYPE_p_lldb__SBFrame); + } + + result = ((lldb::SBFrame const *)arg1)->GetBlock(); + { + lldb::SBBlock * resultptr = new lldb::SBBlock(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBlock,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_GetFunctionName__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBFrame::GetFunctionName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetFunctionName",1,"lldb::SBFrame *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_GetFunctionName",1,SWIGTYPE_p_lldb__SBFrame); + } + + result = (char *)(arg1)->GetFunctionName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_GetDisplayFunctionName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBFrame::GetDisplayFunctionName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetDisplayFunctionName",1,"lldb::SBFrame *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_GetDisplayFunctionName",1,SWIGTYPE_p_lldb__SBFrame); + } + + result = (char *)(arg1)->GetDisplayFunctionName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_GetFunctionName__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBFrame::GetFunctionName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetFunctionName",1,"lldb::SBFrame const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_GetFunctionName",1,SWIGTYPE_p_lldb__SBFrame); + } + + result = (char *)((lldb::SBFrame const *)arg1)->GetFunctionName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_GetFunctionName(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBFrame_GetFunctionName__SWIG_0(L); + } + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBFrame_GetFunctionName__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBFrame_GetFunctionName'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBFrame::GetFunctionName()\n" + " lldb::SBFrame::GetFunctionName() const\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBFrame_GuessLanguage(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::LanguageType result; + + SWIG_check_num_args("lldb::SBFrame::GuessLanguage",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GuessLanguage",1,"lldb::SBFrame const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_GuessLanguage",1,SWIGTYPE_p_lldb__SBFrame); + } + + result = (lldb::LanguageType)((lldb::SBFrame const *)arg1)->GuessLanguage(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_IsInlined__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBFrame::IsInlined",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::IsInlined",1,"lldb::SBFrame *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_IsInlined",1,SWIGTYPE_p_lldb__SBFrame); + } + + result = (bool)(arg1)->IsInlined(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_IsInlined__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBFrame::IsInlined",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::IsInlined",1,"lldb::SBFrame const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_IsInlined",1,SWIGTYPE_p_lldb__SBFrame); + } + + result = (bool)((lldb::SBFrame const *)arg1)->IsInlined(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_IsInlined(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBFrame_IsInlined__SWIG_0(L); + } + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBFrame_IsInlined__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBFrame_IsInlined'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBFrame::IsInlined()\n" + " lldb::SBFrame::IsInlined() const\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBFrame_IsArtificial__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBFrame::IsArtificial",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::IsArtificial",1,"lldb::SBFrame *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_IsArtificial",1,SWIGTYPE_p_lldb__SBFrame); + } + + result = (bool)(arg1)->IsArtificial(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_IsArtificial__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBFrame::IsArtificial",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::IsArtificial",1,"lldb::SBFrame const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_IsArtificial",1,SWIGTYPE_p_lldb__SBFrame); + } + + result = (bool)((lldb::SBFrame const *)arg1)->IsArtificial(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_IsArtificial(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBFrame_IsArtificial__SWIG_0(L); + } + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBFrame_IsArtificial__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBFrame_IsArtificial'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBFrame::IsArtificial()\n" + " lldb::SBFrame::IsArtificial() const\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBFrame_EvaluateExpression__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBFrame::EvaluateExpression",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::EvaluateExpression",1,"lldb::SBFrame *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBFrame::EvaluateExpression",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_EvaluateExpression",1,SWIGTYPE_p_lldb__SBFrame); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->EvaluateExpression((char const *)arg2); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_EvaluateExpression__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + char *arg2 = (char *) 0 ; + lldb::DynamicValueType arg3 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBFrame::EvaluateExpression",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::EvaluateExpression",1,"lldb::SBFrame *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBFrame::EvaluateExpression",2,"char const *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBFrame::EvaluateExpression",3,"lldb::DynamicValueType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_EvaluateExpression",1,SWIGTYPE_p_lldb__SBFrame); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (lldb::DynamicValueType)lua_tointeger(L, 3); + result = (arg1)->EvaluateExpression((char const *)arg2,arg3); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_EvaluateExpression__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + char *arg2 = (char *) 0 ; + lldb::DynamicValueType arg3 ; + bool arg4 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBFrame::EvaluateExpression",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::EvaluateExpression",1,"lldb::SBFrame *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBFrame::EvaluateExpression",2,"char const *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBFrame::EvaluateExpression",3,"lldb::DynamicValueType"); + if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBFrame::EvaluateExpression",4,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_EvaluateExpression",1,SWIGTYPE_p_lldb__SBFrame); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (lldb::DynamicValueType)lua_tointeger(L, 3); + arg4 = (lua_toboolean(L, 4)!=0); + result = (arg1)->EvaluateExpression((char const *)arg2,arg3,arg4); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_EvaluateExpression__SWIG_3(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBExpressionOptions *arg3 = 0 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBFrame::EvaluateExpression",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::EvaluateExpression",1,"lldb::SBFrame *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBFrame::EvaluateExpression",2,"char const *"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBFrame::EvaluateExpression",3,"lldb::SBExpressionOptions const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_EvaluateExpression",1,SWIGTYPE_p_lldb__SBFrame); + } + + arg2 = (char *)lua_tostring(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBFrame_EvaluateExpression",3,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + result = (arg1)->EvaluateExpression((char const *)arg2,(lldb::SBExpressionOptions const &)*arg3); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_EvaluateExpression(lua_State* L) { + int argc; + int argv[5]={ + 1,2,3,4,5 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + return _wrap_SBFrame_EvaluateExpression__SWIG_0(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBFrame_EvaluateExpression__SWIG_3(L); + } + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + return _wrap_SBFrame_EvaluateExpression__SWIG_1(L); + } + } + } + } + if (argc == 4) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[3]); + } + if (_v) { + return _wrap_SBFrame_EvaluateExpression__SWIG_2(L); + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBFrame_GetFrameBlock(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBBlock result; + + SWIG_check_num_args("lldb::SBFrame::GetFrameBlock",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetFrameBlock",1,"lldb::SBFrame const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_GetFrameBlock",1,SWIGTYPE_p_lldb__SBFrame); + } + + result = ((lldb::SBFrame const *)arg1)->GetFrameBlock(); + { + lldb::SBBlock * resultptr = new lldb::SBBlock(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBlock,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_GetLineEntry(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBLineEntry result; + + SWIG_check_num_args("lldb::SBFrame::GetLineEntry",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetLineEntry",1,"lldb::SBFrame const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_GetLineEntry",1,SWIGTYPE_p_lldb__SBFrame); + } + + result = ((lldb::SBFrame const *)arg1)->GetLineEntry(); + { + lldb::SBLineEntry * resultptr = new lldb::SBLineEntry(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBLineEntry,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_GetThread(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBThread result; + + SWIG_check_num_args("lldb::SBFrame::GetThread",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetThread",1,"lldb::SBFrame const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_GetThread",1,SWIGTYPE_p_lldb__SBFrame); + } + + result = ((lldb::SBFrame const *)arg1)->GetThread(); + { + lldb::SBThread * resultptr = new lldb::SBThread(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThread,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_Disassemble(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBFrame::Disassemble",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::Disassemble",1,"lldb::SBFrame const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_Disassemble",1,SWIGTYPE_p_lldb__SBFrame); + } + + result = (char *)((lldb::SBFrame const *)arg1)->Disassemble(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + + SWIG_check_num_args("lldb::SBFrame::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::Clear",1,"lldb::SBFrame *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_Clear",1,SWIGTYPE_p_lldb__SBFrame); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame___eq(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFrame *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBFrame::operator ==",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::operator ==",1,"lldb::SBFrame const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBFrame::operator ==",2,"lldb::SBFrame const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame___eq",1,SWIGTYPE_p_lldb__SBFrame); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame___eq",2,SWIGTYPE_p_lldb__SBFrame); + } + + result = (bool)((lldb::SBFrame const *)arg1)->operator ==((lldb::SBFrame const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_GetVariables__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + bool arg2 ; + bool arg3 ; + bool arg4 ; + bool arg5 ; + lldb::SBValueList result; + + SWIG_check_num_args("lldb::SBFrame::GetVariables",5,5) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetVariables",1,"lldb::SBFrame *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBFrame::GetVariables",2,"bool"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBFrame::GetVariables",3,"bool"); + if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBFrame::GetVariables",4,"bool"); + if(!lua_isboolean(L,5)) SWIG_fail_arg("lldb::SBFrame::GetVariables",5,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_GetVariables",1,SWIGTYPE_p_lldb__SBFrame); + } + + arg2 = (lua_toboolean(L, 2)!=0); + arg3 = (lua_toboolean(L, 3)!=0); + arg4 = (lua_toboolean(L, 4)!=0); + arg5 = (lua_toboolean(L, 5)!=0); + result = (arg1)->GetVariables(arg2,arg3,arg4,arg5); + { + lldb::SBValueList * resultptr = new lldb::SBValueList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValueList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_GetVariables__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + bool arg2 ; + bool arg3 ; + bool arg4 ; + bool arg5 ; + lldb::DynamicValueType arg6 ; + lldb::SBValueList result; + + SWIG_check_num_args("lldb::SBFrame::GetVariables",6,6) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetVariables",1,"lldb::SBFrame *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBFrame::GetVariables",2,"bool"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBFrame::GetVariables",3,"bool"); + if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBFrame::GetVariables",4,"bool"); + if(!lua_isboolean(L,5)) SWIG_fail_arg("lldb::SBFrame::GetVariables",5,"bool"); + if(!lua_isinteger(L,6)) SWIG_fail_arg("lldb::SBFrame::GetVariables",6,"lldb::DynamicValueType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_GetVariables",1,SWIGTYPE_p_lldb__SBFrame); + } + + arg2 = (lua_toboolean(L, 2)!=0); + arg3 = (lua_toboolean(L, 3)!=0); + arg4 = (lua_toboolean(L, 4)!=0); + arg5 = (lua_toboolean(L, 5)!=0); + arg6 = (lldb::DynamicValueType)lua_tointeger(L, 6); + result = (arg1)->GetVariables(arg2,arg3,arg4,arg5,arg6); + { + lldb::SBValueList * resultptr = new lldb::SBValueList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValueList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_GetVariables__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBVariablesOptions *arg2 = 0 ; + lldb::SBValueList result; + + SWIG_check_num_args("lldb::SBFrame::GetVariables",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetVariables",1,"lldb::SBFrame *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBFrame::GetVariables",2,"lldb::SBVariablesOptions const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_GetVariables",1,SWIGTYPE_p_lldb__SBFrame); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBVariablesOptions,0))){ + SWIG_fail_ptr("SBFrame_GetVariables",2,SWIGTYPE_p_lldb__SBVariablesOptions); + } + + result = (arg1)->GetVariables((lldb::SBVariablesOptions const &)*arg2); + { + lldb::SBValueList * resultptr = new lldb::SBValueList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValueList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_GetVariables(lua_State* L) { + int argc; + int argv[7]={ + 1,2,3,4,5,6,7 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBVariablesOptions, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBFrame_GetVariables__SWIG_2(L); + } + } + } + if (argc == 5) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[1]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[2]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[3]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[4]); + } + if (_v) { + return _wrap_SBFrame_GetVariables__SWIG_0(L); + } + } + } + } + } + } + if (argc == 6) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[1]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[2]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[3]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[4]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[5]); + } + if (_v) { + return _wrap_SBFrame_GetVariables__SWIG_1(L); + } + } + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBFrame_GetRegisters(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBValueList result; + + SWIG_check_num_args("lldb::SBFrame::GetRegisters",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetRegisters",1,"lldb::SBFrame *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_GetRegisters",1,SWIGTYPE_p_lldb__SBFrame); + } + + result = (arg1)->GetRegisters(); + { + lldb::SBValueList * resultptr = new lldb::SBValueList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValueList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_FindRegister(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBFrame::FindRegister",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::FindRegister",1,"lldb::SBFrame *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBFrame::FindRegister",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_FindRegister",1,SWIGTYPE_p_lldb__SBFrame); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->FindRegister((char const *)arg2); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_FindVariable__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBFrame::FindVariable",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::FindVariable",1,"lldb::SBFrame *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBFrame::FindVariable",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_FindVariable",1,SWIGTYPE_p_lldb__SBFrame); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->FindVariable((char const *)arg2); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_FindVariable__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + char *arg2 = (char *) 0 ; + lldb::DynamicValueType arg3 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBFrame::FindVariable",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::FindVariable",1,"lldb::SBFrame *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBFrame::FindVariable",2,"char const *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBFrame::FindVariable",3,"lldb::DynamicValueType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_FindVariable",1,SWIGTYPE_p_lldb__SBFrame); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (lldb::DynamicValueType)lua_tointeger(L, 3); + result = (arg1)->FindVariable((char const *)arg2,arg3); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_FindVariable(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + return _wrap_SBFrame_FindVariable__SWIG_0(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + return _wrap_SBFrame_FindVariable__SWIG_1(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBFrame_GetValueForVariablePath__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + char *arg2 = (char *) 0 ; + lldb::DynamicValueType arg3 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBFrame::GetValueForVariablePath",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetValueForVariablePath",1,"lldb::SBFrame *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBFrame::GetValueForVariablePath",2,"char const *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBFrame::GetValueForVariablePath",3,"lldb::DynamicValueType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_GetValueForVariablePath",1,SWIGTYPE_p_lldb__SBFrame); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (lldb::DynamicValueType)lua_tointeger(L, 3); + result = (arg1)->GetValueForVariablePath((char const *)arg2,arg3); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_GetValueForVariablePath__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBFrame::GetValueForVariablePath",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetValueForVariablePath",1,"lldb::SBFrame *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBFrame::GetValueForVariablePath",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_GetValueForVariablePath",1,SWIGTYPE_p_lldb__SBFrame); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->GetValueForVariablePath((char const *)arg2); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_GetValueForVariablePath(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + return _wrap_SBFrame_GetValueForVariablePath__SWIG_1(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + return _wrap_SBFrame_GetValueForVariablePath__SWIG_0(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBFrame_FindValue__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + char *arg2 = (char *) 0 ; + lldb::ValueType arg3 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBFrame::FindValue",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::FindValue",1,"lldb::SBFrame *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBFrame::FindValue",2,"char const *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBFrame::FindValue",3,"lldb::ValueType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_FindValue",1,SWIGTYPE_p_lldb__SBFrame); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (lldb::ValueType)lua_tointeger(L, 3); + result = (arg1)->FindValue((char const *)arg2,arg3); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_FindValue__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + char *arg2 = (char *) 0 ; + lldb::ValueType arg3 ; + lldb::DynamicValueType arg4 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBFrame::FindValue",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::FindValue",1,"lldb::SBFrame *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBFrame::FindValue",2,"char const *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBFrame::FindValue",3,"lldb::ValueType"); + if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBFrame::FindValue",4,"lldb::DynamicValueType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_FindValue",1,SWIGTYPE_p_lldb__SBFrame); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (lldb::ValueType)lua_tointeger(L, 3); + arg4 = (lldb::DynamicValueType)lua_tointeger(L, 4); + result = (arg1)->FindValue((char const *)arg2,arg3,arg4); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_FindValue(lua_State* L) { + int argc; + int argv[5]={ + 1,2,3,4,5 + }; + + argc = lua_gettop(L); + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + return _wrap_SBFrame_FindValue__SWIG_0(L); + } + } + } + } + if (argc == 4) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[3]); + } + if (_v) { + return _wrap_SBFrame_FindValue__SWIG_1(L); + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBFrame_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBFrame::GetDescription",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetDescription",1,"lldb::SBFrame *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBFrame::GetDescription",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_GetDescription",1,SWIGTYPE_p_lldb__SBFrame); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBFrame_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)(arg1)->GetDescription(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame_GetDescriptionWithFormat(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + lldb::SBFormat *arg2 = 0 ; + lldb::SBStream *arg3 = 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBFrame::GetDescriptionWithFormat",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::GetDescriptionWithFormat",1,"lldb::SBFrame *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBFrame::GetDescriptionWithFormat",2,"lldb::SBFormat const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBFrame::GetDescriptionWithFormat",3,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame_GetDescriptionWithFormat",1,SWIGTYPE_p_lldb__SBFrame); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFormat,0))){ + SWIG_fail_ptr("SBFrame_GetDescriptionWithFormat",2,SWIGTYPE_p_lldb__SBFormat); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBFrame_GetDescriptionWithFormat",3,SWIGTYPE_p_lldb__SBStream); + } + + result = (arg1)->GetDescriptionWithFormat((lldb::SBFormat const &)*arg2,*arg3); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFrame___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFrame *arg1 = (lldb::SBFrame *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBFrame::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFrame::__repr__",1,"lldb::SBFrame *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBFrame___tostring",1,SWIGTYPE_p_lldb__SBFrame); + } + + result = lldb_SBFrame___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBFrame(void *obj) { +lldb::SBFrame *arg1 = (lldb::SBFrame *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBFrame(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBFrame); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBFrame_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBFrame_methods[]= { + { "IsEqual", _wrap_SBFrame_IsEqual}, + { "IsValid", _wrap_SBFrame_IsValid}, + { "GetFrameID", _wrap_SBFrame_GetFrameID}, + { "GetCFA", _wrap_SBFrame_GetCFA}, + { "GetPC", _wrap_SBFrame_GetPC}, + { "SetPC", _wrap_SBFrame_SetPC}, + { "GetSP", _wrap_SBFrame_GetSP}, + { "GetFP", _wrap_SBFrame_GetFP}, + { "GetPCAddress", _wrap_SBFrame_GetPCAddress}, + { "GetSymbolContext", _wrap_SBFrame_GetSymbolContext}, + { "GetModule", _wrap_SBFrame_GetModule}, + { "GetCompileUnit", _wrap_SBFrame_GetCompileUnit}, + { "GetFunction", _wrap_SBFrame_GetFunction}, + { "GetSymbol", _wrap_SBFrame_GetSymbol}, + { "GetBlock", _wrap_SBFrame_GetBlock}, + { "GetDisplayFunctionName", _wrap_SBFrame_GetDisplayFunctionName}, + { "GetFunctionName", _wrap_SBFrame_GetFunctionName}, + { "GuessLanguage", _wrap_SBFrame_GuessLanguage}, + { "IsInlined", _wrap_SBFrame_IsInlined}, + { "IsArtificial", _wrap_SBFrame_IsArtificial}, + { "EvaluateExpression", _wrap_SBFrame_EvaluateExpression}, + { "GetFrameBlock", _wrap_SBFrame_GetFrameBlock}, + { "GetLineEntry", _wrap_SBFrame_GetLineEntry}, + { "GetThread", _wrap_SBFrame_GetThread}, + { "Disassemble", _wrap_SBFrame_Disassemble}, + { "Clear", _wrap_SBFrame_Clear}, + { "__eq", _wrap_SBFrame___eq}, + { "GetVariables", _wrap_SBFrame_GetVariables}, + { "GetRegisters", _wrap_SBFrame_GetRegisters}, + { "FindRegister", _wrap_SBFrame_FindRegister}, + { "FindVariable", _wrap_SBFrame_FindVariable}, + { "GetValueForVariablePath", _wrap_SBFrame_GetValueForVariablePath}, + { "FindValue", _wrap_SBFrame_FindValue}, + { "GetDescription", _wrap_SBFrame_GetDescription}, + { "GetDescriptionWithFormat", _wrap_SBFrame_GetDescriptionWithFormat}, + { "__tostring", _wrap_SBFrame___tostring}, + {0,0} +}; +static swig_lua_method swig_SBFrame_meta[] = { + { "__eq", _wrap_SBFrame___eq}, + { "__tostring", _wrap_SBFrame___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBFrame_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBFrame_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBFrame_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBFrame_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBFrame_Sf_SwigStatic = { + "SBFrame", + swig_SBFrame_Sf_SwigStatic_methods, + swig_SBFrame_Sf_SwigStatic_attributes, + swig_SBFrame_Sf_SwigStatic_constants, + swig_SBFrame_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBFrame_bases[] = {0}; +static const char *swig_SBFrame_base_names[] = {0}; +static swig_lua_class _wrap_class_SBFrame = { "SBFrame", "SBFrame", &SWIGTYPE_p_lldb__SBFrame,_proxy__wrap_new_SBFrame, swig_delete_SBFrame, swig_SBFrame_methods, swig_SBFrame_attributes, &swig_SBFrame_Sf_SwigStatic, swig_SBFrame_meta, swig_SBFrame_bases, swig_SBFrame_base_names }; + +static int _wrap_new_SBFunction__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFunction *result = 0 ; + + SWIG_check_num_args("lldb::SBFunction::SBFunction",0,0) + result = (lldb::SBFunction *)new lldb::SBFunction(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBFunction,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBFunction__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFunction *arg1 = 0 ; + lldb::SBFunction *result = 0 ; + + SWIG_check_num_args("lldb::SBFunction::SBFunction",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBFunction::SBFunction",1,"lldb::SBFunction const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){ + SWIG_fail_ptr("new_SBFunction",1,SWIGTYPE_p_lldb__SBFunction); + } + + result = (lldb::SBFunction *)new lldb::SBFunction((lldb::SBFunction const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBFunction,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBFunction(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBFunction__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFunction, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBFunction__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBFunction'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBFunction::SBFunction()\n" + " lldb::SBFunction::SBFunction(lldb::SBFunction const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBFunction_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBFunction::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFunction::IsValid",1,"lldb::SBFunction const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){ + SWIG_fail_ptr("SBFunction_IsValid",1,SWIGTYPE_p_lldb__SBFunction); + } + + result = (bool)((lldb::SBFunction const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFunction_GetName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBFunction::GetName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFunction::GetName",1,"lldb::SBFunction const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){ + SWIG_fail_ptr("SBFunction_GetName",1,SWIGTYPE_p_lldb__SBFunction); + } + + result = (char *)((lldb::SBFunction const *)arg1)->GetName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFunction_GetDisplayName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBFunction::GetDisplayName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFunction::GetDisplayName",1,"lldb::SBFunction const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){ + SWIG_fail_ptr("SBFunction_GetDisplayName",1,SWIGTYPE_p_lldb__SBFunction); + } + + result = (char *)((lldb::SBFunction const *)arg1)->GetDisplayName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFunction_GetMangledName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBFunction::GetMangledName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFunction::GetMangledName",1,"lldb::SBFunction const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){ + SWIG_fail_ptr("SBFunction_GetMangledName",1,SWIGTYPE_p_lldb__SBFunction); + } + + result = (char *)((lldb::SBFunction const *)arg1)->GetMangledName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFunction_GetInstructions__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + lldb::SBTarget arg2 ; + lldb::SBTarget *argp2 ; + lldb::SBInstructionList result; + + SWIG_check_num_args("lldb::SBFunction::GetInstructions",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFunction::GetInstructions",1,"lldb::SBFunction *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBFunction::GetInstructions",2,"lldb::SBTarget"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){ + SWIG_fail_ptr("SBFunction_GetInstructions",1,SWIGTYPE_p_lldb__SBFunction); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBFunction_GetInstructions",2,SWIGTYPE_p_lldb__SBTarget); + } + arg2 = *argp2; + + result = (arg1)->GetInstructions(arg2); + { + lldb::SBInstructionList * resultptr = new lldb::SBInstructionList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBInstructionList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFunction_GetInstructions__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + lldb::SBTarget arg2 ; + char *arg3 = (char *) 0 ; + lldb::SBTarget *argp2 ; + lldb::SBInstructionList result; + + SWIG_check_num_args("lldb::SBFunction::GetInstructions",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFunction::GetInstructions",1,"lldb::SBFunction *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBFunction::GetInstructions",2,"lldb::SBTarget"); + if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBFunction::GetInstructions",3,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){ + SWIG_fail_ptr("SBFunction_GetInstructions",1,SWIGTYPE_p_lldb__SBFunction); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBFunction_GetInstructions",2,SWIGTYPE_p_lldb__SBTarget); + } + arg2 = *argp2; + + arg3 = (char *)lua_tostring(L, 3); + result = (arg1)->GetInstructions(arg2,(char const *)arg3); + { + lldb::SBInstructionList * resultptr = new lldb::SBInstructionList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBInstructionList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFunction_GetInstructions(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFunction, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBFunction_GetInstructions__SWIG_0(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBFunction, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[2]); + } + if (_v) { + return _wrap_SBFunction_GetInstructions__SWIG_1(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBFunction_GetStartAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + lldb::SBAddress result; + + SWIG_check_num_args("lldb::SBFunction::GetStartAddress",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFunction::GetStartAddress",1,"lldb::SBFunction *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){ + SWIG_fail_ptr("SBFunction_GetStartAddress",1,SWIGTYPE_p_lldb__SBFunction); + } + + result = (arg1)->GetStartAddress(); + { + lldb::SBAddress * resultptr = new lldb::SBAddress(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFunction_GetEndAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + lldb::SBAddress result; + + SWIG_check_num_args("lldb::SBFunction::GetEndAddress",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFunction::GetEndAddress",1,"lldb::SBFunction *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){ + SWIG_fail_ptr("SBFunction_GetEndAddress",1,SWIGTYPE_p_lldb__SBFunction); + } + + result = (arg1)->GetEndAddress(); + { + lldb::SBAddress * resultptr = new lldb::SBAddress(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFunction_GetRanges(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + lldb::SBAddressRangeList result; + + SWIG_check_num_args("lldb::SBFunction::GetRanges",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFunction::GetRanges",1,"lldb::SBFunction *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){ + SWIG_fail_ptr("SBFunction_GetRanges",1,SWIGTYPE_p_lldb__SBFunction); + } + + result = (arg1)->GetRanges(); + { + lldb::SBAddressRangeList * resultptr = new lldb::SBAddressRangeList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddressRangeList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFunction_GetArgumentName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + uint32_t arg2 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBFunction::GetArgumentName",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFunction::GetArgumentName",1,"lldb::SBFunction *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBFunction::GetArgumentName",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){ + SWIG_fail_ptr("SBFunction_GetArgumentName",1,SWIGTYPE_p_lldb__SBFunction); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (char *)(arg1)->GetArgumentName(arg2); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFunction_GetPrologueByteSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBFunction::GetPrologueByteSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFunction::GetPrologueByteSize",1,"lldb::SBFunction *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){ + SWIG_fail_ptr("SBFunction_GetPrologueByteSize",1,SWIGTYPE_p_lldb__SBFunction); + } + + result = (uint32_t)(arg1)->GetPrologueByteSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFunction_GetType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + lldb::SBType result; + + SWIG_check_num_args("lldb::SBFunction::GetType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFunction::GetType",1,"lldb::SBFunction *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){ + SWIG_fail_ptr("SBFunction_GetType",1,SWIGTYPE_p_lldb__SBFunction); + } + + result = (arg1)->GetType(); + { + lldb::SBType * resultptr = new lldb::SBType(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFunction_GetBlock(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + lldb::SBBlock result; + + SWIG_check_num_args("lldb::SBFunction::GetBlock",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFunction::GetBlock",1,"lldb::SBFunction *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){ + SWIG_fail_ptr("SBFunction_GetBlock",1,SWIGTYPE_p_lldb__SBFunction); + } + + result = (arg1)->GetBlock(); + { + lldb::SBBlock * resultptr = new lldb::SBBlock(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBlock,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFunction_GetLanguage(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + lldb::LanguageType result; + + SWIG_check_num_args("lldb::SBFunction::GetLanguage",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFunction::GetLanguage",1,"lldb::SBFunction *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){ + SWIG_fail_ptr("SBFunction_GetLanguage",1,SWIGTYPE_p_lldb__SBFunction); + } + + result = (lldb::LanguageType)(arg1)->GetLanguage(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFunction_GetIsOptimized(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBFunction::GetIsOptimized",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFunction::GetIsOptimized",1,"lldb::SBFunction *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){ + SWIG_fail_ptr("SBFunction_GetIsOptimized",1,SWIGTYPE_p_lldb__SBFunction); + } + + result = (bool)(arg1)->GetIsOptimized(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFunction___eq(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + lldb::SBFunction *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBFunction::operator ==",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFunction::operator ==",1,"lldb::SBFunction const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBFunction::operator ==",2,"lldb::SBFunction const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){ + SWIG_fail_ptr("SBFunction___eq",1,SWIGTYPE_p_lldb__SBFunction); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFunction,0))){ + SWIG_fail_ptr("SBFunction___eq",2,SWIGTYPE_p_lldb__SBFunction); + } + + result = (bool)((lldb::SBFunction const *)arg1)->operator ==((lldb::SBFunction const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFunction_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBFunction::GetDescription",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFunction::GetDescription",1,"lldb::SBFunction *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBFunction::GetDescription",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){ + SWIG_fail_ptr("SBFunction_GetDescription",1,SWIGTYPE_p_lldb__SBFunction); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBFunction_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)(arg1)->GetDescription(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBFunction___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFunction *arg1 = (lldb::SBFunction *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBFunction::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBFunction::__repr__",1,"lldb::SBFunction *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBFunction,0))){ + SWIG_fail_ptr("SBFunction___tostring",1,SWIGTYPE_p_lldb__SBFunction); + } + + result = lldb_SBFunction___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBFunction(void *obj) { +lldb::SBFunction *arg1 = (lldb::SBFunction *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBFunction(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBFunction); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBFunction_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBFunction_methods[]= { + { "IsValid", _wrap_SBFunction_IsValid}, + { "GetName", _wrap_SBFunction_GetName}, + { "GetDisplayName", _wrap_SBFunction_GetDisplayName}, + { "GetMangledName", _wrap_SBFunction_GetMangledName}, + { "GetInstructions", _wrap_SBFunction_GetInstructions}, + { "GetStartAddress", _wrap_SBFunction_GetStartAddress}, + { "GetEndAddress", _wrap_SBFunction_GetEndAddress}, + { "GetRanges", _wrap_SBFunction_GetRanges}, + { "GetArgumentName", _wrap_SBFunction_GetArgumentName}, + { "GetPrologueByteSize", _wrap_SBFunction_GetPrologueByteSize}, + { "GetType", _wrap_SBFunction_GetType}, + { "GetBlock", _wrap_SBFunction_GetBlock}, + { "GetLanguage", _wrap_SBFunction_GetLanguage}, + { "GetIsOptimized", _wrap_SBFunction_GetIsOptimized}, + { "__eq", _wrap_SBFunction___eq}, + { "GetDescription", _wrap_SBFunction_GetDescription}, + { "__tostring", _wrap_SBFunction___tostring}, + {0,0} +}; +static swig_lua_method swig_SBFunction_meta[] = { + { "__eq", _wrap_SBFunction___eq}, + { "__tostring", _wrap_SBFunction___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBFunction_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBFunction_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBFunction_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBFunction_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBFunction_Sf_SwigStatic = { + "SBFunction", + swig_SBFunction_Sf_SwigStatic_methods, + swig_SBFunction_Sf_SwigStatic_attributes, + swig_SBFunction_Sf_SwigStatic_constants, + swig_SBFunction_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBFunction_bases[] = {0}; +static const char *swig_SBFunction_base_names[] = {0}; +static swig_lua_class _wrap_class_SBFunction = { "SBFunction", "SBFunction", &SWIGTYPE_p_lldb__SBFunction,_proxy__wrap_new_SBFunction, swig_delete_SBFunction, swig_SBFunction_methods, swig_SBFunction_attributes, &swig_SBFunction_Sf_SwigStatic, swig_SBFunction_meta, swig_SBFunction_bases, swig_SBFunction_base_names }; + +static int _wrap_SBHostOS_GetProgramFileSpec(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFileSpec result; + + SWIG_check_num_args("lldb::SBHostOS::GetProgramFileSpec",0,0) + result = lldb::SBHostOS::GetProgramFileSpec(); + { + lldb::SBFileSpec * resultptr = new lldb::SBFileSpec(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBHostOS_GetLLDBPythonPath(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFileSpec result; + + SWIG_check_num_args("lldb::SBHostOS::GetLLDBPythonPath",0,0) + result = lldb::SBHostOS::GetLLDBPythonPath(); + { + lldb::SBFileSpec * resultptr = new lldb::SBFileSpec(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBHostOS_GetLLDBPath(lua_State* L) { + { + int SWIG_arg = 0; + lldb::PathType arg1 ; + lldb::SBFileSpec result; + + SWIG_check_num_args("lldb::SBHostOS::GetLLDBPath",1,1) + if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBHostOS::GetLLDBPath",1,"lldb::PathType"); + arg1 = (lldb::PathType)lua_tointeger(L, 1); + result = lldb::SBHostOS::GetLLDBPath(arg1); + { + lldb::SBFileSpec * resultptr = new lldb::SBFileSpec(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBHostOS_GetUserHomeDirectory(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBFileSpec result; + + SWIG_check_num_args("lldb::SBHostOS::GetUserHomeDirectory",0,0) + result = lldb::SBHostOS::GetUserHomeDirectory(); + { + lldb::SBFileSpec * resultptr = new lldb::SBFileSpec(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBHostOS_ThreadCreated(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBHostOS::ThreadCreated",1,1) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBHostOS::ThreadCreated",1,"char const *"); + arg1 = (char *)lua_tostring(L, 1); + lldb::SBHostOS::ThreadCreated((char const *)arg1); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBHostOS_ThreadCreate(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + lldb::thread_func_t arg2 = (lldb::thread_func_t) 0 ; + void *arg3 = (void *) 0 ; + lldb::SBError *arg4 = (lldb::SBError *) 0 ; + lldb::thread_t result; + + SWIG_check_num_args("lldb::SBHostOS::ThreadCreate",4,4) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBHostOS::ThreadCreate",1,"char const *"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("lldb::SBHostOS::ThreadCreate",2,"lldb::thread_func_t"); + if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("lldb::SBHostOS::ThreadCreate",3,"void *"); + if(!SWIG_isptrtype(L,4)) SWIG_fail_arg("lldb::SBHostOS::ThreadCreate",4,"lldb::SBError *"); + arg1 = (char *)lua_tostring(L, 1); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_f_p_void__p_void,0))){ + SWIG_fail_ptr("SBHostOS_ThreadCreate",2,SWIGTYPE_p_f_p_void__p_void); + } + + arg3=(void *)SWIG_MustGetPtr(L,3,0,0,3,"SBHostOS_ThreadCreate"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBHostOS_ThreadCreate",4,SWIGTYPE_p_lldb__SBError); + } + + result = lldb::SBHostOS::ThreadCreate((char const *)arg1,arg2,arg3,arg4); + { + lldb::thread_t * resultptr = new lldb::thread_t(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_pthread_t,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBHostOS_ThreadCancel(lua_State* L) { + { + int SWIG_arg = 0; + lldb::thread_t arg1 ; + lldb::SBError *arg2 = (lldb::SBError *) 0 ; + lldb::thread_t *argp1 ; + bool result; + + SWIG_check_num_args("lldb::SBHostOS::ThreadCancel",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBHostOS::ThreadCancel",1,"lldb::thread_t"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("lldb::SBHostOS::ThreadCancel",2,"lldb::SBError *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&argp1,SWIGTYPE_p_pthread_t,0))){ + SWIG_fail_ptr("SBHostOS_ThreadCancel",1,SWIGTYPE_p_pthread_t); + } + arg1 = *argp1; + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBHostOS_ThreadCancel",2,SWIGTYPE_p_lldb__SBError); + } + + result = (bool)lldb::SBHostOS::ThreadCancel(SWIG_STD_MOVE(arg1),arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBHostOS_ThreadDetach(lua_State* L) { + { + int SWIG_arg = 0; + lldb::thread_t arg1 ; + lldb::SBError *arg2 = (lldb::SBError *) 0 ; + lldb::thread_t *argp1 ; + bool result; + + SWIG_check_num_args("lldb::SBHostOS::ThreadDetach",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBHostOS::ThreadDetach",1,"lldb::thread_t"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("lldb::SBHostOS::ThreadDetach",2,"lldb::SBError *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&argp1,SWIGTYPE_p_pthread_t,0))){ + SWIG_fail_ptr("SBHostOS_ThreadDetach",1,SWIGTYPE_p_pthread_t); + } + arg1 = *argp1; + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBHostOS_ThreadDetach",2,SWIGTYPE_p_lldb__SBError); + } + + result = (bool)lldb::SBHostOS::ThreadDetach(SWIG_STD_MOVE(arg1),arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBHostOS_ThreadJoin(lua_State* L) { + { + int SWIG_arg = 0; + lldb::thread_t arg1 ; + lldb::thread_result_t *arg2 = (lldb::thread_result_t *) 0 ; + lldb::SBError *arg3 = (lldb::SBError *) 0 ; + lldb::thread_t *argp1 ; + bool result; + + SWIG_check_num_args("lldb::SBHostOS::ThreadJoin",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBHostOS::ThreadJoin",1,"lldb::thread_t"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("lldb::SBHostOS::ThreadJoin",2,"lldb::thread_result_t *"); + if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("lldb::SBHostOS::ThreadJoin",3,"lldb::SBError *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&argp1,SWIGTYPE_p_pthread_t,0))){ + SWIG_fail_ptr("SBHostOS_ThreadJoin",1,SWIGTYPE_p_pthread_t); + } + arg1 = *argp1; + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_p_void,0))){ + SWIG_fail_ptr("SBHostOS_ThreadJoin",2,SWIGTYPE_p_p_void); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBHostOS_ThreadJoin",3,SWIGTYPE_p_lldb__SBError); + } + + result = (bool)lldb::SBHostOS::ThreadJoin(SWIG_STD_MOVE(arg1),arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBHostOS(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBHostOS *result = 0 ; + + SWIG_check_num_args("lldb::SBHostOS::SBHostOS",0,0) + result = (lldb::SBHostOS *)new lldb::SBHostOS(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBHostOS,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBHostOS(void *obj) { +lldb::SBHostOS *arg1 = (lldb::SBHostOS *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBHostOS(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBHostOS); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBHostOS_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBHostOS_methods[]= { + {0,0} +}; +static swig_lua_method swig_SBHostOS_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBHostOS_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBHostOS_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBHostOS_Sf_SwigStatic_methods[]= { + { "GetProgramFileSpec", _wrap_SBHostOS_GetProgramFileSpec}, + { "GetLLDBPythonPath", _wrap_SBHostOS_GetLLDBPythonPath}, + { "GetLLDBPath", _wrap_SBHostOS_GetLLDBPath}, + { "GetUserHomeDirectory", _wrap_SBHostOS_GetUserHomeDirectory}, + { "ThreadCreated", _wrap_SBHostOS_ThreadCreated}, + { "ThreadCreate", _wrap_SBHostOS_ThreadCreate}, + { "ThreadCancel", _wrap_SBHostOS_ThreadCancel}, + { "ThreadDetach", _wrap_SBHostOS_ThreadDetach}, + { "ThreadJoin", _wrap_SBHostOS_ThreadJoin}, + {0,0} +}; +static swig_lua_class* swig_SBHostOS_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBHostOS_Sf_SwigStatic = { + "SBHostOS", + swig_SBHostOS_Sf_SwigStatic_methods, + swig_SBHostOS_Sf_SwigStatic_attributes, + swig_SBHostOS_Sf_SwigStatic_constants, + swig_SBHostOS_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBHostOS_bases[] = {0}; +static const char *swig_SBHostOS_base_names[] = {0}; +static swig_lua_class _wrap_class_SBHostOS = { "SBHostOS", "SBHostOS", &SWIGTYPE_p_lldb__SBHostOS,_proxy__wrap_new_SBHostOS, swig_delete_SBHostOS, swig_SBHostOS_methods, swig_SBHostOS_attributes, &swig_SBHostOS_Sf_SwigStatic, swig_SBHostOS_meta, swig_SBHostOS_bases, swig_SBHostOS_base_names }; + +static int _wrap_new_SBInstruction__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBInstruction *result = 0 ; + + SWIG_check_num_args("lldb::SBInstruction::SBInstruction",0,0) + result = (lldb::SBInstruction *)new lldb::SBInstruction(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBInstruction,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBInstruction__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBInstruction *arg1 = 0 ; + lldb::SBInstruction *result = 0 ; + + SWIG_check_num_args("lldb::SBInstruction::SBInstruction",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBInstruction::SBInstruction",1,"lldb::SBInstruction const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){ + SWIG_fail_ptr("new_SBInstruction",1,SWIGTYPE_p_lldb__SBInstruction); + } + + result = (lldb::SBInstruction *)new lldb::SBInstruction((lldb::SBInstruction const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBInstruction,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBInstruction(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBInstruction__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBInstruction, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBInstruction__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBInstruction'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBInstruction::SBInstruction()\n" + " lldb::SBInstruction::SBInstruction(lldb::SBInstruction const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBInstruction_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBInstruction::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstruction::IsValid",1,"lldb::SBInstruction *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){ + SWIG_fail_ptr("SBInstruction_IsValid",1,SWIGTYPE_p_lldb__SBInstruction); + } + + result = (bool)(arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBInstruction_GetAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + lldb::SBAddress result; + + SWIG_check_num_args("lldb::SBInstruction::GetAddress",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstruction::GetAddress",1,"lldb::SBInstruction *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){ + SWIG_fail_ptr("SBInstruction_GetAddress",1,SWIGTYPE_p_lldb__SBInstruction); + } + + result = (arg1)->GetAddress(); + { + lldb::SBAddress * resultptr = new lldb::SBAddress(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBInstruction_GetMnemonic(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + lldb::SBTarget arg2 ; + lldb::SBTarget *argp2 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBInstruction::GetMnemonic",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstruction::GetMnemonic",1,"lldb::SBInstruction *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBInstruction::GetMnemonic",2,"lldb::SBTarget"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){ + SWIG_fail_ptr("SBInstruction_GetMnemonic",1,SWIGTYPE_p_lldb__SBInstruction); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBInstruction_GetMnemonic",2,SWIGTYPE_p_lldb__SBTarget); + } + arg2 = *argp2; + + result = (char *)(arg1)->GetMnemonic(arg2); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBInstruction_GetOperands(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + lldb::SBTarget arg2 ; + lldb::SBTarget *argp2 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBInstruction::GetOperands",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstruction::GetOperands",1,"lldb::SBInstruction *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBInstruction::GetOperands",2,"lldb::SBTarget"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){ + SWIG_fail_ptr("SBInstruction_GetOperands",1,SWIGTYPE_p_lldb__SBInstruction); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBInstruction_GetOperands",2,SWIGTYPE_p_lldb__SBTarget); + } + arg2 = *argp2; + + result = (char *)(arg1)->GetOperands(arg2); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBInstruction_GetComment(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + lldb::SBTarget arg2 ; + lldb::SBTarget *argp2 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBInstruction::GetComment",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstruction::GetComment",1,"lldb::SBInstruction *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBInstruction::GetComment",2,"lldb::SBTarget"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){ + SWIG_fail_ptr("SBInstruction_GetComment",1,SWIGTYPE_p_lldb__SBInstruction); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBInstruction_GetComment",2,SWIGTYPE_p_lldb__SBTarget); + } + arg2 = *argp2; + + result = (char *)(arg1)->GetComment(arg2); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBInstruction_GetControlFlowKind(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + lldb::SBTarget arg2 ; + lldb::SBTarget *argp2 ; + lldb::InstructionControlFlowKind result; + + SWIG_check_num_args("lldb::SBInstruction::GetControlFlowKind",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstruction::GetControlFlowKind",1,"lldb::SBInstruction *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBInstruction::GetControlFlowKind",2,"lldb::SBTarget"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){ + SWIG_fail_ptr("SBInstruction_GetControlFlowKind",1,SWIGTYPE_p_lldb__SBInstruction); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBInstruction_GetControlFlowKind",2,SWIGTYPE_p_lldb__SBTarget); + } + arg2 = *argp2; + + result = (lldb::InstructionControlFlowKind)(arg1)->GetControlFlowKind(arg2); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBInstruction_GetData(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + lldb::SBTarget arg2 ; + lldb::SBTarget *argp2 ; + lldb::SBData result; + + SWIG_check_num_args("lldb::SBInstruction::GetData",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstruction::GetData",1,"lldb::SBInstruction *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBInstruction::GetData",2,"lldb::SBTarget"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){ + SWIG_fail_ptr("SBInstruction_GetData",1,SWIGTYPE_p_lldb__SBInstruction); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBInstruction_GetData",2,SWIGTYPE_p_lldb__SBTarget); + } + arg2 = *argp2; + + result = (arg1)->GetData(arg2); + { + lldb::SBData * resultptr = new lldb::SBData(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBData,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBInstruction_GetByteSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + size_t result; + + SWIG_check_num_args("lldb::SBInstruction::GetByteSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstruction::GetByteSize",1,"lldb::SBInstruction *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){ + SWIG_fail_ptr("SBInstruction_GetByteSize",1,SWIGTYPE_p_lldb__SBInstruction); + } + + result = (arg1)->GetByteSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBInstruction_DoesBranch(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBInstruction::DoesBranch",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstruction::DoesBranch",1,"lldb::SBInstruction *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){ + SWIG_fail_ptr("SBInstruction_DoesBranch",1,SWIGTYPE_p_lldb__SBInstruction); + } + + result = (bool)(arg1)->DoesBranch(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBInstruction_HasDelaySlot(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBInstruction::HasDelaySlot",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstruction::HasDelaySlot",1,"lldb::SBInstruction *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){ + SWIG_fail_ptr("SBInstruction_HasDelaySlot",1,SWIGTYPE_p_lldb__SBInstruction); + } + + result = (bool)(arg1)->HasDelaySlot(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBInstruction_CanSetBreakpoint(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBInstruction::CanSetBreakpoint",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstruction::CanSetBreakpoint",1,"lldb::SBInstruction *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){ + SWIG_fail_ptr("SBInstruction_CanSetBreakpoint",1,SWIGTYPE_p_lldb__SBInstruction); + } + + result = (bool)(arg1)->CanSetBreakpoint(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBInstruction_Print__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + lldb::SBFile arg2 ; + lldb::SBFile *argp2 ; + + SWIG_check_num_args("lldb::SBInstruction::Print",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstruction::Print",1,"lldb::SBInstruction *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBInstruction::Print",2,"lldb::SBFile"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){ + SWIG_fail_ptr("SBInstruction_Print",1,SWIGTYPE_p_lldb__SBInstruction); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBFile,0))){ + SWIG_fail_ptr("SBInstruction_Print",2,SWIGTYPE_p_lldb__SBFile); + } + arg2 = *argp2; + + (arg1)->Print(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBInstruction_Print__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ; + + SWIG_check_num_args("lldb::SBInstruction::Print",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstruction::Print",1,"lldb::SBInstruction *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){ + SWIG_fail_ptr("SBInstruction_Print",1,SWIGTYPE_p_lldb__SBInstruction); + } + + { + luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 2, LUA_FILEHANDLE); + lldb::FileSP file_sp; + file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false); + if (!file_sp->IsValid()) + return luaL_error(L, "Invalid file"); + arg2 = file_sp; + } + (arg1)->Print(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBInstruction_Print(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBInstruction, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBInstruction_Print__SWIG_0(L); + } + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBInstruction, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = (lua_isuserdata(L, argv[1])) && + (luaL_testudata(L, argv[1], LUA_FILEHANDLE) != nullptr); + } + if (_v) { + return _wrap_SBInstruction_Print__SWIG_1(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBInstruction_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBInstruction::GetDescription",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstruction::GetDescription",1,"lldb::SBInstruction *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBInstruction::GetDescription",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){ + SWIG_fail_ptr("SBInstruction_GetDescription",1,SWIGTYPE_p_lldb__SBInstruction); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBInstruction_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)(arg1)->GetDescription(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBInstruction_EmulateWithFrame(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + lldb::SBFrame *arg2 = 0 ; + uint32_t arg3 ; + bool result; + + SWIG_check_num_args("lldb::SBInstruction::EmulateWithFrame",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstruction::EmulateWithFrame",1,"lldb::SBInstruction *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBInstruction::EmulateWithFrame",2,"lldb::SBFrame &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBInstruction::EmulateWithFrame",3,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){ + SWIG_fail_ptr("SBInstruction_EmulateWithFrame",1,SWIGTYPE_p_lldb__SBInstruction); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBInstruction_EmulateWithFrame",2,SWIGTYPE_p_lldb__SBFrame); + } + + arg3 = (uint32_t)lua_tointeger(L, 3); + result = (bool)(arg1)->EmulateWithFrame(*arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBInstruction_DumpEmulation(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + char *arg2 = (char *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBInstruction::DumpEmulation",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstruction::DumpEmulation",1,"lldb::SBInstruction *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBInstruction::DumpEmulation",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){ + SWIG_fail_ptr("SBInstruction_DumpEmulation",1,SWIGTYPE_p_lldb__SBInstruction); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (bool)(arg1)->DumpEmulation((char const *)arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBInstruction_TestEmulation(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + lldb::SBStream *arg2 = 0 ; + char *arg3 = (char *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBInstruction::TestEmulation",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstruction::TestEmulation",1,"lldb::SBInstruction *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBInstruction::TestEmulation",2,"lldb::SBStream &"); + if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBInstruction::TestEmulation",3,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){ + SWIG_fail_ptr("SBInstruction_TestEmulation",1,SWIGTYPE_p_lldb__SBInstruction); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBInstruction_TestEmulation",2,SWIGTYPE_p_lldb__SBStream); + } + + arg3 = (char *)lua_tostring(L, 3); + result = (bool)(arg1)->TestEmulation(*arg2,(char const *)arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBInstruction___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBInstruction *arg1 = (lldb::SBInstruction *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBInstruction::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstruction::__repr__",1,"lldb::SBInstruction *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstruction,0))){ + SWIG_fail_ptr("SBInstruction___tostring",1,SWIGTYPE_p_lldb__SBInstruction); + } + + result = lldb_SBInstruction___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBInstruction(void *obj) { +lldb::SBInstruction *arg1 = (lldb::SBInstruction *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBInstruction(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBInstruction); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBInstruction_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBInstruction_methods[]= { + { "IsValid", _wrap_SBInstruction_IsValid}, + { "GetAddress", _wrap_SBInstruction_GetAddress}, + { "GetMnemonic", _wrap_SBInstruction_GetMnemonic}, + { "GetOperands", _wrap_SBInstruction_GetOperands}, + { "GetComment", _wrap_SBInstruction_GetComment}, + { "GetControlFlowKind", _wrap_SBInstruction_GetControlFlowKind}, + { "GetData", _wrap_SBInstruction_GetData}, + { "GetByteSize", _wrap_SBInstruction_GetByteSize}, + { "DoesBranch", _wrap_SBInstruction_DoesBranch}, + { "HasDelaySlot", _wrap_SBInstruction_HasDelaySlot}, + { "CanSetBreakpoint", _wrap_SBInstruction_CanSetBreakpoint}, + { "Print", _wrap_SBInstruction_Print}, + { "GetDescription", _wrap_SBInstruction_GetDescription}, + { "EmulateWithFrame", _wrap_SBInstruction_EmulateWithFrame}, + { "DumpEmulation", _wrap_SBInstruction_DumpEmulation}, + { "TestEmulation", _wrap_SBInstruction_TestEmulation}, + { "__tostring", _wrap_SBInstruction___tostring}, + {0,0} +}; +static swig_lua_method swig_SBInstruction_meta[] = { + { "__tostring", _wrap_SBInstruction___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBInstruction_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBInstruction_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBInstruction_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBInstruction_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBInstruction_Sf_SwigStatic = { + "SBInstruction", + swig_SBInstruction_Sf_SwigStatic_methods, + swig_SBInstruction_Sf_SwigStatic_attributes, + swig_SBInstruction_Sf_SwigStatic_constants, + swig_SBInstruction_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBInstruction_bases[] = {0}; +static const char *swig_SBInstruction_base_names[] = {0}; +static swig_lua_class _wrap_class_SBInstruction = { "SBInstruction", "SBInstruction", &SWIGTYPE_p_lldb__SBInstruction,_proxy__wrap_new_SBInstruction, swig_delete_SBInstruction, swig_SBInstruction_methods, swig_SBInstruction_attributes, &swig_SBInstruction_Sf_SwigStatic, swig_SBInstruction_meta, swig_SBInstruction_bases, swig_SBInstruction_base_names }; + +static int _wrap_new_SBInstructionList__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBInstructionList *result = 0 ; + + SWIG_check_num_args("lldb::SBInstructionList::SBInstructionList",0,0) + result = (lldb::SBInstructionList *)new lldb::SBInstructionList(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBInstructionList,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBInstructionList__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBInstructionList *arg1 = 0 ; + lldb::SBInstructionList *result = 0 ; + + SWIG_check_num_args("lldb::SBInstructionList::SBInstructionList",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBInstructionList::SBInstructionList",1,"lldb::SBInstructionList const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstructionList,0))){ + SWIG_fail_ptr("new_SBInstructionList",1,SWIGTYPE_p_lldb__SBInstructionList); + } + + result = (lldb::SBInstructionList *)new lldb::SBInstructionList((lldb::SBInstructionList const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBInstructionList,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBInstructionList(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBInstructionList__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBInstructionList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBInstructionList__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBInstructionList'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBInstructionList::SBInstructionList()\n" + " lldb::SBInstructionList::SBInstructionList(lldb::SBInstructionList const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBInstructionList_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBInstructionList::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstructionList::IsValid",1,"lldb::SBInstructionList const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstructionList,0))){ + SWIG_fail_ptr("SBInstructionList_IsValid",1,SWIGTYPE_p_lldb__SBInstructionList); + } + + result = (bool)((lldb::SBInstructionList const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBInstructionList_GetSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ; + size_t result; + + SWIG_check_num_args("lldb::SBInstructionList::GetSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstructionList::GetSize",1,"lldb::SBInstructionList *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstructionList,0))){ + SWIG_fail_ptr("SBInstructionList_GetSize",1,SWIGTYPE_p_lldb__SBInstructionList); + } + + result = (arg1)->GetSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBInstructionList_GetInstructionAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ; + uint32_t arg2 ; + lldb::SBInstruction result; + + SWIG_check_num_args("lldb::SBInstructionList::GetInstructionAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstructionList::GetInstructionAtIndex",1,"lldb::SBInstructionList *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBInstructionList::GetInstructionAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstructionList,0))){ + SWIG_fail_ptr("SBInstructionList_GetInstructionAtIndex",1,SWIGTYPE_p_lldb__SBInstructionList); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetInstructionAtIndex(arg2); + { + lldb::SBInstruction * resultptr = new lldb::SBInstruction(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBInstruction,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBInstructionList_GetInstructionsCount__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ; + lldb::SBAddress *arg2 = 0 ; + lldb::SBAddress *arg3 = 0 ; + bool arg4 ; + size_t result; + + SWIG_check_num_args("lldb::SBInstructionList::GetInstructionsCount",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstructionList::GetInstructionsCount",1,"lldb::SBInstructionList *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBInstructionList::GetInstructionsCount",2,"lldb::SBAddress const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBInstructionList::GetInstructionsCount",3,"lldb::SBAddress const &"); + if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBInstructionList::GetInstructionsCount",4,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstructionList,0))){ + SWIG_fail_ptr("SBInstructionList_GetInstructionsCount",1,SWIGTYPE_p_lldb__SBInstructionList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBInstructionList_GetInstructionsCount",2,SWIGTYPE_p_lldb__SBAddress); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBInstructionList_GetInstructionsCount",3,SWIGTYPE_p_lldb__SBAddress); + } + + arg4 = (lua_toboolean(L, 4)!=0); + result = (arg1)->GetInstructionsCount((lldb::SBAddress const &)*arg2,(lldb::SBAddress const &)*arg3,arg4); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBInstructionList_GetInstructionsCount__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ; + lldb::SBAddress *arg2 = 0 ; + lldb::SBAddress *arg3 = 0 ; + size_t result; + + SWIG_check_num_args("lldb::SBInstructionList::GetInstructionsCount",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstructionList::GetInstructionsCount",1,"lldb::SBInstructionList *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBInstructionList::GetInstructionsCount",2,"lldb::SBAddress const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBInstructionList::GetInstructionsCount",3,"lldb::SBAddress const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstructionList,0))){ + SWIG_fail_ptr("SBInstructionList_GetInstructionsCount",1,SWIGTYPE_p_lldb__SBInstructionList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBInstructionList_GetInstructionsCount",2,SWIGTYPE_p_lldb__SBAddress); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBInstructionList_GetInstructionsCount",3,SWIGTYPE_p_lldb__SBAddress); + } + + result = (arg1)->GetInstructionsCount((lldb::SBAddress const &)*arg2,(lldb::SBAddress const &)*arg3); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBInstructionList_GetInstructionsCount(lua_State* L) { + int argc; + int argv[5]={ + 1,2,3,4,5 + }; + + argc = lua_gettop(L); + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBInstructionList, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBInstructionList_GetInstructionsCount__SWIG_1(L); + } + } + } + } + if (argc == 4) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBInstructionList, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[3]); + } + if (_v) { + return _wrap_SBInstructionList_GetInstructionsCount__SWIG_0(L); + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBInstructionList_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ; + + SWIG_check_num_args("lldb::SBInstructionList::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstructionList::Clear",1,"lldb::SBInstructionList *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstructionList,0))){ + SWIG_fail_ptr("SBInstructionList_Clear",1,SWIGTYPE_p_lldb__SBInstructionList); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBInstructionList_AppendInstruction(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ; + lldb::SBInstruction arg2 ; + lldb::SBInstruction *argp2 ; + + SWIG_check_num_args("lldb::SBInstructionList::AppendInstruction",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstructionList::AppendInstruction",1,"lldb::SBInstructionList *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBInstructionList::AppendInstruction",2,"lldb::SBInstruction"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstructionList,0))){ + SWIG_fail_ptr("SBInstructionList_AppendInstruction",1,SWIGTYPE_p_lldb__SBInstructionList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBInstruction,0))){ + SWIG_fail_ptr("SBInstructionList_AppendInstruction",2,SWIGTYPE_p_lldb__SBInstruction); + } + arg2 = *argp2; + + (arg1)->AppendInstruction(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBInstructionList_Print__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ; + lldb::SBFile arg2 ; + lldb::SBFile *argp2 ; + + SWIG_check_num_args("lldb::SBInstructionList::Print",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstructionList::Print",1,"lldb::SBInstructionList *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBInstructionList::Print",2,"lldb::SBFile"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstructionList,0))){ + SWIG_fail_ptr("SBInstructionList_Print",1,SWIGTYPE_p_lldb__SBInstructionList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBFile,0))){ + SWIG_fail_ptr("SBInstructionList_Print",2,SWIGTYPE_p_lldb__SBFile); + } + arg2 = *argp2; + + (arg1)->Print(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBInstructionList_Print__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ; + SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ; + + SWIG_check_num_args("lldb::SBInstructionList::Print",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstructionList::Print",1,"lldb::SBInstructionList *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstructionList,0))){ + SWIG_fail_ptr("SBInstructionList_Print",1,SWIGTYPE_p_lldb__SBInstructionList); + } + + { + luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 2, LUA_FILEHANDLE); + lldb::FileSP file_sp; + file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false); + if (!file_sp->IsValid()) + return luaL_error(L, "Invalid file"); + arg2 = file_sp; + } + (arg1)->Print(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBInstructionList_Print(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBInstructionList, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBInstructionList_Print__SWIG_0(L); + } + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBInstructionList, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = (lua_isuserdata(L, argv[1])) && + (luaL_testudata(L, argv[1], LUA_FILEHANDLE) != nullptr); + } + if (_v) { + return _wrap_SBInstructionList_Print__SWIG_1(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBInstructionList_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBInstructionList::GetDescription",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstructionList::GetDescription",1,"lldb::SBInstructionList *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBInstructionList::GetDescription",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstructionList,0))){ + SWIG_fail_ptr("SBInstructionList_GetDescription",1,SWIGTYPE_p_lldb__SBInstructionList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBInstructionList_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)(arg1)->GetDescription(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBInstructionList_DumpEmulationForAllInstructions(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ; + char *arg2 = (char *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBInstructionList::DumpEmulationForAllInstructions",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstructionList::DumpEmulationForAllInstructions",1,"lldb::SBInstructionList *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBInstructionList::DumpEmulationForAllInstructions",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstructionList,0))){ + SWIG_fail_ptr("SBInstructionList_DumpEmulationForAllInstructions",1,SWIGTYPE_p_lldb__SBInstructionList); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (bool)(arg1)->DumpEmulationForAllInstructions((char const *)arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBInstructionList___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBInstructionList::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBInstructionList::__repr__",1,"lldb::SBInstructionList *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBInstructionList,0))){ + SWIG_fail_ptr("SBInstructionList___tostring",1,SWIGTYPE_p_lldb__SBInstructionList); + } + + result = lldb_SBInstructionList___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBInstructionList(void *obj) { +lldb::SBInstructionList *arg1 = (lldb::SBInstructionList *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBInstructionList(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBInstructionList); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBInstructionList_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBInstructionList_methods[]= { + { "IsValid", _wrap_SBInstructionList_IsValid}, + { "GetSize", _wrap_SBInstructionList_GetSize}, + { "GetInstructionAtIndex", _wrap_SBInstructionList_GetInstructionAtIndex}, + { "GetInstructionsCount", _wrap_SBInstructionList_GetInstructionsCount}, + { "Clear", _wrap_SBInstructionList_Clear}, + { "AppendInstruction", _wrap_SBInstructionList_AppendInstruction}, + { "Print", _wrap_SBInstructionList_Print}, + { "GetDescription", _wrap_SBInstructionList_GetDescription}, + { "DumpEmulationForAllInstructions", _wrap_SBInstructionList_DumpEmulationForAllInstructions}, + { "__tostring", _wrap_SBInstructionList___tostring}, + {0,0} +}; +static swig_lua_method swig_SBInstructionList_meta[] = { + { "__tostring", _wrap_SBInstructionList___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBInstructionList_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBInstructionList_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBInstructionList_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBInstructionList_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBInstructionList_Sf_SwigStatic = { + "SBInstructionList", + swig_SBInstructionList_Sf_SwigStatic_methods, + swig_SBInstructionList_Sf_SwigStatic_attributes, + swig_SBInstructionList_Sf_SwigStatic_constants, + swig_SBInstructionList_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBInstructionList_bases[] = {0}; +static const char *swig_SBInstructionList_base_names[] = {0}; +static swig_lua_class _wrap_class_SBInstructionList = { "SBInstructionList", "SBInstructionList", &SWIGTYPE_p_lldb__SBInstructionList,_proxy__wrap_new_SBInstructionList, swig_delete_SBInstructionList, swig_SBInstructionList_methods, swig_SBInstructionList_attributes, &swig_SBInstructionList_Sf_SwigStatic, swig_SBInstructionList_meta, swig_SBInstructionList_bases, swig_SBInstructionList_base_names }; + +static int _wrap_SBLanguageRuntime_GetLanguageTypeFromString(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + lldb::LanguageType result; + + SWIG_check_num_args("lldb::SBLanguageRuntime::GetLanguageTypeFromString",1,1) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBLanguageRuntime::GetLanguageTypeFromString",1,"char const *"); + arg1 = (char *)lua_tostring(L, 1); + result = (lldb::LanguageType)lldb::SBLanguageRuntime::GetLanguageTypeFromString((char const *)arg1); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLanguageRuntime_GetNameForLanguageType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::LanguageType arg1 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBLanguageRuntime::GetNameForLanguageType",1,1) + if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBLanguageRuntime::GetNameForLanguageType",1,"lldb::LanguageType"); + arg1 = (lldb::LanguageType)lua_tointeger(L, 1); + result = (char *)lldb::SBLanguageRuntime::GetNameForLanguageType(arg1); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLanguageRuntime_LanguageIsCPlusPlus(lua_State* L) { + { + int SWIG_arg = 0; + lldb::LanguageType arg1 ; + bool result; + + SWIG_check_num_args("lldb::SBLanguageRuntime::LanguageIsCPlusPlus",1,1) + if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBLanguageRuntime::LanguageIsCPlusPlus",1,"lldb::LanguageType"); + arg1 = (lldb::LanguageType)lua_tointeger(L, 1); + result = (bool)lldb::SBLanguageRuntime::LanguageIsCPlusPlus(arg1); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLanguageRuntime_LanguageIsObjC(lua_State* L) { + { + int SWIG_arg = 0; + lldb::LanguageType arg1 ; + bool result; + + SWIG_check_num_args("lldb::SBLanguageRuntime::LanguageIsObjC",1,1) + if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBLanguageRuntime::LanguageIsObjC",1,"lldb::LanguageType"); + arg1 = (lldb::LanguageType)lua_tointeger(L, 1); + result = (bool)lldb::SBLanguageRuntime::LanguageIsObjC(arg1); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLanguageRuntime_LanguageIsCFamily(lua_State* L) { + { + int SWIG_arg = 0; + lldb::LanguageType arg1 ; + bool result; + + SWIG_check_num_args("lldb::SBLanguageRuntime::LanguageIsCFamily",1,1) + if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBLanguageRuntime::LanguageIsCFamily",1,"lldb::LanguageType"); + arg1 = (lldb::LanguageType)lua_tointeger(L, 1); + result = (bool)lldb::SBLanguageRuntime::LanguageIsCFamily(arg1); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLanguageRuntime_SupportsExceptionBreakpointsOnThrow(lua_State* L) { + { + int SWIG_arg = 0; + lldb::LanguageType arg1 ; + bool result; + + SWIG_check_num_args("lldb::SBLanguageRuntime::SupportsExceptionBreakpointsOnThrow",1,1) + if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBLanguageRuntime::SupportsExceptionBreakpointsOnThrow",1,"lldb::LanguageType"); + arg1 = (lldb::LanguageType)lua_tointeger(L, 1); + result = (bool)lldb::SBLanguageRuntime::SupportsExceptionBreakpointsOnThrow(arg1); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLanguageRuntime_SupportsExceptionBreakpointsOnCatch(lua_State* L) { + { + int SWIG_arg = 0; + lldb::LanguageType arg1 ; + bool result; + + SWIG_check_num_args("lldb::SBLanguageRuntime::SupportsExceptionBreakpointsOnCatch",1,1) + if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBLanguageRuntime::SupportsExceptionBreakpointsOnCatch",1,"lldb::LanguageType"); + arg1 = (lldb::LanguageType)lua_tointeger(L, 1); + result = (bool)lldb::SBLanguageRuntime::SupportsExceptionBreakpointsOnCatch(arg1); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLanguageRuntime_GetThrowKeywordForLanguage(lua_State* L) { + { + int SWIG_arg = 0; + lldb::LanguageType arg1 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBLanguageRuntime::GetThrowKeywordForLanguage",1,1) + if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBLanguageRuntime::GetThrowKeywordForLanguage",1,"lldb::LanguageType"); + arg1 = (lldb::LanguageType)lua_tointeger(L, 1); + result = (char *)lldb::SBLanguageRuntime::GetThrowKeywordForLanguage(arg1); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLanguageRuntime_GetCatchKeywordForLanguage(lua_State* L) { + { + int SWIG_arg = 0; + lldb::LanguageType arg1 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBLanguageRuntime::GetCatchKeywordForLanguage",1,1) + if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBLanguageRuntime::GetCatchKeywordForLanguage",1,"lldb::LanguageType"); + arg1 = (lldb::LanguageType)lua_tointeger(L, 1); + result = (char *)lldb::SBLanguageRuntime::GetCatchKeywordForLanguage(arg1); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBLanguageRuntime(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLanguageRuntime *result = 0 ; + + SWIG_check_num_args("lldb::SBLanguageRuntime::SBLanguageRuntime",0,0) + result = (lldb::SBLanguageRuntime *)new lldb::SBLanguageRuntime(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBLanguageRuntime,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBLanguageRuntime(void *obj) { +lldb::SBLanguageRuntime *arg1 = (lldb::SBLanguageRuntime *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBLanguageRuntime(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBLanguageRuntime); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBLanguageRuntime_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBLanguageRuntime_methods[]= { + {0,0} +}; +static swig_lua_method swig_SBLanguageRuntime_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBLanguageRuntime_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBLanguageRuntime_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBLanguageRuntime_Sf_SwigStatic_methods[]= { + { "GetLanguageTypeFromString", _wrap_SBLanguageRuntime_GetLanguageTypeFromString}, + { "GetNameForLanguageType", _wrap_SBLanguageRuntime_GetNameForLanguageType}, + { "LanguageIsCPlusPlus", _wrap_SBLanguageRuntime_LanguageIsCPlusPlus}, + { "LanguageIsObjC", _wrap_SBLanguageRuntime_LanguageIsObjC}, + { "LanguageIsCFamily", _wrap_SBLanguageRuntime_LanguageIsCFamily}, + { "SupportsExceptionBreakpointsOnThrow", _wrap_SBLanguageRuntime_SupportsExceptionBreakpointsOnThrow}, + { "SupportsExceptionBreakpointsOnCatch", _wrap_SBLanguageRuntime_SupportsExceptionBreakpointsOnCatch}, + { "GetThrowKeywordForLanguage", _wrap_SBLanguageRuntime_GetThrowKeywordForLanguage}, + { "GetCatchKeywordForLanguage", _wrap_SBLanguageRuntime_GetCatchKeywordForLanguage}, + {0,0} +}; +static swig_lua_class* swig_SBLanguageRuntime_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBLanguageRuntime_Sf_SwigStatic = { + "SBLanguageRuntime", + swig_SBLanguageRuntime_Sf_SwigStatic_methods, + swig_SBLanguageRuntime_Sf_SwigStatic_attributes, + swig_SBLanguageRuntime_Sf_SwigStatic_constants, + swig_SBLanguageRuntime_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBLanguageRuntime_bases[] = {0}; +static const char *swig_SBLanguageRuntime_base_names[] = {0}; +static swig_lua_class _wrap_class_SBLanguageRuntime = { "SBLanguageRuntime", "SBLanguageRuntime", &SWIGTYPE_p_lldb__SBLanguageRuntime,_proxy__wrap_new_SBLanguageRuntime, swig_delete_SBLanguageRuntime, swig_SBLanguageRuntime_methods, swig_SBLanguageRuntime_attributes, &swig_SBLanguageRuntime_Sf_SwigStatic, swig_SBLanguageRuntime_meta, swig_SBLanguageRuntime_bases, swig_SBLanguageRuntime_base_names }; + +static int _wrap_new_SBLaunchInfo(lua_State* L) { + { + int SWIG_arg = 0; + char **arg1 = (char **) 0 ; + lldb::SBLaunchInfo *result = 0 ; + + SWIG_check_num_args("lldb::SBLaunchInfo::SBLaunchInfo",1,1) + { + if (lua_istable(L, 1)) { + size_t size = lua_rawlen(L, 1); + arg1 = (char **)malloc((size + 1) * sizeof(char *)); + int i = 0, j = 0; + while (i++ < size) { + lua_rawgeti(L, 1, i); + if (!lua_isstring(L, -1)) { + // if current element cannot be converted to string, raise an error + lua_pop(L, 1); + return luaL_error(L, "List should only contain strings"); + } + arg1[j++] = (char *)lua_tostring(L, -1); + lua_pop(L, 1); + } + arg1[j] = 0; + } else if (lua_isnil(L, 1)) { + // "nil" is also acceptable, equivalent as an empty table + arg1 = NULL; + } else { + return luaL_error(L, "A list of strings expected"); + } + } + result = (lldb::SBLaunchInfo *)new lldb::SBLaunchInfo((char const **)arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBLaunchInfo,1); SWIG_arg++; + { + free((char *) arg1); + } + return SWIG_arg; + + fail: SWIGUNUSED; + { + free((char *) arg1); + } + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_GetProcessID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::pid_t result; + + SWIG_check_num_args("lldb::SBLaunchInfo::GetProcessID",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetProcessID",1,"lldb::SBLaunchInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_GetProcessID",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + result = (lldb::pid_t)(arg1)->GetProcessID(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_GetUserID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBLaunchInfo::GetUserID",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetUserID",1,"lldb::SBLaunchInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_GetUserID",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + result = (uint32_t)(arg1)->GetUserID(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_GetGroupID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBLaunchInfo::GetGroupID",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetGroupID",1,"lldb::SBLaunchInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_GetGroupID",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + result = (uint32_t)(arg1)->GetGroupID(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_UserIDIsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBLaunchInfo::UserIDIsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::UserIDIsValid",1,"lldb::SBLaunchInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_UserIDIsValid",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + result = (bool)(arg1)->UserIDIsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_GroupIDIsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBLaunchInfo::GroupIDIsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GroupIDIsValid",1,"lldb::SBLaunchInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_GroupIDIsValid",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + result = (bool)(arg1)->GroupIDIsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_SetUserID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + uint32_t arg2 ; + + SWIG_check_num_args("lldb::SBLaunchInfo::SetUserID",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::SetUserID",1,"lldb::SBLaunchInfo *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::SetUserID",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_SetUserID",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + (arg1)->SetUserID(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_SetGroupID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + uint32_t arg2 ; + + SWIG_check_num_args("lldb::SBLaunchInfo::SetGroupID",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::SetGroupID",1,"lldb::SBLaunchInfo *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::SetGroupID",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_SetGroupID",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + (arg1)->SetGroupID(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_GetExecutableFile(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBFileSpec result; + + SWIG_check_num_args("lldb::SBLaunchInfo::GetExecutableFile",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetExecutableFile",1,"lldb::SBLaunchInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_GetExecutableFile",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + result = (arg1)->GetExecutableFile(); + { + lldb::SBFileSpec * resultptr = new lldb::SBFileSpec(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_SetExecutableFile(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBFileSpec arg2 ; + bool arg3 ; + lldb::SBFileSpec *argp2 ; + + SWIG_check_num_args("lldb::SBLaunchInfo::SetExecutableFile",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::SetExecutableFile",1,"lldb::SBLaunchInfo *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::SetExecutableFile",2,"lldb::SBFileSpec"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBLaunchInfo::SetExecutableFile",3,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_SetExecutableFile",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBLaunchInfo_SetExecutableFile",2,SWIGTYPE_p_lldb__SBFileSpec); + } + arg2 = *argp2; + + arg3 = (lua_toboolean(L, 3)!=0); + (arg1)->SetExecutableFile(arg2,arg3); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_GetListener(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBListener result; + + SWIG_check_num_args("lldb::SBLaunchInfo::GetListener",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetListener",1,"lldb::SBLaunchInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_GetListener",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + result = (arg1)->GetListener(); + { + lldb::SBListener * resultptr = new lldb::SBListener(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBListener,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_SetListener(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBListener *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBLaunchInfo::SetListener",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::SetListener",1,"lldb::SBLaunchInfo *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::SetListener",2,"lldb::SBListener &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_SetListener",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBListener,0))){ + SWIG_fail_ptr("SBLaunchInfo_SetListener",2,SWIGTYPE_p_lldb__SBListener); + } + + (arg1)->SetListener(*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_GetShadowListener(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBListener result; + + SWIG_check_num_args("lldb::SBLaunchInfo::GetShadowListener",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetShadowListener",1,"lldb::SBLaunchInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_GetShadowListener",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + result = (arg1)->GetShadowListener(); + { + lldb::SBListener * resultptr = new lldb::SBListener(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBListener,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_SetShadowListener(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBListener *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBLaunchInfo::SetShadowListener",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::SetShadowListener",1,"lldb::SBLaunchInfo *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::SetShadowListener",2,"lldb::SBListener &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_SetShadowListener",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBListener,0))){ + SWIG_fail_ptr("SBLaunchInfo_SetShadowListener",2,SWIGTYPE_p_lldb__SBListener); + } + + (arg1)->SetShadowListener(*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_GetNumArguments(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBLaunchInfo::GetNumArguments",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetNumArguments",1,"lldb::SBLaunchInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_GetNumArguments",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + result = (uint32_t)(arg1)->GetNumArguments(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_GetArgumentAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + uint32_t arg2 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBLaunchInfo::GetArgumentAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetArgumentAtIndex",1,"lldb::SBLaunchInfo *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::GetArgumentAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_GetArgumentAtIndex",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (char *)(arg1)->GetArgumentAtIndex(arg2); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_SetArguments(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + char **arg2 = (char **) 0 ; + bool arg3 ; + + SWIG_check_num_args("lldb::SBLaunchInfo::SetArguments",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::SetArguments",1,"lldb::SBLaunchInfo *"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBLaunchInfo::SetArguments",3,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_SetArguments",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + { + if (lua_istable(L, 2)) { + size_t size = lua_rawlen(L, 2); + arg2 = (char **)malloc((size + 1) * sizeof(char *)); + int i = 0, j = 0; + while (i++ < size) { + lua_rawgeti(L, 2, i); + if (!lua_isstring(L, -1)) { + // if current element cannot be converted to string, raise an error + lua_pop(L, 1); + return luaL_error(L, "List should only contain strings"); + } + arg2[j++] = (char *)lua_tostring(L, -1); + lua_pop(L, 1); + } + arg2[j] = 0; + } else if (lua_isnil(L, 2)) { + // "nil" is also acceptable, equivalent as an empty table + arg2 = NULL; + } else { + return luaL_error(L, "A list of strings expected"); + } + } + arg3 = (lua_toboolean(L, 3)!=0); + (arg1)->SetArguments((char const **)arg2,arg3); + + { + free((char *) arg2); + } + return SWIG_arg; + + fail: SWIGUNUSED; + { + free((char *) arg2); + } + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_GetNumEnvironmentEntries(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBLaunchInfo::GetNumEnvironmentEntries",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetNumEnvironmentEntries",1,"lldb::SBLaunchInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_GetNumEnvironmentEntries",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + result = (uint32_t)(arg1)->GetNumEnvironmentEntries(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_GetEnvironmentEntryAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + uint32_t arg2 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBLaunchInfo::GetEnvironmentEntryAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetEnvironmentEntryAtIndex",1,"lldb::SBLaunchInfo *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::GetEnvironmentEntryAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_GetEnvironmentEntryAtIndex",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (char *)(arg1)->GetEnvironmentEntryAtIndex(arg2); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_SetEnvironmentEntries(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + char **arg2 = (char **) 0 ; + bool arg3 ; + + SWIG_check_num_args("lldb::SBLaunchInfo::SetEnvironmentEntries",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::SetEnvironmentEntries",1,"lldb::SBLaunchInfo *"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBLaunchInfo::SetEnvironmentEntries",3,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_SetEnvironmentEntries",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + { + if (lua_istable(L, 2)) { + size_t size = lua_rawlen(L, 2); + arg2 = (char **)malloc((size + 1) * sizeof(char *)); + int i = 0, j = 0; + while (i++ < size) { + lua_rawgeti(L, 2, i); + if (!lua_isstring(L, -1)) { + // if current element cannot be converted to string, raise an error + lua_pop(L, 1); + return luaL_error(L, "List should only contain strings"); + } + arg2[j++] = (char *)lua_tostring(L, -1); + lua_pop(L, 1); + } + arg2[j] = 0; + } else if (lua_isnil(L, 2)) { + // "nil" is also acceptable, equivalent as an empty table + arg2 = NULL; + } else { + return luaL_error(L, "A list of strings expected"); + } + } + arg3 = (lua_toboolean(L, 3)!=0); + (arg1)->SetEnvironmentEntries((char const **)arg2,arg3); + + { + free((char *) arg2); + } + return SWIG_arg; + + fail: SWIGUNUSED; + { + free((char *) arg2); + } + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_SetEnvironment(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBEnvironment *arg2 = 0 ; + bool arg3 ; + + SWIG_check_num_args("lldb::SBLaunchInfo::SetEnvironment",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::SetEnvironment",1,"lldb::SBLaunchInfo *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::SetEnvironment",2,"lldb::SBEnvironment const &"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBLaunchInfo::SetEnvironment",3,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_SetEnvironment",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBEnvironment,0))){ + SWIG_fail_ptr("SBLaunchInfo_SetEnvironment",2,SWIGTYPE_p_lldb__SBEnvironment); + } + + arg3 = (lua_toboolean(L, 3)!=0); + (arg1)->SetEnvironment((lldb::SBEnvironment const &)*arg2,arg3); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_GetEnvironment(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBEnvironment result; + + SWIG_check_num_args("lldb::SBLaunchInfo::GetEnvironment",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetEnvironment",1,"lldb::SBLaunchInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_GetEnvironment",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + result = (arg1)->GetEnvironment(); + { + lldb::SBEnvironment * resultptr = new lldb::SBEnvironment(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBEnvironment,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + + SWIG_check_num_args("lldb::SBLaunchInfo::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::Clear",1,"lldb::SBLaunchInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_Clear",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_GetWorkingDirectory(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBLaunchInfo::GetWorkingDirectory",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetWorkingDirectory",1,"lldb::SBLaunchInfo const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_GetWorkingDirectory",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + result = (char *)((lldb::SBLaunchInfo const *)arg1)->GetWorkingDirectory(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_SetWorkingDirectory(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBLaunchInfo::SetWorkingDirectory",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::SetWorkingDirectory",1,"lldb::SBLaunchInfo *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::SetWorkingDirectory",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_SetWorkingDirectory",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetWorkingDirectory((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_GetLaunchFlags(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBLaunchInfo::GetLaunchFlags",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetLaunchFlags",1,"lldb::SBLaunchInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_GetLaunchFlags",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + result = (uint32_t)(arg1)->GetLaunchFlags(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_SetLaunchFlags(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + uint32_t arg2 ; + + SWIG_check_num_args("lldb::SBLaunchInfo::SetLaunchFlags",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::SetLaunchFlags",1,"lldb::SBLaunchInfo *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::SetLaunchFlags",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_SetLaunchFlags",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + (arg1)->SetLaunchFlags(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_GetProcessPluginName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBLaunchInfo::GetProcessPluginName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetProcessPluginName",1,"lldb::SBLaunchInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_GetProcessPluginName",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + result = (char *)(arg1)->GetProcessPluginName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_SetProcessPluginName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBLaunchInfo::SetProcessPluginName",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::SetProcessPluginName",1,"lldb::SBLaunchInfo *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::SetProcessPluginName",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_SetProcessPluginName",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetProcessPluginName((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_GetShell(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBLaunchInfo::GetShell",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetShell",1,"lldb::SBLaunchInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_GetShell",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + result = (char *)(arg1)->GetShell(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_SetShell(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBLaunchInfo::SetShell",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::SetShell",1,"lldb::SBLaunchInfo *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::SetShell",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_SetShell",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetShell((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_GetShellExpandArguments(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBLaunchInfo::GetShellExpandArguments",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetShellExpandArguments",1,"lldb::SBLaunchInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_GetShellExpandArguments",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + result = (bool)(arg1)->GetShellExpandArguments(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_SetShellExpandArguments(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBLaunchInfo::SetShellExpandArguments",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::SetShellExpandArguments",1,"lldb::SBLaunchInfo *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::SetShellExpandArguments",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_SetShellExpandArguments",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetShellExpandArguments(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_GetResumeCount(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBLaunchInfo::GetResumeCount",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetResumeCount",1,"lldb::SBLaunchInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_GetResumeCount",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + result = (uint32_t)(arg1)->GetResumeCount(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_SetResumeCount(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + uint32_t arg2 ; + + SWIG_check_num_args("lldb::SBLaunchInfo::SetResumeCount",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::SetResumeCount",1,"lldb::SBLaunchInfo *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::SetResumeCount",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_SetResumeCount",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + (arg1)->SetResumeCount(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_AddCloseFileAction(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + int arg2 ; + bool result; + + SWIG_check_num_args("lldb::SBLaunchInfo::AddCloseFileAction",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::AddCloseFileAction",1,"lldb::SBLaunchInfo *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::AddCloseFileAction",2,"int"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_AddCloseFileAction",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + arg2 = (int)lua_tointeger(L, 2); + result = (bool)(arg1)->AddCloseFileAction(arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_AddDuplicateFileAction(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + int arg2 ; + int arg3 ; + bool result; + + SWIG_check_num_args("lldb::SBLaunchInfo::AddDuplicateFileAction",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::AddDuplicateFileAction",1,"lldb::SBLaunchInfo *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::AddDuplicateFileAction",2,"int"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBLaunchInfo::AddDuplicateFileAction",3,"int"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_AddDuplicateFileAction",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + arg2 = (int)lua_tointeger(L, 2); + arg3 = (int)lua_tointeger(L, 3); + result = (bool)(arg1)->AddDuplicateFileAction(arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_AddOpenFileAction(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + int arg2 ; + char *arg3 = (char *) 0 ; + bool arg4 ; + bool arg5 ; + bool result; + + SWIG_check_num_args("lldb::SBLaunchInfo::AddOpenFileAction",5,5) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::AddOpenFileAction",1,"lldb::SBLaunchInfo *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::AddOpenFileAction",2,"int"); + if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBLaunchInfo::AddOpenFileAction",3,"char const *"); + if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBLaunchInfo::AddOpenFileAction",4,"bool"); + if(!lua_isboolean(L,5)) SWIG_fail_arg("lldb::SBLaunchInfo::AddOpenFileAction",5,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_AddOpenFileAction",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + arg2 = (int)lua_tointeger(L, 2); + arg3 = (char *)lua_tostring(L, 3); + arg4 = (lua_toboolean(L, 4)!=0); + arg5 = (lua_toboolean(L, 5)!=0); + result = (bool)(arg1)->AddOpenFileAction(arg2,(char const *)arg3,arg4,arg5); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_AddSuppressFileAction(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + int arg2 ; + bool arg3 ; + bool arg4 ; + bool result; + + SWIG_check_num_args("lldb::SBLaunchInfo::AddSuppressFileAction",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::AddSuppressFileAction",1,"lldb::SBLaunchInfo *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::AddSuppressFileAction",2,"int"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBLaunchInfo::AddSuppressFileAction",3,"bool"); + if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBLaunchInfo::AddSuppressFileAction",4,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_AddSuppressFileAction",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + arg2 = (int)lua_tointeger(L, 2); + arg3 = (lua_toboolean(L, 3)!=0); + arg4 = (lua_toboolean(L, 4)!=0); + result = (bool)(arg1)->AddSuppressFileAction(arg2,arg3,arg4); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_SetLaunchEventData(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBLaunchInfo::SetLaunchEventData",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::SetLaunchEventData",1,"lldb::SBLaunchInfo *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::SetLaunchEventData",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_SetLaunchEventData",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetLaunchEventData((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_GetLaunchEventData(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBLaunchInfo::GetLaunchEventData",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetLaunchEventData",1,"lldb::SBLaunchInfo const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_GetLaunchEventData",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + result = (char *)((lldb::SBLaunchInfo const *)arg1)->GetLaunchEventData(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_GetDetachOnError(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBLaunchInfo::GetDetachOnError",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetDetachOnError",1,"lldb::SBLaunchInfo const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_GetDetachOnError",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + result = (bool)((lldb::SBLaunchInfo const *)arg1)->GetDetachOnError(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_SetDetachOnError(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBLaunchInfo::SetDetachOnError",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::SetDetachOnError",1,"lldb::SBLaunchInfo *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::SetDetachOnError",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_SetDetachOnError",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetDetachOnError(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_GetScriptedProcessClassName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBLaunchInfo::GetScriptedProcessClassName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetScriptedProcessClassName",1,"lldb::SBLaunchInfo const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_GetScriptedProcessClassName",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + result = (char *)((lldb::SBLaunchInfo const *)arg1)->GetScriptedProcessClassName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_SetScriptedProcessClassName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBLaunchInfo::SetScriptedProcessClassName",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::SetScriptedProcessClassName",1,"lldb::SBLaunchInfo *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::SetScriptedProcessClassName",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_SetScriptedProcessClassName",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetScriptedProcessClassName((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_GetScriptedProcessDictionary(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBStructuredData result; + + SWIG_check_num_args("lldb::SBLaunchInfo::GetScriptedProcessDictionary",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::GetScriptedProcessDictionary",1,"lldb::SBLaunchInfo const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_GetScriptedProcessDictionary",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + result = ((lldb::SBLaunchInfo const *)arg1)->GetScriptedProcessDictionary(); + { + lldb::SBStructuredData * resultptr = new lldb::SBStructuredData(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBStructuredData,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLaunchInfo_SetScriptedProcessDictionary(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) 0 ; + lldb::SBStructuredData arg2 ; + lldb::SBStructuredData *argp2 ; + + SWIG_check_num_args("lldb::SBLaunchInfo::SetScriptedProcessDictionary",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLaunchInfo::SetScriptedProcessDictionary",1,"lldb::SBLaunchInfo *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBLaunchInfo::SetScriptedProcessDictionary",2,"lldb::SBStructuredData"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBLaunchInfo_SetScriptedProcessDictionary",1,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("SBLaunchInfo_SetScriptedProcessDictionary",2,SWIGTYPE_p_lldb__SBStructuredData); + } + arg2 = *argp2; + + (arg1)->SetScriptedProcessDictionary(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBLaunchInfo(void *obj) { +lldb::SBLaunchInfo *arg1 = (lldb::SBLaunchInfo *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBLaunchInfo(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBLaunchInfo); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBLaunchInfo_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBLaunchInfo_methods[]= { + { "GetProcessID", _wrap_SBLaunchInfo_GetProcessID}, + { "GetUserID", _wrap_SBLaunchInfo_GetUserID}, + { "GetGroupID", _wrap_SBLaunchInfo_GetGroupID}, + { "UserIDIsValid", _wrap_SBLaunchInfo_UserIDIsValid}, + { "GroupIDIsValid", _wrap_SBLaunchInfo_GroupIDIsValid}, + { "SetUserID", _wrap_SBLaunchInfo_SetUserID}, + { "SetGroupID", _wrap_SBLaunchInfo_SetGroupID}, + { "GetExecutableFile", _wrap_SBLaunchInfo_GetExecutableFile}, + { "SetExecutableFile", _wrap_SBLaunchInfo_SetExecutableFile}, + { "GetListener", _wrap_SBLaunchInfo_GetListener}, + { "SetListener", _wrap_SBLaunchInfo_SetListener}, + { "GetShadowListener", _wrap_SBLaunchInfo_GetShadowListener}, + { "SetShadowListener", _wrap_SBLaunchInfo_SetShadowListener}, + { "GetNumArguments", _wrap_SBLaunchInfo_GetNumArguments}, + { "GetArgumentAtIndex", _wrap_SBLaunchInfo_GetArgumentAtIndex}, + { "SetArguments", _wrap_SBLaunchInfo_SetArguments}, + { "GetNumEnvironmentEntries", _wrap_SBLaunchInfo_GetNumEnvironmentEntries}, + { "GetEnvironmentEntryAtIndex", _wrap_SBLaunchInfo_GetEnvironmentEntryAtIndex}, + { "SetEnvironmentEntries", _wrap_SBLaunchInfo_SetEnvironmentEntries}, + { "SetEnvironment", _wrap_SBLaunchInfo_SetEnvironment}, + { "GetEnvironment", _wrap_SBLaunchInfo_GetEnvironment}, + { "Clear", _wrap_SBLaunchInfo_Clear}, + { "GetWorkingDirectory", _wrap_SBLaunchInfo_GetWorkingDirectory}, + { "SetWorkingDirectory", _wrap_SBLaunchInfo_SetWorkingDirectory}, + { "GetLaunchFlags", _wrap_SBLaunchInfo_GetLaunchFlags}, + { "SetLaunchFlags", _wrap_SBLaunchInfo_SetLaunchFlags}, + { "GetProcessPluginName", _wrap_SBLaunchInfo_GetProcessPluginName}, + { "SetProcessPluginName", _wrap_SBLaunchInfo_SetProcessPluginName}, + { "GetShell", _wrap_SBLaunchInfo_GetShell}, + { "SetShell", _wrap_SBLaunchInfo_SetShell}, + { "GetShellExpandArguments", _wrap_SBLaunchInfo_GetShellExpandArguments}, + { "SetShellExpandArguments", _wrap_SBLaunchInfo_SetShellExpandArguments}, + { "GetResumeCount", _wrap_SBLaunchInfo_GetResumeCount}, + { "SetResumeCount", _wrap_SBLaunchInfo_SetResumeCount}, + { "AddCloseFileAction", _wrap_SBLaunchInfo_AddCloseFileAction}, + { "AddDuplicateFileAction", _wrap_SBLaunchInfo_AddDuplicateFileAction}, + { "AddOpenFileAction", _wrap_SBLaunchInfo_AddOpenFileAction}, + { "AddSuppressFileAction", _wrap_SBLaunchInfo_AddSuppressFileAction}, + { "SetLaunchEventData", _wrap_SBLaunchInfo_SetLaunchEventData}, + { "GetLaunchEventData", _wrap_SBLaunchInfo_GetLaunchEventData}, + { "GetDetachOnError", _wrap_SBLaunchInfo_GetDetachOnError}, + { "SetDetachOnError", _wrap_SBLaunchInfo_SetDetachOnError}, + { "GetScriptedProcessClassName", _wrap_SBLaunchInfo_GetScriptedProcessClassName}, + { "SetScriptedProcessClassName", _wrap_SBLaunchInfo_SetScriptedProcessClassName}, + { "GetScriptedProcessDictionary", _wrap_SBLaunchInfo_GetScriptedProcessDictionary}, + { "SetScriptedProcessDictionary", _wrap_SBLaunchInfo_SetScriptedProcessDictionary}, + {0,0} +}; +static swig_lua_method swig_SBLaunchInfo_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBLaunchInfo_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBLaunchInfo_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBLaunchInfo_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBLaunchInfo_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBLaunchInfo_Sf_SwigStatic = { + "SBLaunchInfo", + swig_SBLaunchInfo_Sf_SwigStatic_methods, + swig_SBLaunchInfo_Sf_SwigStatic_attributes, + swig_SBLaunchInfo_Sf_SwigStatic_constants, + swig_SBLaunchInfo_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBLaunchInfo_bases[] = {0}; +static const char *swig_SBLaunchInfo_base_names[] = {0}; +static swig_lua_class _wrap_class_SBLaunchInfo = { "SBLaunchInfo", "SBLaunchInfo", &SWIGTYPE_p_lldb__SBLaunchInfo,_proxy__wrap_new_SBLaunchInfo, swig_delete_SBLaunchInfo, swig_SBLaunchInfo_methods, swig_SBLaunchInfo_attributes, &swig_SBLaunchInfo_Sf_SwigStatic, swig_SBLaunchInfo_meta, swig_SBLaunchInfo_bases, swig_SBLaunchInfo_base_names }; + +static int _wrap_new_SBLineEntry__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLineEntry *result = 0 ; + + SWIG_check_num_args("lldb::SBLineEntry::SBLineEntry",0,0) + result = (lldb::SBLineEntry *)new lldb::SBLineEntry(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBLineEntry,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBLineEntry__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLineEntry *arg1 = 0 ; + lldb::SBLineEntry *result = 0 ; + + SWIG_check_num_args("lldb::SBLineEntry::SBLineEntry",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBLineEntry::SBLineEntry",1,"lldb::SBLineEntry const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLineEntry,0))){ + SWIG_fail_ptr("new_SBLineEntry",1,SWIGTYPE_p_lldb__SBLineEntry); + } + + result = (lldb::SBLineEntry *)new lldb::SBLineEntry((lldb::SBLineEntry const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBLineEntry,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBLineEntry(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBLineEntry__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBLineEntry, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBLineEntry__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBLineEntry'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBLineEntry::SBLineEntry()\n" + " lldb::SBLineEntry::SBLineEntry(lldb::SBLineEntry const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBLineEntry_GetStartAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ; + lldb::SBAddress result; + + SWIG_check_num_args("lldb::SBLineEntry::GetStartAddress",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLineEntry::GetStartAddress",1,"lldb::SBLineEntry const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLineEntry,0))){ + SWIG_fail_ptr("SBLineEntry_GetStartAddress",1,SWIGTYPE_p_lldb__SBLineEntry); + } + + result = ((lldb::SBLineEntry const *)arg1)->GetStartAddress(); + { + lldb::SBAddress * resultptr = new lldb::SBAddress(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLineEntry_GetEndAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ; + lldb::SBAddress result; + + SWIG_check_num_args("lldb::SBLineEntry::GetEndAddress",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLineEntry::GetEndAddress",1,"lldb::SBLineEntry const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLineEntry,0))){ + SWIG_fail_ptr("SBLineEntry_GetEndAddress",1,SWIGTYPE_p_lldb__SBLineEntry); + } + + result = ((lldb::SBLineEntry const *)arg1)->GetEndAddress(); + { + lldb::SBAddress * resultptr = new lldb::SBAddress(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLineEntry_GetSameLineContiguousAddressRangeEnd(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ; + bool arg2 ; + lldb::SBAddress result; + + SWIG_check_num_args("lldb::SBLineEntry::GetSameLineContiguousAddressRangeEnd",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLineEntry::GetSameLineContiguousAddressRangeEnd",1,"lldb::SBLineEntry const *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBLineEntry::GetSameLineContiguousAddressRangeEnd",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLineEntry,0))){ + SWIG_fail_ptr("SBLineEntry_GetSameLineContiguousAddressRangeEnd",1,SWIGTYPE_p_lldb__SBLineEntry); + } + + arg2 = (lua_toboolean(L, 2)!=0); + result = ((lldb::SBLineEntry const *)arg1)->GetSameLineContiguousAddressRangeEnd(arg2); + { + lldb::SBAddress * resultptr = new lldb::SBAddress(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLineEntry_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBLineEntry::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLineEntry::IsValid",1,"lldb::SBLineEntry const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLineEntry,0))){ + SWIG_fail_ptr("SBLineEntry_IsValid",1,SWIGTYPE_p_lldb__SBLineEntry); + } + + result = (bool)((lldb::SBLineEntry const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLineEntry_GetFileSpec(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ; + lldb::SBFileSpec result; + + SWIG_check_num_args("lldb::SBLineEntry::GetFileSpec",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLineEntry::GetFileSpec",1,"lldb::SBLineEntry const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLineEntry,0))){ + SWIG_fail_ptr("SBLineEntry_GetFileSpec",1,SWIGTYPE_p_lldb__SBLineEntry); + } + + result = ((lldb::SBLineEntry const *)arg1)->GetFileSpec(); + { + lldb::SBFileSpec * resultptr = new lldb::SBFileSpec(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLineEntry_GetLine(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBLineEntry::GetLine",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLineEntry::GetLine",1,"lldb::SBLineEntry const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLineEntry,0))){ + SWIG_fail_ptr("SBLineEntry_GetLine",1,SWIGTYPE_p_lldb__SBLineEntry); + } + + result = (uint32_t)((lldb::SBLineEntry const *)arg1)->GetLine(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLineEntry_GetColumn(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBLineEntry::GetColumn",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLineEntry::GetColumn",1,"lldb::SBLineEntry const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLineEntry,0))){ + SWIG_fail_ptr("SBLineEntry_GetColumn",1,SWIGTYPE_p_lldb__SBLineEntry); + } + + result = (uint32_t)((lldb::SBLineEntry const *)arg1)->GetColumn(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLineEntry_SetFileSpec(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ; + lldb::SBFileSpec arg2 ; + lldb::SBFileSpec *argp2 ; + + SWIG_check_num_args("lldb::SBLineEntry::SetFileSpec",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLineEntry::SetFileSpec",1,"lldb::SBLineEntry *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBLineEntry::SetFileSpec",2,"lldb::SBFileSpec"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLineEntry,0))){ + SWIG_fail_ptr("SBLineEntry_SetFileSpec",1,SWIGTYPE_p_lldb__SBLineEntry); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBLineEntry_SetFileSpec",2,SWIGTYPE_p_lldb__SBFileSpec); + } + arg2 = *argp2; + + (arg1)->SetFileSpec(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLineEntry_SetLine(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ; + uint32_t arg2 ; + + SWIG_check_num_args("lldb::SBLineEntry::SetLine",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLineEntry::SetLine",1,"lldb::SBLineEntry *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBLineEntry::SetLine",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLineEntry,0))){ + SWIG_fail_ptr("SBLineEntry_SetLine",1,SWIGTYPE_p_lldb__SBLineEntry); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + (arg1)->SetLine(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLineEntry_SetColumn(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ; + uint32_t arg2 ; + + SWIG_check_num_args("lldb::SBLineEntry::SetColumn",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLineEntry::SetColumn",1,"lldb::SBLineEntry *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBLineEntry::SetColumn",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLineEntry,0))){ + SWIG_fail_ptr("SBLineEntry_SetColumn",1,SWIGTYPE_p_lldb__SBLineEntry); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + (arg1)->SetColumn(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLineEntry___eq(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ; + lldb::SBLineEntry *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBLineEntry::operator ==",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLineEntry::operator ==",1,"lldb::SBLineEntry const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBLineEntry::operator ==",2,"lldb::SBLineEntry const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLineEntry,0))){ + SWIG_fail_ptr("SBLineEntry___eq",1,SWIGTYPE_p_lldb__SBLineEntry); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBLineEntry,0))){ + SWIG_fail_ptr("SBLineEntry___eq",2,SWIGTYPE_p_lldb__SBLineEntry); + } + + result = (bool)((lldb::SBLineEntry const *)arg1)->operator ==((lldb::SBLineEntry const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLineEntry_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBLineEntry::GetDescription",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLineEntry::GetDescription",1,"lldb::SBLineEntry *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBLineEntry::GetDescription",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLineEntry,0))){ + SWIG_fail_ptr("SBLineEntry_GetDescription",1,SWIGTYPE_p_lldb__SBLineEntry); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBLineEntry_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)(arg1)->GetDescription(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBLineEntry___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBLineEntry::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBLineEntry::__repr__",1,"lldb::SBLineEntry *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBLineEntry,0))){ + SWIG_fail_ptr("SBLineEntry___tostring",1,SWIGTYPE_p_lldb__SBLineEntry); + } + + result = lldb_SBLineEntry___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBLineEntry(void *obj) { +lldb::SBLineEntry *arg1 = (lldb::SBLineEntry *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBLineEntry(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBLineEntry); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBLineEntry_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBLineEntry_methods[]= { + { "GetStartAddress", _wrap_SBLineEntry_GetStartAddress}, + { "GetEndAddress", _wrap_SBLineEntry_GetEndAddress}, + { "GetSameLineContiguousAddressRangeEnd", _wrap_SBLineEntry_GetSameLineContiguousAddressRangeEnd}, + { "IsValid", _wrap_SBLineEntry_IsValid}, + { "GetFileSpec", _wrap_SBLineEntry_GetFileSpec}, + { "GetLine", _wrap_SBLineEntry_GetLine}, + { "GetColumn", _wrap_SBLineEntry_GetColumn}, + { "SetFileSpec", _wrap_SBLineEntry_SetFileSpec}, + { "SetLine", _wrap_SBLineEntry_SetLine}, + { "SetColumn", _wrap_SBLineEntry_SetColumn}, + { "__eq", _wrap_SBLineEntry___eq}, + { "GetDescription", _wrap_SBLineEntry_GetDescription}, + { "__tostring", _wrap_SBLineEntry___tostring}, + {0,0} +}; +static swig_lua_method swig_SBLineEntry_meta[] = { + { "__eq", _wrap_SBLineEntry___eq}, + { "__tostring", _wrap_SBLineEntry___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBLineEntry_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBLineEntry_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBLineEntry_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBLineEntry_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBLineEntry_Sf_SwigStatic = { + "SBLineEntry", + swig_SBLineEntry_Sf_SwigStatic_methods, + swig_SBLineEntry_Sf_SwigStatic_attributes, + swig_SBLineEntry_Sf_SwigStatic_constants, + swig_SBLineEntry_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBLineEntry_bases[] = {0}; +static const char *swig_SBLineEntry_base_names[] = {0}; +static swig_lua_class _wrap_class_SBLineEntry = { "SBLineEntry", "SBLineEntry", &SWIGTYPE_p_lldb__SBLineEntry,_proxy__wrap_new_SBLineEntry, swig_delete_SBLineEntry, swig_SBLineEntry_methods, swig_SBLineEntry_attributes, &swig_SBLineEntry_Sf_SwigStatic, swig_SBLineEntry_meta, swig_SBLineEntry_bases, swig_SBLineEntry_base_names }; + +static int _wrap_new_SBListener__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBListener *result = 0 ; + + SWIG_check_num_args("lldb::SBListener::SBListener",0,0) + result = (lldb::SBListener *)new lldb::SBListener(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBListener,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBListener__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + lldb::SBListener *result = 0 ; + + SWIG_check_num_args("lldb::SBListener::SBListener",1,1) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBListener::SBListener",1,"char const *"); + arg1 = (char *)lua_tostring(L, 1); + result = (lldb::SBListener *)new lldb::SBListener((char const *)arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBListener,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBListener__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBListener *arg1 = 0 ; + lldb::SBListener *result = 0 ; + + SWIG_check_num_args("lldb::SBListener::SBListener",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBListener::SBListener",1,"lldb::SBListener const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){ + SWIG_fail_ptr("new_SBListener",1,SWIGTYPE_p_lldb__SBListener); + } + + result = (lldb::SBListener *)new lldb::SBListener((lldb::SBListener const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBListener,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBListener(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBListener__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBListener, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBListener__SWIG_2(L); + } + } + if (argc == 1) { + int _v = 0; + { + _v = SWIG_lua_isnilstring(L,argv[0]); + } + if (_v) { + return _wrap_new_SBListener__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBListener_AddEvent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + lldb::SBEvent *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBListener::AddEvent",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBListener::AddEvent",1,"lldb::SBListener *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBListener::AddEvent",2,"lldb::SBEvent const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){ + SWIG_fail_ptr("SBListener_AddEvent",1,SWIGTYPE_p_lldb__SBListener); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBListener_AddEvent",2,SWIGTYPE_p_lldb__SBEvent); + } + + (arg1)->AddEvent((lldb::SBEvent const &)*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBListener_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + + SWIG_check_num_args("lldb::SBListener::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBListener::Clear",1,"lldb::SBListener *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){ + SWIG_fail_ptr("SBListener_Clear",1,SWIGTYPE_p_lldb__SBListener); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBListener_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBListener::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBListener::IsValid",1,"lldb::SBListener const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){ + SWIG_fail_ptr("SBListener_IsValid",1,SWIGTYPE_p_lldb__SBListener); + } + + result = (bool)((lldb::SBListener const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBListener_StartListeningForEventClass(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + lldb::SBDebugger *arg2 = 0 ; + char *arg3 = (char *) 0 ; + uint32_t arg4 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBListener::StartListeningForEventClass",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBListener::StartListeningForEventClass",1,"lldb::SBListener *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBListener::StartListeningForEventClass",2,"lldb::SBDebugger &"); + if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBListener::StartListeningForEventClass",3,"char const *"); + if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBListener::StartListeningForEventClass",4,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){ + SWIG_fail_ptr("SBListener_StartListeningForEventClass",1,SWIGTYPE_p_lldb__SBListener); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBListener_StartListeningForEventClass",2,SWIGTYPE_p_lldb__SBDebugger); + } + + arg3 = (char *)lua_tostring(L, 3); + arg4 = (uint32_t)lua_tointeger(L, 4); + result = (uint32_t)(arg1)->StartListeningForEventClass(*arg2,(char const *)arg3,arg4); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBListener_StopListeningForEventClass(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + lldb::SBDebugger *arg2 = 0 ; + char *arg3 = (char *) 0 ; + uint32_t arg4 ; + bool result; + + SWIG_check_num_args("lldb::SBListener::StopListeningForEventClass",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBListener::StopListeningForEventClass",1,"lldb::SBListener *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBListener::StopListeningForEventClass",2,"lldb::SBDebugger &"); + if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBListener::StopListeningForEventClass",3,"char const *"); + if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBListener::StopListeningForEventClass",4,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){ + SWIG_fail_ptr("SBListener_StopListeningForEventClass",1,SWIGTYPE_p_lldb__SBListener); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBListener_StopListeningForEventClass",2,SWIGTYPE_p_lldb__SBDebugger); + } + + arg3 = (char *)lua_tostring(L, 3); + arg4 = (uint32_t)lua_tointeger(L, 4); + result = (bool)(arg1)->StopListeningForEventClass(*arg2,(char const *)arg3,arg4); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBListener_StartListeningForEvents(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + lldb::SBBroadcaster *arg2 = 0 ; + uint32_t arg3 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBListener::StartListeningForEvents",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBListener::StartListeningForEvents",1,"lldb::SBListener *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBListener::StartListeningForEvents",2,"lldb::SBBroadcaster const &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBListener::StartListeningForEvents",3,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){ + SWIG_fail_ptr("SBListener_StartListeningForEvents",1,SWIGTYPE_p_lldb__SBListener); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBBroadcaster,0))){ + SWIG_fail_ptr("SBListener_StartListeningForEvents",2,SWIGTYPE_p_lldb__SBBroadcaster); + } + + arg3 = (uint32_t)lua_tointeger(L, 3); + result = (uint32_t)(arg1)->StartListeningForEvents((lldb::SBBroadcaster const &)*arg2,arg3); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBListener_StopListeningForEvents(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + lldb::SBBroadcaster *arg2 = 0 ; + uint32_t arg3 ; + bool result; + + SWIG_check_num_args("lldb::SBListener::StopListeningForEvents",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBListener::StopListeningForEvents",1,"lldb::SBListener *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBListener::StopListeningForEvents",2,"lldb::SBBroadcaster const &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBListener::StopListeningForEvents",3,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){ + SWIG_fail_ptr("SBListener_StopListeningForEvents",1,SWIGTYPE_p_lldb__SBListener); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBBroadcaster,0))){ + SWIG_fail_ptr("SBListener_StopListeningForEvents",2,SWIGTYPE_p_lldb__SBBroadcaster); + } + + arg3 = (uint32_t)lua_tointeger(L, 3); + result = (bool)(arg1)->StopListeningForEvents((lldb::SBBroadcaster const &)*arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBListener_WaitForEvent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + uint32_t arg2 ; + lldb::SBEvent *arg3 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBListener::WaitForEvent",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBListener::WaitForEvent",1,"lldb::SBListener *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBListener::WaitForEvent",2,"uint32_t"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBListener::WaitForEvent",3,"lldb::SBEvent &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){ + SWIG_fail_ptr("SBListener_WaitForEvent",1,SWIGTYPE_p_lldb__SBListener); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBListener_WaitForEvent",3,SWIGTYPE_p_lldb__SBEvent); + } + + result = (bool)(arg1)->WaitForEvent(arg2,*arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBListener_WaitForEventForBroadcaster(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + uint32_t arg2 ; + lldb::SBBroadcaster *arg3 = 0 ; + lldb::SBEvent *arg4 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBListener::WaitForEventForBroadcaster",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBListener::WaitForEventForBroadcaster",1,"lldb::SBListener *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBListener::WaitForEventForBroadcaster",2,"uint32_t"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBListener::WaitForEventForBroadcaster",3,"lldb::SBBroadcaster const &"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBListener::WaitForEventForBroadcaster",4,"lldb::SBEvent &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){ + SWIG_fail_ptr("SBListener_WaitForEventForBroadcaster",1,SWIGTYPE_p_lldb__SBListener); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBBroadcaster,0))){ + SWIG_fail_ptr("SBListener_WaitForEventForBroadcaster",3,SWIGTYPE_p_lldb__SBBroadcaster); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBListener_WaitForEventForBroadcaster",4,SWIGTYPE_p_lldb__SBEvent); + } + + result = (bool)(arg1)->WaitForEventForBroadcaster(arg2,(lldb::SBBroadcaster const &)*arg3,*arg4); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBListener_WaitForEventForBroadcasterWithType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + uint32_t arg2 ; + lldb::SBBroadcaster *arg3 = 0 ; + uint32_t arg4 ; + lldb::SBEvent *arg5 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBListener::WaitForEventForBroadcasterWithType",5,5) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBListener::WaitForEventForBroadcasterWithType",1,"lldb::SBListener *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBListener::WaitForEventForBroadcasterWithType",2,"uint32_t"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBListener::WaitForEventForBroadcasterWithType",3,"lldb::SBBroadcaster const &"); + if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBListener::WaitForEventForBroadcasterWithType",4,"uint32_t"); + if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBListener::WaitForEventForBroadcasterWithType",5,"lldb::SBEvent &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){ + SWIG_fail_ptr("SBListener_WaitForEventForBroadcasterWithType",1,SWIGTYPE_p_lldb__SBListener); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBBroadcaster,0))){ + SWIG_fail_ptr("SBListener_WaitForEventForBroadcasterWithType",3,SWIGTYPE_p_lldb__SBBroadcaster); + } + + arg4 = (uint32_t)lua_tointeger(L, 4); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBListener_WaitForEventForBroadcasterWithType",5,SWIGTYPE_p_lldb__SBEvent); + } + + result = (bool)(arg1)->WaitForEventForBroadcasterWithType(arg2,(lldb::SBBroadcaster const &)*arg3,arg4,*arg5); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBListener_PeekAtNextEvent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + lldb::SBEvent *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBListener::PeekAtNextEvent",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBListener::PeekAtNextEvent",1,"lldb::SBListener *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBListener::PeekAtNextEvent",2,"lldb::SBEvent &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){ + SWIG_fail_ptr("SBListener_PeekAtNextEvent",1,SWIGTYPE_p_lldb__SBListener); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBListener_PeekAtNextEvent",2,SWIGTYPE_p_lldb__SBEvent); + } + + result = (bool)(arg1)->PeekAtNextEvent(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBListener_PeekAtNextEventForBroadcaster(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + lldb::SBBroadcaster *arg2 = 0 ; + lldb::SBEvent *arg3 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBListener::PeekAtNextEventForBroadcaster",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBListener::PeekAtNextEventForBroadcaster",1,"lldb::SBListener *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBListener::PeekAtNextEventForBroadcaster",2,"lldb::SBBroadcaster const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBListener::PeekAtNextEventForBroadcaster",3,"lldb::SBEvent &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){ + SWIG_fail_ptr("SBListener_PeekAtNextEventForBroadcaster",1,SWIGTYPE_p_lldb__SBListener); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBBroadcaster,0))){ + SWIG_fail_ptr("SBListener_PeekAtNextEventForBroadcaster",2,SWIGTYPE_p_lldb__SBBroadcaster); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBListener_PeekAtNextEventForBroadcaster",3,SWIGTYPE_p_lldb__SBEvent); + } + + result = (bool)(arg1)->PeekAtNextEventForBroadcaster((lldb::SBBroadcaster const &)*arg2,*arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBListener_PeekAtNextEventForBroadcasterWithType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + lldb::SBBroadcaster *arg2 = 0 ; + uint32_t arg3 ; + lldb::SBEvent *arg4 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBListener::PeekAtNextEventForBroadcasterWithType",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBListener::PeekAtNextEventForBroadcasterWithType",1,"lldb::SBListener *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBListener::PeekAtNextEventForBroadcasterWithType",2,"lldb::SBBroadcaster const &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBListener::PeekAtNextEventForBroadcasterWithType",3,"uint32_t"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBListener::PeekAtNextEventForBroadcasterWithType",4,"lldb::SBEvent &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){ + SWIG_fail_ptr("SBListener_PeekAtNextEventForBroadcasterWithType",1,SWIGTYPE_p_lldb__SBListener); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBBroadcaster,0))){ + SWIG_fail_ptr("SBListener_PeekAtNextEventForBroadcasterWithType",2,SWIGTYPE_p_lldb__SBBroadcaster); + } + + arg3 = (uint32_t)lua_tointeger(L, 3); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBListener_PeekAtNextEventForBroadcasterWithType",4,SWIGTYPE_p_lldb__SBEvent); + } + + result = (bool)(arg1)->PeekAtNextEventForBroadcasterWithType((lldb::SBBroadcaster const &)*arg2,arg3,*arg4); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBListener_GetNextEvent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + lldb::SBEvent *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBListener::GetNextEvent",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBListener::GetNextEvent",1,"lldb::SBListener *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBListener::GetNextEvent",2,"lldb::SBEvent &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){ + SWIG_fail_ptr("SBListener_GetNextEvent",1,SWIGTYPE_p_lldb__SBListener); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBListener_GetNextEvent",2,SWIGTYPE_p_lldb__SBEvent); + } + + result = (bool)(arg1)->GetNextEvent(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBListener_GetNextEventForBroadcaster(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + lldb::SBBroadcaster *arg2 = 0 ; + lldb::SBEvent *arg3 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBListener::GetNextEventForBroadcaster",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBListener::GetNextEventForBroadcaster",1,"lldb::SBListener *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBListener::GetNextEventForBroadcaster",2,"lldb::SBBroadcaster const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBListener::GetNextEventForBroadcaster",3,"lldb::SBEvent &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){ + SWIG_fail_ptr("SBListener_GetNextEventForBroadcaster",1,SWIGTYPE_p_lldb__SBListener); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBBroadcaster,0))){ + SWIG_fail_ptr("SBListener_GetNextEventForBroadcaster",2,SWIGTYPE_p_lldb__SBBroadcaster); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBListener_GetNextEventForBroadcaster",3,SWIGTYPE_p_lldb__SBEvent); + } + + result = (bool)(arg1)->GetNextEventForBroadcaster((lldb::SBBroadcaster const &)*arg2,*arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBListener_GetNextEventForBroadcasterWithType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + lldb::SBBroadcaster *arg2 = 0 ; + uint32_t arg3 ; + lldb::SBEvent *arg4 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBListener::GetNextEventForBroadcasterWithType",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBListener::GetNextEventForBroadcasterWithType",1,"lldb::SBListener *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBListener::GetNextEventForBroadcasterWithType",2,"lldb::SBBroadcaster const &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBListener::GetNextEventForBroadcasterWithType",3,"uint32_t"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBListener::GetNextEventForBroadcasterWithType",4,"lldb::SBEvent &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){ + SWIG_fail_ptr("SBListener_GetNextEventForBroadcasterWithType",1,SWIGTYPE_p_lldb__SBListener); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBBroadcaster,0))){ + SWIG_fail_ptr("SBListener_GetNextEventForBroadcasterWithType",2,SWIGTYPE_p_lldb__SBBroadcaster); + } + + arg3 = (uint32_t)lua_tointeger(L, 3); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBListener_GetNextEventForBroadcasterWithType",4,SWIGTYPE_p_lldb__SBEvent); + } + + result = (bool)(arg1)->GetNextEventForBroadcasterWithType((lldb::SBBroadcaster const &)*arg2,arg3,*arg4); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBListener_HandleBroadcastEvent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBListener *arg1 = (lldb::SBListener *) 0 ; + lldb::SBEvent *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBListener::HandleBroadcastEvent",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBListener::HandleBroadcastEvent",1,"lldb::SBListener *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBListener::HandleBroadcastEvent",2,"lldb::SBEvent const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBListener,0))){ + SWIG_fail_ptr("SBListener_HandleBroadcastEvent",1,SWIGTYPE_p_lldb__SBListener); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBListener_HandleBroadcastEvent",2,SWIGTYPE_p_lldb__SBEvent); + } + + result = (bool)(arg1)->HandleBroadcastEvent((lldb::SBEvent const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBListener(void *obj) { +lldb::SBListener *arg1 = (lldb::SBListener *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBListener(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBListener); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBListener_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBListener_methods[]= { + { "AddEvent", _wrap_SBListener_AddEvent}, + { "Clear", _wrap_SBListener_Clear}, + { "IsValid", _wrap_SBListener_IsValid}, + { "StartListeningForEventClass", _wrap_SBListener_StartListeningForEventClass}, + { "StopListeningForEventClass", _wrap_SBListener_StopListeningForEventClass}, + { "StartListeningForEvents", _wrap_SBListener_StartListeningForEvents}, + { "StopListeningForEvents", _wrap_SBListener_StopListeningForEvents}, + { "WaitForEvent", _wrap_SBListener_WaitForEvent}, + { "WaitForEventForBroadcaster", _wrap_SBListener_WaitForEventForBroadcaster}, + { "WaitForEventForBroadcasterWithType", _wrap_SBListener_WaitForEventForBroadcasterWithType}, + { "PeekAtNextEvent", _wrap_SBListener_PeekAtNextEvent}, + { "PeekAtNextEventForBroadcaster", _wrap_SBListener_PeekAtNextEventForBroadcaster}, + { "PeekAtNextEventForBroadcasterWithType", _wrap_SBListener_PeekAtNextEventForBroadcasterWithType}, + { "GetNextEvent", _wrap_SBListener_GetNextEvent}, + { "GetNextEventForBroadcaster", _wrap_SBListener_GetNextEventForBroadcaster}, + { "GetNextEventForBroadcasterWithType", _wrap_SBListener_GetNextEventForBroadcasterWithType}, + { "HandleBroadcastEvent", _wrap_SBListener_HandleBroadcastEvent}, + {0,0} +}; +static swig_lua_method swig_SBListener_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBListener_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBListener_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBListener_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBListener_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBListener_Sf_SwigStatic = { + "SBListener", + swig_SBListener_Sf_SwigStatic_methods, + swig_SBListener_Sf_SwigStatic_attributes, + swig_SBListener_Sf_SwigStatic_constants, + swig_SBListener_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBListener_bases[] = {0}; +static const char *swig_SBListener_base_names[] = {0}; +static swig_lua_class _wrap_class_SBListener = { "SBListener", "SBListener", &SWIGTYPE_p_lldb__SBListener,_proxy__wrap_new_SBListener, swig_delete_SBListener, swig_SBListener_methods, swig_SBListener_attributes, &swig_SBListener_Sf_SwigStatic, swig_SBListener_meta, swig_SBListener_bases, swig_SBListener_base_names }; + +static int _wrap_new_SBMemoryRegionInfo__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBMemoryRegionInfo *result = 0 ; + + SWIG_check_num_args("lldb::SBMemoryRegionInfo::SBMemoryRegionInfo",0,0) + result = (lldb::SBMemoryRegionInfo *)new lldb::SBMemoryRegionInfo(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBMemoryRegionInfo,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBMemoryRegionInfo__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBMemoryRegionInfo *arg1 = 0 ; + lldb::SBMemoryRegionInfo *result = 0 ; + + SWIG_check_num_args("lldb::SBMemoryRegionInfo::SBMemoryRegionInfo",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::SBMemoryRegionInfo",1,"lldb::SBMemoryRegionInfo const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){ + SWIG_fail_ptr("new_SBMemoryRegionInfo",1,SWIGTYPE_p_lldb__SBMemoryRegionInfo); + } + + result = (lldb::SBMemoryRegionInfo *)new lldb::SBMemoryRegionInfo((lldb::SBMemoryRegionInfo const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBMemoryRegionInfo,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBMemoryRegionInfo__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + lldb::addr_t arg2 ; + lldb::addr_t arg3 ; + uint32_t arg4 ; + bool arg5 ; + bool arg6 ; + lldb::SBMemoryRegionInfo *result = 0 ; + + SWIG_check_num_args("lldb::SBMemoryRegionInfo::SBMemoryRegionInfo",6,6) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::SBMemoryRegionInfo",1,"char const *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::SBMemoryRegionInfo",2,"lldb::addr_t"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::SBMemoryRegionInfo",3,"lldb::addr_t"); + if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::SBMemoryRegionInfo",4,"uint32_t"); + if(!lua_isboolean(L,5)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::SBMemoryRegionInfo",5,"bool"); + if(!lua_isboolean(L,6)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::SBMemoryRegionInfo",6,"bool"); + arg1 = (char *)lua_tostring(L, 1); + arg2 = (lldb::addr_t)lua_tointeger(L, 2); + arg3 = (lldb::addr_t)lua_tointeger(L, 3); + arg4 = (uint32_t)lua_tointeger(L, 4); + arg5 = (lua_toboolean(L, 5)!=0); + arg6 = (lua_toboolean(L, 6)!=0); + result = (lldb::SBMemoryRegionInfo *)new lldb::SBMemoryRegionInfo((char const *)arg1,arg2,arg3,arg4,arg5,arg6); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBMemoryRegionInfo,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBMemoryRegionInfo__SWIG_3(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + lldb::addr_t arg2 ; + lldb::addr_t arg3 ; + uint32_t arg4 ; + bool arg5 ; + lldb::SBMemoryRegionInfo *result = 0 ; + + SWIG_check_num_args("lldb::SBMemoryRegionInfo::SBMemoryRegionInfo",5,5) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::SBMemoryRegionInfo",1,"char const *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::SBMemoryRegionInfo",2,"lldb::addr_t"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::SBMemoryRegionInfo",3,"lldb::addr_t"); + if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::SBMemoryRegionInfo",4,"uint32_t"); + if(!lua_isboolean(L,5)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::SBMemoryRegionInfo",5,"bool"); + arg1 = (char *)lua_tostring(L, 1); + arg2 = (lldb::addr_t)lua_tointeger(L, 2); + arg3 = (lldb::addr_t)lua_tointeger(L, 3); + arg4 = (uint32_t)lua_tointeger(L, 4); + arg5 = (lua_toboolean(L, 5)!=0); + result = (lldb::SBMemoryRegionInfo *)new lldb::SBMemoryRegionInfo((char const *)arg1,arg2,arg3,arg4,arg5); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBMemoryRegionInfo,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBMemoryRegionInfo(lua_State* L) { + int argc; + int argv[7]={ + 1,2,3,4,5,6,7 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBMemoryRegionInfo__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBMemoryRegionInfo, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBMemoryRegionInfo__SWIG_1(L); + } + } + if (argc == 5) { + int _v = 0; + { + _v = SWIG_lua_isnilstring(L,argv[0]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[3]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[4]); + } + if (_v) { + return _wrap_new_SBMemoryRegionInfo__SWIG_3(L); + } + } + } + } + } + } + if (argc == 6) { + int _v = 0; + { + _v = SWIG_lua_isnilstring(L,argv[0]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[3]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[4]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[5]); + } + if (_v) { + return _wrap_new_SBMemoryRegionInfo__SWIG_2(L); + } + } + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBMemoryRegionInfo_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ; + + SWIG_check_num_args("lldb::SBMemoryRegionInfo::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::Clear",1,"lldb::SBMemoryRegionInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){ + SWIG_fail_ptr("SBMemoryRegionInfo_Clear",1,SWIGTYPE_p_lldb__SBMemoryRegionInfo); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBMemoryRegionInfo_GetRegionBase(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ; + lldb::addr_t result; + + SWIG_check_num_args("lldb::SBMemoryRegionInfo::GetRegionBase",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::GetRegionBase",1,"lldb::SBMemoryRegionInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){ + SWIG_fail_ptr("SBMemoryRegionInfo_GetRegionBase",1,SWIGTYPE_p_lldb__SBMemoryRegionInfo); + } + + result = (lldb::addr_t)(arg1)->GetRegionBase(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBMemoryRegionInfo_GetRegionEnd(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ; + lldb::addr_t result; + + SWIG_check_num_args("lldb::SBMemoryRegionInfo::GetRegionEnd",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::GetRegionEnd",1,"lldb::SBMemoryRegionInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){ + SWIG_fail_ptr("SBMemoryRegionInfo_GetRegionEnd",1,SWIGTYPE_p_lldb__SBMemoryRegionInfo); + } + + result = (lldb::addr_t)(arg1)->GetRegionEnd(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBMemoryRegionInfo_IsReadable(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBMemoryRegionInfo::IsReadable",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::IsReadable",1,"lldb::SBMemoryRegionInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){ + SWIG_fail_ptr("SBMemoryRegionInfo_IsReadable",1,SWIGTYPE_p_lldb__SBMemoryRegionInfo); + } + + result = (bool)(arg1)->IsReadable(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBMemoryRegionInfo_IsWritable(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBMemoryRegionInfo::IsWritable",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::IsWritable",1,"lldb::SBMemoryRegionInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){ + SWIG_fail_ptr("SBMemoryRegionInfo_IsWritable",1,SWIGTYPE_p_lldb__SBMemoryRegionInfo); + } + + result = (bool)(arg1)->IsWritable(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBMemoryRegionInfo_IsExecutable(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBMemoryRegionInfo::IsExecutable",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::IsExecutable",1,"lldb::SBMemoryRegionInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){ + SWIG_fail_ptr("SBMemoryRegionInfo_IsExecutable",1,SWIGTYPE_p_lldb__SBMemoryRegionInfo); + } + + result = (bool)(arg1)->IsExecutable(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBMemoryRegionInfo_IsMapped(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBMemoryRegionInfo::IsMapped",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::IsMapped",1,"lldb::SBMemoryRegionInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){ + SWIG_fail_ptr("SBMemoryRegionInfo_IsMapped",1,SWIGTYPE_p_lldb__SBMemoryRegionInfo); + } + + result = (bool)(arg1)->IsMapped(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBMemoryRegionInfo_GetName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBMemoryRegionInfo::GetName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::GetName",1,"lldb::SBMemoryRegionInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){ + SWIG_fail_ptr("SBMemoryRegionInfo_GetName",1,SWIGTYPE_p_lldb__SBMemoryRegionInfo); + } + + result = (char *)(arg1)->GetName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBMemoryRegionInfo_HasDirtyMemoryPageList(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBMemoryRegionInfo::HasDirtyMemoryPageList",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::HasDirtyMemoryPageList",1,"lldb::SBMemoryRegionInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){ + SWIG_fail_ptr("SBMemoryRegionInfo_HasDirtyMemoryPageList",1,SWIGTYPE_p_lldb__SBMemoryRegionInfo); + } + + result = (bool)(arg1)->HasDirtyMemoryPageList(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBMemoryRegionInfo_GetNumDirtyPages(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBMemoryRegionInfo::GetNumDirtyPages",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::GetNumDirtyPages",1,"lldb::SBMemoryRegionInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){ + SWIG_fail_ptr("SBMemoryRegionInfo_GetNumDirtyPages",1,SWIGTYPE_p_lldb__SBMemoryRegionInfo); + } + + result = (uint32_t)(arg1)->GetNumDirtyPages(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBMemoryRegionInfo_GetDirtyPageAddressAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ; + uint32_t arg2 ; + lldb::addr_t result; + + SWIG_check_num_args("lldb::SBMemoryRegionInfo::GetDirtyPageAddressAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::GetDirtyPageAddressAtIndex",1,"lldb::SBMemoryRegionInfo *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::GetDirtyPageAddressAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){ + SWIG_fail_ptr("SBMemoryRegionInfo_GetDirtyPageAddressAtIndex",1,SWIGTYPE_p_lldb__SBMemoryRegionInfo); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (lldb::addr_t)(arg1)->GetDirtyPageAddressAtIndex(arg2); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBMemoryRegionInfo_GetPageSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ; + int result; + + SWIG_check_num_args("lldb::SBMemoryRegionInfo::GetPageSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::GetPageSize",1,"lldb::SBMemoryRegionInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){ + SWIG_fail_ptr("SBMemoryRegionInfo_GetPageSize",1,SWIGTYPE_p_lldb__SBMemoryRegionInfo); + } + + result = (int)(arg1)->GetPageSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBMemoryRegionInfo___eq(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ; + lldb::SBMemoryRegionInfo *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBMemoryRegionInfo::operator ==",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::operator ==",1,"lldb::SBMemoryRegionInfo const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::operator ==",2,"lldb::SBMemoryRegionInfo const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){ + SWIG_fail_ptr("SBMemoryRegionInfo___eq",1,SWIGTYPE_p_lldb__SBMemoryRegionInfo); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){ + SWIG_fail_ptr("SBMemoryRegionInfo___eq",2,SWIGTYPE_p_lldb__SBMemoryRegionInfo); + } + + result = (bool)((lldb::SBMemoryRegionInfo const *)arg1)->operator ==((lldb::SBMemoryRegionInfo const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBMemoryRegionInfo_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBMemoryRegionInfo::GetDescription",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::GetDescription",1,"lldb::SBMemoryRegionInfo *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::GetDescription",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){ + SWIG_fail_ptr("SBMemoryRegionInfo_GetDescription",1,SWIGTYPE_p_lldb__SBMemoryRegionInfo); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBMemoryRegionInfo_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)(arg1)->GetDescription(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBMemoryRegionInfo___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBMemoryRegionInfo::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfo::__repr__",1,"lldb::SBMemoryRegionInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){ + SWIG_fail_ptr("SBMemoryRegionInfo___tostring",1,SWIGTYPE_p_lldb__SBMemoryRegionInfo); + } + + result = lldb_SBMemoryRegionInfo___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBMemoryRegionInfo(void *obj) { +lldb::SBMemoryRegionInfo *arg1 = (lldb::SBMemoryRegionInfo *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBMemoryRegionInfo(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBMemoryRegionInfo); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBMemoryRegionInfo_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBMemoryRegionInfo_methods[]= { + { "Clear", _wrap_SBMemoryRegionInfo_Clear}, + { "GetRegionBase", _wrap_SBMemoryRegionInfo_GetRegionBase}, + { "GetRegionEnd", _wrap_SBMemoryRegionInfo_GetRegionEnd}, + { "IsReadable", _wrap_SBMemoryRegionInfo_IsReadable}, + { "IsWritable", _wrap_SBMemoryRegionInfo_IsWritable}, + { "IsExecutable", _wrap_SBMemoryRegionInfo_IsExecutable}, + { "IsMapped", _wrap_SBMemoryRegionInfo_IsMapped}, + { "GetName", _wrap_SBMemoryRegionInfo_GetName}, + { "HasDirtyMemoryPageList", _wrap_SBMemoryRegionInfo_HasDirtyMemoryPageList}, + { "GetNumDirtyPages", _wrap_SBMemoryRegionInfo_GetNumDirtyPages}, + { "GetDirtyPageAddressAtIndex", _wrap_SBMemoryRegionInfo_GetDirtyPageAddressAtIndex}, + { "GetPageSize", _wrap_SBMemoryRegionInfo_GetPageSize}, + { "__eq", _wrap_SBMemoryRegionInfo___eq}, + { "GetDescription", _wrap_SBMemoryRegionInfo_GetDescription}, + { "__tostring", _wrap_SBMemoryRegionInfo___tostring}, + {0,0} +}; +static swig_lua_method swig_SBMemoryRegionInfo_meta[] = { + { "__eq", _wrap_SBMemoryRegionInfo___eq}, + { "__tostring", _wrap_SBMemoryRegionInfo___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBMemoryRegionInfo_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBMemoryRegionInfo_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBMemoryRegionInfo_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBMemoryRegionInfo_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBMemoryRegionInfo_Sf_SwigStatic = { + "SBMemoryRegionInfo", + swig_SBMemoryRegionInfo_Sf_SwigStatic_methods, + swig_SBMemoryRegionInfo_Sf_SwigStatic_attributes, + swig_SBMemoryRegionInfo_Sf_SwigStatic_constants, + swig_SBMemoryRegionInfo_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBMemoryRegionInfo_bases[] = {0}; +static const char *swig_SBMemoryRegionInfo_base_names[] = {0}; +static swig_lua_class _wrap_class_SBMemoryRegionInfo = { "SBMemoryRegionInfo", "SBMemoryRegionInfo", &SWIGTYPE_p_lldb__SBMemoryRegionInfo,_proxy__wrap_new_SBMemoryRegionInfo, swig_delete_SBMemoryRegionInfo, swig_SBMemoryRegionInfo_methods, swig_SBMemoryRegionInfo_attributes, &swig_SBMemoryRegionInfo_Sf_SwigStatic, swig_SBMemoryRegionInfo_meta, swig_SBMemoryRegionInfo_bases, swig_SBMemoryRegionInfo_base_names }; + +static int _wrap_new_SBMemoryRegionInfoList__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBMemoryRegionInfoList *result = 0 ; + + SWIG_check_num_args("lldb::SBMemoryRegionInfoList::SBMemoryRegionInfoList",0,0) + result = (lldb::SBMemoryRegionInfoList *)new lldb::SBMemoryRegionInfoList(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBMemoryRegionInfoList,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBMemoryRegionInfoList__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBMemoryRegionInfoList *arg1 = 0 ; + lldb::SBMemoryRegionInfoList *result = 0 ; + + SWIG_check_num_args("lldb::SBMemoryRegionInfoList::SBMemoryRegionInfoList",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfoList::SBMemoryRegionInfoList",1,"lldb::SBMemoryRegionInfoList const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfoList,0))){ + SWIG_fail_ptr("new_SBMemoryRegionInfoList",1,SWIGTYPE_p_lldb__SBMemoryRegionInfoList); + } + + result = (lldb::SBMemoryRegionInfoList *)new lldb::SBMemoryRegionInfoList((lldb::SBMemoryRegionInfoList const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBMemoryRegionInfoList,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBMemoryRegionInfoList(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBMemoryRegionInfoList__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBMemoryRegionInfoList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBMemoryRegionInfoList__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBMemoryRegionInfoList'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBMemoryRegionInfoList::SBMemoryRegionInfoList()\n" + " lldb::SBMemoryRegionInfoList::SBMemoryRegionInfoList(lldb::SBMemoryRegionInfoList const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBMemoryRegionInfoList_GetSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBMemoryRegionInfoList *arg1 = (lldb::SBMemoryRegionInfoList *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBMemoryRegionInfoList::GetSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfoList::GetSize",1,"lldb::SBMemoryRegionInfoList const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfoList,0))){ + SWIG_fail_ptr("SBMemoryRegionInfoList_GetSize",1,SWIGTYPE_p_lldb__SBMemoryRegionInfoList); + } + + result = (uint32_t)((lldb::SBMemoryRegionInfoList const *)arg1)->GetSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBMemoryRegionInfoList_GetMemoryRegionContainingAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBMemoryRegionInfoList *arg1 = (lldb::SBMemoryRegionInfoList *) 0 ; + lldb::addr_t arg2 ; + lldb::SBMemoryRegionInfo *arg3 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBMemoryRegionInfoList::GetMemoryRegionContainingAddress",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfoList::GetMemoryRegionContainingAddress",1,"lldb::SBMemoryRegionInfoList *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBMemoryRegionInfoList::GetMemoryRegionContainingAddress",2,"lldb::addr_t"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBMemoryRegionInfoList::GetMemoryRegionContainingAddress",3,"lldb::SBMemoryRegionInfo &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfoList,0))){ + SWIG_fail_ptr("SBMemoryRegionInfoList_GetMemoryRegionContainingAddress",1,SWIGTYPE_p_lldb__SBMemoryRegionInfoList); + } + + arg2 = (lldb::addr_t)lua_tointeger(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){ + SWIG_fail_ptr("SBMemoryRegionInfoList_GetMemoryRegionContainingAddress",3,SWIGTYPE_p_lldb__SBMemoryRegionInfo); + } + + result = (bool)(arg1)->GetMemoryRegionContainingAddress(arg2,*arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBMemoryRegionInfoList_GetMemoryRegionAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBMemoryRegionInfoList *arg1 = (lldb::SBMemoryRegionInfoList *) 0 ; + uint32_t arg2 ; + lldb::SBMemoryRegionInfo *arg3 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBMemoryRegionInfoList::GetMemoryRegionAtIndex",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfoList::GetMemoryRegionAtIndex",1,"lldb::SBMemoryRegionInfoList *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBMemoryRegionInfoList::GetMemoryRegionAtIndex",2,"uint32_t"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBMemoryRegionInfoList::GetMemoryRegionAtIndex",3,"lldb::SBMemoryRegionInfo &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfoList,0))){ + SWIG_fail_ptr("SBMemoryRegionInfoList_GetMemoryRegionAtIndex",1,SWIGTYPE_p_lldb__SBMemoryRegionInfoList); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){ + SWIG_fail_ptr("SBMemoryRegionInfoList_GetMemoryRegionAtIndex",3,SWIGTYPE_p_lldb__SBMemoryRegionInfo); + } + + result = (bool)(arg1)->GetMemoryRegionAtIndex(arg2,*arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBMemoryRegionInfoList_Append__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBMemoryRegionInfoList *arg1 = (lldb::SBMemoryRegionInfoList *) 0 ; + lldb::SBMemoryRegionInfo *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBMemoryRegionInfoList::Append",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfoList::Append",1,"lldb::SBMemoryRegionInfoList *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBMemoryRegionInfoList::Append",2,"lldb::SBMemoryRegionInfo &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfoList,0))){ + SWIG_fail_ptr("SBMemoryRegionInfoList_Append",1,SWIGTYPE_p_lldb__SBMemoryRegionInfoList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){ + SWIG_fail_ptr("SBMemoryRegionInfoList_Append",2,SWIGTYPE_p_lldb__SBMemoryRegionInfo); + } + + (arg1)->Append(*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBMemoryRegionInfoList_Append__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBMemoryRegionInfoList *arg1 = (lldb::SBMemoryRegionInfoList *) 0 ; + lldb::SBMemoryRegionInfoList *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBMemoryRegionInfoList::Append",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfoList::Append",1,"lldb::SBMemoryRegionInfoList *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBMemoryRegionInfoList::Append",2,"lldb::SBMemoryRegionInfoList &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfoList,0))){ + SWIG_fail_ptr("SBMemoryRegionInfoList_Append",1,SWIGTYPE_p_lldb__SBMemoryRegionInfoList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBMemoryRegionInfoList,0))){ + SWIG_fail_ptr("SBMemoryRegionInfoList_Append",2,SWIGTYPE_p_lldb__SBMemoryRegionInfoList); + } + + (arg1)->Append(*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBMemoryRegionInfoList_Append(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBMemoryRegionInfoList, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBMemoryRegionInfo, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBMemoryRegionInfoList_Append__SWIG_0(L); + } + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBMemoryRegionInfoList, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBMemoryRegionInfoList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBMemoryRegionInfoList_Append__SWIG_1(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBMemoryRegionInfoList_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBMemoryRegionInfoList *arg1 = (lldb::SBMemoryRegionInfoList *) 0 ; + + SWIG_check_num_args("lldb::SBMemoryRegionInfoList::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBMemoryRegionInfoList::Clear",1,"lldb::SBMemoryRegionInfoList *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBMemoryRegionInfoList,0))){ + SWIG_fail_ptr("SBMemoryRegionInfoList_Clear",1,SWIGTYPE_p_lldb__SBMemoryRegionInfoList); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBMemoryRegionInfoList(void *obj) { +lldb::SBMemoryRegionInfoList *arg1 = (lldb::SBMemoryRegionInfoList *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBMemoryRegionInfoList(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBMemoryRegionInfoList); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBMemoryRegionInfoList_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBMemoryRegionInfoList_methods[]= { + { "GetSize", _wrap_SBMemoryRegionInfoList_GetSize}, + { "GetMemoryRegionContainingAddress", _wrap_SBMemoryRegionInfoList_GetMemoryRegionContainingAddress}, + { "GetMemoryRegionAtIndex", _wrap_SBMemoryRegionInfoList_GetMemoryRegionAtIndex}, + { "Append", _wrap_SBMemoryRegionInfoList_Append}, + { "Clear", _wrap_SBMemoryRegionInfoList_Clear}, + {0,0} +}; +static swig_lua_method swig_SBMemoryRegionInfoList_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBMemoryRegionInfoList_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBMemoryRegionInfoList_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBMemoryRegionInfoList_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBMemoryRegionInfoList_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBMemoryRegionInfoList_Sf_SwigStatic = { + "SBMemoryRegionInfoList", + swig_SBMemoryRegionInfoList_Sf_SwigStatic_methods, + swig_SBMemoryRegionInfoList_Sf_SwigStatic_attributes, + swig_SBMemoryRegionInfoList_Sf_SwigStatic_constants, + swig_SBMemoryRegionInfoList_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBMemoryRegionInfoList_bases[] = {0}; +static const char *swig_SBMemoryRegionInfoList_base_names[] = {0}; +static swig_lua_class _wrap_class_SBMemoryRegionInfoList = { "SBMemoryRegionInfoList", "SBMemoryRegionInfoList", &SWIGTYPE_p_lldb__SBMemoryRegionInfoList,_proxy__wrap_new_SBMemoryRegionInfoList, swig_delete_SBMemoryRegionInfoList, swig_SBMemoryRegionInfoList_methods, swig_SBMemoryRegionInfoList_attributes, &swig_SBMemoryRegionInfoList_Sf_SwigStatic, swig_SBMemoryRegionInfoList_meta, swig_SBMemoryRegionInfoList_bases, swig_SBMemoryRegionInfoList_base_names }; + +static int _wrap_new_SBModule__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *result = 0 ; + + SWIG_check_num_args("lldb::SBModule::SBModule",0,0) + result = (lldb::SBModule *)new lldb::SBModule(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBModule,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBModule__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = 0 ; + lldb::SBModule *result = 0 ; + + SWIG_check_num_args("lldb::SBModule::SBModule",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBModule::SBModule",1,"lldb::SBModule const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("new_SBModule",1,SWIGTYPE_p_lldb__SBModule); + } + + result = (lldb::SBModule *)new lldb::SBModule((lldb::SBModule const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBModule,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBModule__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModuleSpec *arg1 = 0 ; + lldb::SBModule *result = 0 ; + + SWIG_check_num_args("lldb::SBModule::SBModule",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBModule::SBModule",1,"lldb::SBModuleSpec const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){ + SWIG_fail_ptr("new_SBModule",1,SWIGTYPE_p_lldb__SBModuleSpec); + } + + result = (lldb::SBModule *)new lldb::SBModule((lldb::SBModuleSpec const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBModule,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBModule__SWIG_3(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = 0 ; + lldb::addr_t arg2 ; + lldb::SBModule *result = 0 ; + + SWIG_check_num_args("lldb::SBModule::SBModule",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBModule::SBModule",1,"lldb::SBProcess &"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBModule::SBModule",2,"lldb::addr_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("new_SBModule",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (lldb::addr_t)lua_tointeger(L, 2); + result = (lldb::SBModule *)new lldb::SBModule(*arg1,arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBModule,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBModule(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBModule__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBModule, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBModule__SWIG_1(L); + } + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBModuleSpec, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBModule__SWIG_2(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_new_SBModule__SWIG_3(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBModule_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBModule::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::IsValid",1,"lldb::SBModule const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_IsValid",1,SWIGTYPE_p_lldb__SBModule); + } + + result = (bool)((lldb::SBModule const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + + SWIG_check_num_args("lldb::SBModule::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::Clear",1,"lldb::SBModule *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_Clear",1,SWIGTYPE_p_lldb__SBModule); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_IsFileBacked(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBModule::IsFileBacked",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::IsFileBacked",1,"lldb::SBModule const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_IsFileBacked",1,SWIGTYPE_p_lldb__SBModule); + } + + result = (bool)((lldb::SBModule const *)arg1)->IsFileBacked(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_GetFileSpec(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBFileSpec result; + + SWIG_check_num_args("lldb::SBModule::GetFileSpec",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetFileSpec",1,"lldb::SBModule const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_GetFileSpec",1,SWIGTYPE_p_lldb__SBModule); + } + + result = ((lldb::SBModule const *)arg1)->GetFileSpec(); + { + lldb::SBFileSpec * resultptr = new lldb::SBFileSpec(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_GetPlatformFileSpec(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBFileSpec result; + + SWIG_check_num_args("lldb::SBModule::GetPlatformFileSpec",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetPlatformFileSpec",1,"lldb::SBModule const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_GetPlatformFileSpec",1,SWIGTYPE_p_lldb__SBModule); + } + + result = ((lldb::SBModule const *)arg1)->GetPlatformFileSpec(); + { + lldb::SBFileSpec * resultptr = new lldb::SBFileSpec(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_SetPlatformFileSpec(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBFileSpec *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBModule::SetPlatformFileSpec",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::SetPlatformFileSpec",1,"lldb::SBModule *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBModule::SetPlatformFileSpec",2,"lldb::SBFileSpec const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_SetPlatformFileSpec",1,SWIGTYPE_p_lldb__SBModule); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBModule_SetPlatformFileSpec",2,SWIGTYPE_p_lldb__SBFileSpec); + } + + result = (bool)(arg1)->SetPlatformFileSpec((lldb::SBFileSpec const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_GetRemoteInstallFileSpec(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBFileSpec result; + + SWIG_check_num_args("lldb::SBModule::GetRemoteInstallFileSpec",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetRemoteInstallFileSpec",1,"lldb::SBModule *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_GetRemoteInstallFileSpec",1,SWIGTYPE_p_lldb__SBModule); + } + + result = (arg1)->GetRemoteInstallFileSpec(); + { + lldb::SBFileSpec * resultptr = new lldb::SBFileSpec(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_SetRemoteInstallFileSpec(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBFileSpec *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBModule::SetRemoteInstallFileSpec",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::SetRemoteInstallFileSpec",1,"lldb::SBModule *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBModule::SetRemoteInstallFileSpec",2,"lldb::SBFileSpec &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_SetRemoteInstallFileSpec",1,SWIGTYPE_p_lldb__SBModule); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBModule_SetRemoteInstallFileSpec",2,SWIGTYPE_p_lldb__SBFileSpec); + } + + result = (bool)(arg1)->SetRemoteInstallFileSpec(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_GetByteOrder(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::ByteOrder result; + + SWIG_check_num_args("lldb::SBModule::GetByteOrder",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetByteOrder",1,"lldb::SBModule *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_GetByteOrder",1,SWIGTYPE_p_lldb__SBModule); + } + + result = (lldb::ByteOrder)(arg1)->GetByteOrder(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_GetAddressByteSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBModule::GetAddressByteSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetAddressByteSize",1,"lldb::SBModule *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_GetAddressByteSize",1,SWIGTYPE_p_lldb__SBModule); + } + + result = (uint32_t)(arg1)->GetAddressByteSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_GetTriple(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBModule::GetTriple",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetTriple",1,"lldb::SBModule *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_GetTriple",1,SWIGTYPE_p_lldb__SBModule); + } + + result = (char *)(arg1)->GetTriple(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_GetUUIDBytes(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + uint8_t *result = 0 ; + + SWIG_check_num_args("lldb::SBModule::GetUUIDBytes",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetUUIDBytes",1,"lldb::SBModule const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_GetUUIDBytes",1,SWIGTYPE_p_lldb__SBModule); + } + + result = (uint8_t *)((lldb::SBModule const *)arg1)->GetUUIDBytes(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_unsigned_char,0); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_GetUUIDString(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBModule::GetUUIDString",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetUUIDString",1,"lldb::SBModule const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_GetUUIDString",1,SWIGTYPE_p_lldb__SBModule); + } + + result = (char *)((lldb::SBModule const *)arg1)->GetUUIDString(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule___eq(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBModule *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBModule::operator ==",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::operator ==",1,"lldb::SBModule const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBModule::operator ==",2,"lldb::SBModule const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule___eq",1,SWIGTYPE_p_lldb__SBModule); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule___eq",2,SWIGTYPE_p_lldb__SBModule); + } + + result = (bool)((lldb::SBModule const *)arg1)->operator ==((lldb::SBModule const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_FindSection(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBSection result; + + SWIG_check_num_args("lldb::SBModule::FindSection",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::FindSection",1,"lldb::SBModule *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBModule::FindSection",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_FindSection",1,SWIGTYPE_p_lldb__SBModule); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->FindSection((char const *)arg2); + { + lldb::SBSection * resultptr = new lldb::SBSection(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSection,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_ResolveFileAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::addr_t arg2 ; + lldb::SBAddress result; + + SWIG_check_num_args("lldb::SBModule::ResolveFileAddress",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::ResolveFileAddress",1,"lldb::SBModule *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBModule::ResolveFileAddress",2,"lldb::addr_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_ResolveFileAddress",1,SWIGTYPE_p_lldb__SBModule); + } + + arg2 = (lldb::addr_t)lua_tointeger(L, 2); + result = (arg1)->ResolveFileAddress(arg2); + { + lldb::SBAddress * resultptr = new lldb::SBAddress(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_ResolveSymbolContextForAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBAddress *arg2 = 0 ; + uint32_t arg3 ; + lldb::SBSymbolContext result; + + SWIG_check_num_args("lldb::SBModule::ResolveSymbolContextForAddress",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::ResolveSymbolContextForAddress",1,"lldb::SBModule *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBModule::ResolveSymbolContextForAddress",2,"lldb::SBAddress const &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBModule::ResolveSymbolContextForAddress",3,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_ResolveSymbolContextForAddress",1,SWIGTYPE_p_lldb__SBModule); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBModule_ResolveSymbolContextForAddress",2,SWIGTYPE_p_lldb__SBAddress); + } + + arg3 = (uint32_t)lua_tointeger(L, 3); + result = (arg1)->ResolveSymbolContextForAddress((lldb::SBAddress const &)*arg2,arg3); + { + lldb::SBSymbolContext * resultptr = new lldb::SBSymbolContext(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbolContext,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBModule::GetDescription",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetDescription",1,"lldb::SBModule *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBModule::GetDescription",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_GetDescription",1,SWIGTYPE_p_lldb__SBModule); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBModule_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)(arg1)->GetDescription(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_GetNumCompileUnits(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBModule::GetNumCompileUnits",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetNumCompileUnits",1,"lldb::SBModule *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_GetNumCompileUnits",1,SWIGTYPE_p_lldb__SBModule); + } + + result = (uint32_t)(arg1)->GetNumCompileUnits(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_GetCompileUnitAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + uint32_t arg2 ; + lldb::SBCompileUnit result; + + SWIG_check_num_args("lldb::SBModule::GetCompileUnitAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetCompileUnitAtIndex",1,"lldb::SBModule *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBModule::GetCompileUnitAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_GetCompileUnitAtIndex",1,SWIGTYPE_p_lldb__SBModule); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetCompileUnitAtIndex(arg2); + { + lldb::SBCompileUnit * resultptr = new lldb::SBCompileUnit(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBCompileUnit,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_FindCompileUnits(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBFileSpec *arg2 = 0 ; + lldb::SBSymbolContextList result; + + SWIG_check_num_args("lldb::SBModule::FindCompileUnits",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::FindCompileUnits",1,"lldb::SBModule *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBModule::FindCompileUnits",2,"lldb::SBFileSpec const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_FindCompileUnits",1,SWIGTYPE_p_lldb__SBModule); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBModule_FindCompileUnits",2,SWIGTYPE_p_lldb__SBFileSpec); + } + + result = (arg1)->FindCompileUnits((lldb::SBFileSpec const &)*arg2); + { + lldb::SBSymbolContextList * resultptr = new lldb::SBSymbolContextList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbolContextList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_GetNumSymbols(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + size_t result; + + SWIG_check_num_args("lldb::SBModule::GetNumSymbols",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetNumSymbols",1,"lldb::SBModule *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_GetNumSymbols",1,SWIGTYPE_p_lldb__SBModule); + } + + result = (arg1)->GetNumSymbols(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_GetSymbolAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + size_t arg2 ; + lldb::SBSymbol result; + + SWIG_check_num_args("lldb::SBModule::GetSymbolAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetSymbolAtIndex",1,"lldb::SBModule *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBModule::GetSymbolAtIndex",2,"size_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_GetSymbolAtIndex",1,SWIGTYPE_p_lldb__SBModule); + } + + arg2 = (size_t)lua_tointeger(L, 2); + result = (arg1)->GetSymbolAtIndex(arg2); + { + lldb::SBSymbol * resultptr = new lldb::SBSymbol(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbol,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_FindSymbol__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SymbolType arg3 ; + lldb::SBSymbol result; + + SWIG_check_num_args("lldb::SBModule::FindSymbol",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::FindSymbol",1,"lldb::SBModule *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBModule::FindSymbol",2,"char const *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBModule::FindSymbol",3,"lldb::SymbolType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_FindSymbol",1,SWIGTYPE_p_lldb__SBModule); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (lldb::SymbolType)lua_tointeger(L, 3); + result = (arg1)->FindSymbol((char const *)arg2,arg3); + { + lldb::SBSymbol * resultptr = new lldb::SBSymbol(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbol,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_FindSymbol__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBSymbol result; + + SWIG_check_num_args("lldb::SBModule::FindSymbol",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::FindSymbol",1,"lldb::SBModule *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBModule::FindSymbol",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_FindSymbol",1,SWIGTYPE_p_lldb__SBModule); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->FindSymbol((char const *)arg2); + { + lldb::SBSymbol * resultptr = new lldb::SBSymbol(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbol,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_FindSymbol(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBModule, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + return _wrap_SBModule_FindSymbol__SWIG_1(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBModule, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + return _wrap_SBModule_FindSymbol__SWIG_0(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBModule_FindSymbols__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SymbolType arg3 ; + lldb::SBSymbolContextList result; + + SWIG_check_num_args("lldb::SBModule::FindSymbols",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::FindSymbols",1,"lldb::SBModule *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBModule::FindSymbols",2,"char const *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBModule::FindSymbols",3,"lldb::SymbolType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_FindSymbols",1,SWIGTYPE_p_lldb__SBModule); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (lldb::SymbolType)lua_tointeger(L, 3); + result = (arg1)->FindSymbols((char const *)arg2,arg3); + { + lldb::SBSymbolContextList * resultptr = new lldb::SBSymbolContextList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbolContextList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_FindSymbols__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBSymbolContextList result; + + SWIG_check_num_args("lldb::SBModule::FindSymbols",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::FindSymbols",1,"lldb::SBModule *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBModule::FindSymbols",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_FindSymbols",1,SWIGTYPE_p_lldb__SBModule); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->FindSymbols((char const *)arg2); + { + lldb::SBSymbolContextList * resultptr = new lldb::SBSymbolContextList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbolContextList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_FindSymbols(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBModule, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + return _wrap_SBModule_FindSymbols__SWIG_1(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBModule, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + return _wrap_SBModule_FindSymbols__SWIG_0(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBModule_GetNumSections(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + size_t result; + + SWIG_check_num_args("lldb::SBModule::GetNumSections",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetNumSections",1,"lldb::SBModule *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_GetNumSections",1,SWIGTYPE_p_lldb__SBModule); + } + + result = (arg1)->GetNumSections(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_GetSectionAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + size_t arg2 ; + lldb::SBSection result; + + SWIG_check_num_args("lldb::SBModule::GetSectionAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetSectionAtIndex",1,"lldb::SBModule *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBModule::GetSectionAtIndex",2,"size_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_GetSectionAtIndex",1,SWIGTYPE_p_lldb__SBModule); + } + + arg2 = (size_t)lua_tointeger(L, 2); + result = (arg1)->GetSectionAtIndex(arg2); + { + lldb::SBSection * resultptr = new lldb::SBSection(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSection,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_FindFunctions__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + char *arg2 = (char *) 0 ; + uint32_t arg3 ; + lldb::SBSymbolContextList result; + + SWIG_check_num_args("lldb::SBModule::FindFunctions",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::FindFunctions",1,"lldb::SBModule *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBModule::FindFunctions",2,"char const *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBModule::FindFunctions",3,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_FindFunctions",1,SWIGTYPE_p_lldb__SBModule); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (uint32_t)lua_tointeger(L, 3); + result = (arg1)->FindFunctions((char const *)arg2,arg3); + { + lldb::SBSymbolContextList * resultptr = new lldb::SBSymbolContextList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbolContextList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_FindFunctions__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBSymbolContextList result; + + SWIG_check_num_args("lldb::SBModule::FindFunctions",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::FindFunctions",1,"lldb::SBModule *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBModule::FindFunctions",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_FindFunctions",1,SWIGTYPE_p_lldb__SBModule); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->FindFunctions((char const *)arg2); + { + lldb::SBSymbolContextList * resultptr = new lldb::SBSymbolContextList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbolContextList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_FindFunctions(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBModule, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + return _wrap_SBModule_FindFunctions__SWIG_1(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBModule, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + return _wrap_SBModule_FindFunctions__SWIG_0(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBModule_FindGlobalVariables(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBTarget *arg2 = 0 ; + char *arg3 = (char *) 0 ; + uint32_t arg4 ; + lldb::SBValueList result; + + SWIG_check_num_args("lldb::SBModule::FindGlobalVariables",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::FindGlobalVariables",1,"lldb::SBModule *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBModule::FindGlobalVariables",2,"lldb::SBTarget &"); + if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBModule::FindGlobalVariables",3,"char const *"); + if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBModule::FindGlobalVariables",4,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_FindGlobalVariables",1,SWIGTYPE_p_lldb__SBModule); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBModule_FindGlobalVariables",2,SWIGTYPE_p_lldb__SBTarget); + } + + arg3 = (char *)lua_tostring(L, 3); + arg4 = (uint32_t)lua_tointeger(L, 4); + result = (arg1)->FindGlobalVariables(*arg2,(char const *)arg3,arg4); + { + lldb::SBValueList * resultptr = new lldb::SBValueList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValueList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_FindFirstGlobalVariable(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBTarget *arg2 = 0 ; + char *arg3 = (char *) 0 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBModule::FindFirstGlobalVariable",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::FindFirstGlobalVariable",1,"lldb::SBModule *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBModule::FindFirstGlobalVariable",2,"lldb::SBTarget &"); + if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBModule::FindFirstGlobalVariable",3,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_FindFirstGlobalVariable",1,SWIGTYPE_p_lldb__SBModule); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBModule_FindFirstGlobalVariable",2,SWIGTYPE_p_lldb__SBTarget); + } + + arg3 = (char *)lua_tostring(L, 3); + result = (arg1)->FindFirstGlobalVariable(*arg2,(char const *)arg3); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_FindFirstType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBType result; + + SWIG_check_num_args("lldb::SBModule::FindFirstType",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::FindFirstType",1,"lldb::SBModule *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBModule::FindFirstType",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_FindFirstType",1,SWIGTYPE_p_lldb__SBModule); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->FindFirstType((char const *)arg2); + { + lldb::SBType * resultptr = new lldb::SBType(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_FindTypes(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBTypeList result; + + SWIG_check_num_args("lldb::SBModule::FindTypes",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::FindTypes",1,"lldb::SBModule *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBModule::FindTypes",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_FindTypes",1,SWIGTYPE_p_lldb__SBModule); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->FindTypes((char const *)arg2); + { + lldb::SBTypeList * resultptr = new lldb::SBTypeList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_GetTypeByID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::user_id_t arg2 ; + lldb::SBType result; + + SWIG_check_num_args("lldb::SBModule::GetTypeByID",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetTypeByID",1,"lldb::SBModule *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBModule::GetTypeByID",2,"lldb::user_id_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_GetTypeByID",1,SWIGTYPE_p_lldb__SBModule); + } + + arg2 = (lldb::user_id_t)lua_tointeger(L, 2); + result = (arg1)->GetTypeByID(arg2); + { + lldb::SBType * resultptr = new lldb::SBType(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_GetBasicType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::BasicType arg2 ; + lldb::SBType result; + + SWIG_check_num_args("lldb::SBModule::GetBasicType",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetBasicType",1,"lldb::SBModule *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBModule::GetBasicType",2,"lldb::BasicType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_GetBasicType",1,SWIGTYPE_p_lldb__SBModule); + } + + arg2 = (lldb::BasicType)lua_tointeger(L, 2); + result = (arg1)->GetBasicType(arg2); + { + lldb::SBType * resultptr = new lldb::SBType(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_GetTypes__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + uint32_t arg2 ; + lldb::SBTypeList result; + + SWIG_check_num_args("lldb::SBModule::GetTypes",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetTypes",1,"lldb::SBModule *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBModule::GetTypes",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_GetTypes",1,SWIGTYPE_p_lldb__SBModule); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetTypes(arg2); + { + lldb::SBTypeList * resultptr = new lldb::SBTypeList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_GetTypes__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBTypeList result; + + SWIG_check_num_args("lldb::SBModule::GetTypes",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetTypes",1,"lldb::SBModule *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_GetTypes",1,SWIGTYPE_p_lldb__SBModule); + } + + result = (arg1)->GetTypes(); + { + lldb::SBTypeList * resultptr = new lldb::SBTypeList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_GetTypes(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBModule, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBModule_GetTypes__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBModule, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_SBModule_GetTypes__SWIG_0(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBModule_GetTypes'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBModule::GetTypes(uint32_t)\n" + " lldb::SBModule::GetTypes()\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBModule_GetVersion(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + uint32_t *arg2 = (uint32_t *) 0 ; + uint32_t arg3 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBModule::GetVersion",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetVersion",1,"lldb::SBModule *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_GetVersion",1,SWIGTYPE_p_lldb__SBModule); + } + + { + arg3 = 99; + arg2 = (uint32_t *)malloc(sizeof(uint32_t) * arg3); + } + result = (uint32_t)(arg1)->GetVersion(arg2,arg3); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + { + uint32_t count = result; + if (count >= arg3) + count = arg3; + lua_newtable(L); + int i = 0; + while (i++ < count) { + lua_pushinteger(L, arg2[i - 1]); + lua_seti(L, -2, i); + } + SWIG_arg++; + free(arg2); + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_GetSymbolFileSpec(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBFileSpec result; + + SWIG_check_num_args("lldb::SBModule::GetSymbolFileSpec",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetSymbolFileSpec",1,"lldb::SBModule const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_GetSymbolFileSpec",1,SWIGTYPE_p_lldb__SBModule); + } + + result = ((lldb::SBModule const *)arg1)->GetSymbolFileSpec(); + { + lldb::SBFileSpec * resultptr = new lldb::SBFileSpec(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_GetObjectFileHeaderAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBAddress result; + + SWIG_check_num_args("lldb::SBModule::GetObjectFileHeaderAddress",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetObjectFileHeaderAddress",1,"lldb::SBModule const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_GetObjectFileHeaderAddress",1,SWIGTYPE_p_lldb__SBModule); + } + + result = ((lldb::SBModule const *)arg1)->GetObjectFileHeaderAddress(); + { + lldb::SBAddress * resultptr = new lldb::SBAddress(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_GetObjectFileEntryPointAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + lldb::SBAddress result; + + SWIG_check_num_args("lldb::SBModule::GetObjectFileEntryPointAddress",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::GetObjectFileEntryPointAddress",1,"lldb::SBModule const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule_GetObjectFileEntryPointAddress",1,SWIGTYPE_p_lldb__SBModule); + } + + result = ((lldb::SBModule const *)arg1)->GetObjectFileEntryPointAddress(); + { + lldb::SBAddress * resultptr = new lldb::SBAddress(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_GetNumberAllocatedModules(lua_State* L) { + { + int SWIG_arg = 0; + uint32_t result; + + SWIG_check_num_args("lldb::SBModule::GetNumberAllocatedModules",0,0) + result = (uint32_t)lldb::SBModule::GetNumberAllocatedModules(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule_GarbageCollectAllocatedModules(lua_State* L) { + { + int SWIG_arg = 0; + + SWIG_check_num_args("lldb::SBModule::GarbageCollectAllocatedModules",0,0) + lldb::SBModule::GarbageCollectAllocatedModules(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModule___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModule *arg1 = (lldb::SBModule *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBModule::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModule::__repr__",1,"lldb::SBModule *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBModule___tostring",1,SWIGTYPE_p_lldb__SBModule); + } + + result = lldb_SBModule___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBModule(void *obj) { +lldb::SBModule *arg1 = (lldb::SBModule *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBModule(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBModule); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBModule_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBModule_methods[]= { + { "IsValid", _wrap_SBModule_IsValid}, + { "Clear", _wrap_SBModule_Clear}, + { "IsFileBacked", _wrap_SBModule_IsFileBacked}, + { "GetFileSpec", _wrap_SBModule_GetFileSpec}, + { "GetPlatformFileSpec", _wrap_SBModule_GetPlatformFileSpec}, + { "SetPlatformFileSpec", _wrap_SBModule_SetPlatformFileSpec}, + { "GetRemoteInstallFileSpec", _wrap_SBModule_GetRemoteInstallFileSpec}, + { "SetRemoteInstallFileSpec", _wrap_SBModule_SetRemoteInstallFileSpec}, + { "GetByteOrder", _wrap_SBModule_GetByteOrder}, + { "GetAddressByteSize", _wrap_SBModule_GetAddressByteSize}, + { "GetTriple", _wrap_SBModule_GetTriple}, + { "GetUUIDBytes", _wrap_SBModule_GetUUIDBytes}, + { "GetUUIDString", _wrap_SBModule_GetUUIDString}, + { "__eq", _wrap_SBModule___eq}, + { "FindSection", _wrap_SBModule_FindSection}, + { "ResolveFileAddress", _wrap_SBModule_ResolveFileAddress}, + { "ResolveSymbolContextForAddress", _wrap_SBModule_ResolveSymbolContextForAddress}, + { "GetDescription", _wrap_SBModule_GetDescription}, + { "GetNumCompileUnits", _wrap_SBModule_GetNumCompileUnits}, + { "GetCompileUnitAtIndex", _wrap_SBModule_GetCompileUnitAtIndex}, + { "FindCompileUnits", _wrap_SBModule_FindCompileUnits}, + { "GetNumSymbols", _wrap_SBModule_GetNumSymbols}, + { "GetSymbolAtIndex", _wrap_SBModule_GetSymbolAtIndex}, + { "FindSymbol", _wrap_SBModule_FindSymbol}, + { "FindSymbols", _wrap_SBModule_FindSymbols}, + { "GetNumSections", _wrap_SBModule_GetNumSections}, + { "GetSectionAtIndex", _wrap_SBModule_GetSectionAtIndex}, + { "FindFunctions", _wrap_SBModule_FindFunctions}, + { "FindGlobalVariables", _wrap_SBModule_FindGlobalVariables}, + { "FindFirstGlobalVariable", _wrap_SBModule_FindFirstGlobalVariable}, + { "FindFirstType", _wrap_SBModule_FindFirstType}, + { "FindTypes", _wrap_SBModule_FindTypes}, + { "GetTypeByID", _wrap_SBModule_GetTypeByID}, + { "GetBasicType", _wrap_SBModule_GetBasicType}, + { "GetTypes", _wrap_SBModule_GetTypes}, + { "GetVersion", _wrap_SBModule_GetVersion}, + { "GetSymbolFileSpec", _wrap_SBModule_GetSymbolFileSpec}, + { "GetObjectFileHeaderAddress", _wrap_SBModule_GetObjectFileHeaderAddress}, + { "GetObjectFileEntryPointAddress", _wrap_SBModule_GetObjectFileEntryPointAddress}, + { "__tostring", _wrap_SBModule___tostring}, + {0,0} +}; +static swig_lua_method swig_SBModule_meta[] = { + { "__eq", _wrap_SBModule___eq}, + { "__tostring", _wrap_SBModule___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBModule_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBModule_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBModule_Sf_SwigStatic_methods[]= { + { "GetNumberAllocatedModules", _wrap_SBModule_GetNumberAllocatedModules}, + { "GarbageCollectAllocatedModules", _wrap_SBModule_GarbageCollectAllocatedModules}, + {0,0} +}; +static swig_lua_class* swig_SBModule_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBModule_Sf_SwigStatic = { + "SBModule", + swig_SBModule_Sf_SwigStatic_methods, + swig_SBModule_Sf_SwigStatic_attributes, + swig_SBModule_Sf_SwigStatic_constants, + swig_SBModule_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBModule_bases[] = {0}; +static const char *swig_SBModule_base_names[] = {0}; +static swig_lua_class _wrap_class_SBModule = { "SBModule", "SBModule", &SWIGTYPE_p_lldb__SBModule,_proxy__wrap_new_SBModule, swig_delete_SBModule, swig_SBModule_methods, swig_SBModule_attributes, &swig_SBModule_Sf_SwigStatic, swig_SBModule_meta, swig_SBModule_bases, swig_SBModule_base_names }; + +static int _wrap_new_SBModuleSpec__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModuleSpec *result = 0 ; + + SWIG_check_num_args("lldb::SBModuleSpec::SBModuleSpec",0,0) + result = (lldb::SBModuleSpec *)new lldb::SBModuleSpec(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBModuleSpec,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBModuleSpec__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModuleSpec *arg1 = 0 ; + lldb::SBModuleSpec *result = 0 ; + + SWIG_check_num_args("lldb::SBModuleSpec::SBModuleSpec",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::SBModuleSpec",1,"lldb::SBModuleSpec const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){ + SWIG_fail_ptr("new_SBModuleSpec",1,SWIGTYPE_p_lldb__SBModuleSpec); + } + + result = (lldb::SBModuleSpec *)new lldb::SBModuleSpec((lldb::SBModuleSpec const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBModuleSpec,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBModuleSpec(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBModuleSpec__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBModuleSpec, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBModuleSpec__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBModuleSpec'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBModuleSpec::SBModuleSpec()\n" + " lldb::SBModuleSpec::SBModuleSpec(lldb::SBModuleSpec const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBModuleSpec_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBModuleSpec::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::IsValid",1,"lldb::SBModuleSpec const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){ + SWIG_fail_ptr("SBModuleSpec_IsValid",1,SWIGTYPE_p_lldb__SBModuleSpec); + } + + result = (bool)((lldb::SBModuleSpec const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModuleSpec_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + + SWIG_check_num_args("lldb::SBModuleSpec::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::Clear",1,"lldb::SBModuleSpec *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){ + SWIG_fail_ptr("SBModuleSpec_Clear",1,SWIGTYPE_p_lldb__SBModuleSpec); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModuleSpec_GetFileSpec(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + lldb::SBFileSpec result; + + SWIG_check_num_args("lldb::SBModuleSpec::GetFileSpec",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::GetFileSpec",1,"lldb::SBModuleSpec *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){ + SWIG_fail_ptr("SBModuleSpec_GetFileSpec",1,SWIGTYPE_p_lldb__SBModuleSpec); + } + + result = (arg1)->GetFileSpec(); + { + lldb::SBFileSpec * resultptr = new lldb::SBFileSpec(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModuleSpec_SetFileSpec(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + lldb::SBFileSpec *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBModuleSpec::SetFileSpec",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::SetFileSpec",1,"lldb::SBModuleSpec *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBModuleSpec::SetFileSpec",2,"lldb::SBFileSpec const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){ + SWIG_fail_ptr("SBModuleSpec_SetFileSpec",1,SWIGTYPE_p_lldb__SBModuleSpec); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBModuleSpec_SetFileSpec",2,SWIGTYPE_p_lldb__SBFileSpec); + } + + (arg1)->SetFileSpec((lldb::SBFileSpec const &)*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModuleSpec_GetPlatformFileSpec(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + lldb::SBFileSpec result; + + SWIG_check_num_args("lldb::SBModuleSpec::GetPlatformFileSpec",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::GetPlatformFileSpec",1,"lldb::SBModuleSpec *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){ + SWIG_fail_ptr("SBModuleSpec_GetPlatformFileSpec",1,SWIGTYPE_p_lldb__SBModuleSpec); + } + + result = (arg1)->GetPlatformFileSpec(); + { + lldb::SBFileSpec * resultptr = new lldb::SBFileSpec(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModuleSpec_SetPlatformFileSpec(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + lldb::SBFileSpec *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBModuleSpec::SetPlatformFileSpec",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::SetPlatformFileSpec",1,"lldb::SBModuleSpec *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBModuleSpec::SetPlatformFileSpec",2,"lldb::SBFileSpec const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){ + SWIG_fail_ptr("SBModuleSpec_SetPlatformFileSpec",1,SWIGTYPE_p_lldb__SBModuleSpec); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBModuleSpec_SetPlatformFileSpec",2,SWIGTYPE_p_lldb__SBFileSpec); + } + + (arg1)->SetPlatformFileSpec((lldb::SBFileSpec const &)*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModuleSpec_GetSymbolFileSpec(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + lldb::SBFileSpec result; + + SWIG_check_num_args("lldb::SBModuleSpec::GetSymbolFileSpec",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::GetSymbolFileSpec",1,"lldb::SBModuleSpec *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){ + SWIG_fail_ptr("SBModuleSpec_GetSymbolFileSpec",1,SWIGTYPE_p_lldb__SBModuleSpec); + } + + result = (arg1)->GetSymbolFileSpec(); + { + lldb::SBFileSpec * resultptr = new lldb::SBFileSpec(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModuleSpec_SetSymbolFileSpec(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + lldb::SBFileSpec *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBModuleSpec::SetSymbolFileSpec",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::SetSymbolFileSpec",1,"lldb::SBModuleSpec *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBModuleSpec::SetSymbolFileSpec",2,"lldb::SBFileSpec const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){ + SWIG_fail_ptr("SBModuleSpec_SetSymbolFileSpec",1,SWIGTYPE_p_lldb__SBModuleSpec); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBModuleSpec_SetSymbolFileSpec",2,SWIGTYPE_p_lldb__SBFileSpec); + } + + (arg1)->SetSymbolFileSpec((lldb::SBFileSpec const &)*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModuleSpec_GetObjectName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBModuleSpec::GetObjectName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::GetObjectName",1,"lldb::SBModuleSpec *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){ + SWIG_fail_ptr("SBModuleSpec_GetObjectName",1,SWIGTYPE_p_lldb__SBModuleSpec); + } + + result = (char *)(arg1)->GetObjectName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModuleSpec_SetObjectName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBModuleSpec::SetObjectName",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::SetObjectName",1,"lldb::SBModuleSpec *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBModuleSpec::SetObjectName",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){ + SWIG_fail_ptr("SBModuleSpec_SetObjectName",1,SWIGTYPE_p_lldb__SBModuleSpec); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetObjectName((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModuleSpec_GetTriple(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBModuleSpec::GetTriple",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::GetTriple",1,"lldb::SBModuleSpec *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){ + SWIG_fail_ptr("SBModuleSpec_GetTriple",1,SWIGTYPE_p_lldb__SBModuleSpec); + } + + result = (char *)(arg1)->GetTriple(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModuleSpec_SetTriple(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBModuleSpec::SetTriple",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::SetTriple",1,"lldb::SBModuleSpec *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBModuleSpec::SetTriple",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){ + SWIG_fail_ptr("SBModuleSpec_SetTriple",1,SWIGTYPE_p_lldb__SBModuleSpec); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetTriple((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModuleSpec_GetUUIDBytes(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + uint8_t *result = 0 ; + + SWIG_check_num_args("lldb::SBModuleSpec::GetUUIDBytes",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::GetUUIDBytes",1,"lldb::SBModuleSpec *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){ + SWIG_fail_ptr("SBModuleSpec_GetUUIDBytes",1,SWIGTYPE_p_lldb__SBModuleSpec); + } + + result = (uint8_t *)(arg1)->GetUUIDBytes(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_unsigned_char,0); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModuleSpec_GetUUIDLength(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + size_t result; + + SWIG_check_num_args("lldb::SBModuleSpec::GetUUIDLength",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::GetUUIDLength",1,"lldb::SBModuleSpec *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){ + SWIG_fail_ptr("SBModuleSpec_GetUUIDLength",1,SWIGTYPE_p_lldb__SBModuleSpec); + } + + result = (arg1)->GetUUIDLength(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModuleSpec_SetUUIDBytes(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + uint8_t *arg2 = (uint8_t *) 0 ; + size_t arg3 ; + bool result; + + SWIG_check_num_args("lldb::SBModuleSpec::SetUUIDBytes",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::SetUUIDBytes",1,"lldb::SBModuleSpec *"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("lldb::SBModuleSpec::SetUUIDBytes",2,"uint8_t const *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBModuleSpec::SetUUIDBytes",3,"size_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){ + SWIG_fail_ptr("SBModuleSpec_SetUUIDBytes",1,SWIGTYPE_p_lldb__SBModuleSpec); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_char,0))){ + SWIG_fail_ptr("SBModuleSpec_SetUUIDBytes",2,SWIGTYPE_p_unsigned_char); + } + + arg3 = (size_t)lua_tointeger(L, 3); + result = (bool)(arg1)->SetUUIDBytes((uint8_t const *)arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModuleSpec_GetObjectOffset(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + uint64_t result; + + SWIG_check_num_args("lldb::SBModuleSpec::GetObjectOffset",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::GetObjectOffset",1,"lldb::SBModuleSpec *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){ + SWIG_fail_ptr("SBModuleSpec_GetObjectOffset",1,SWIGTYPE_p_lldb__SBModuleSpec); + } + + result = (uint64_t)(arg1)->GetObjectOffset(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModuleSpec_SetObjectOffset(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + uint64_t arg2 ; + + SWIG_check_num_args("lldb::SBModuleSpec::SetObjectOffset",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::SetObjectOffset",1,"lldb::SBModuleSpec *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBModuleSpec::SetObjectOffset",2,"uint64_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){ + SWIG_fail_ptr("SBModuleSpec_SetObjectOffset",1,SWIGTYPE_p_lldb__SBModuleSpec); + } + + arg2 = (uint64_t)lua_tointeger(L, 2); + (arg1)->SetObjectOffset(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModuleSpec_GetObjectSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + uint64_t result; + + SWIG_check_num_args("lldb::SBModuleSpec::GetObjectSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::GetObjectSize",1,"lldb::SBModuleSpec *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){ + SWIG_fail_ptr("SBModuleSpec_GetObjectSize",1,SWIGTYPE_p_lldb__SBModuleSpec); + } + + result = (uint64_t)(arg1)->GetObjectSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModuleSpec_SetObjectSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + uint64_t arg2 ; + + SWIG_check_num_args("lldb::SBModuleSpec::SetObjectSize",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::SetObjectSize",1,"lldb::SBModuleSpec *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBModuleSpec::SetObjectSize",2,"uint64_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){ + SWIG_fail_ptr("SBModuleSpec_SetObjectSize",1,SWIGTYPE_p_lldb__SBModuleSpec); + } + + arg2 = (uint64_t)lua_tointeger(L, 2); + (arg1)->SetObjectSize(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModuleSpec_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBModuleSpec::GetDescription",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::GetDescription",1,"lldb::SBModuleSpec *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBModuleSpec::GetDescription",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){ + SWIG_fail_ptr("SBModuleSpec_GetDescription",1,SWIGTYPE_p_lldb__SBModuleSpec); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBModuleSpec_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)(arg1)->GetDescription(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModuleSpec___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBModuleSpec::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpec::__repr__",1,"lldb::SBModuleSpec *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpec,0))){ + SWIG_fail_ptr("SBModuleSpec___tostring",1,SWIGTYPE_p_lldb__SBModuleSpec); + } + + result = lldb_SBModuleSpec___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBModuleSpec(void *obj) { +lldb::SBModuleSpec *arg1 = (lldb::SBModuleSpec *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBModuleSpec(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBModuleSpec); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBModuleSpec_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBModuleSpec_methods[]= { + { "IsValid", _wrap_SBModuleSpec_IsValid}, + { "Clear", _wrap_SBModuleSpec_Clear}, + { "GetFileSpec", _wrap_SBModuleSpec_GetFileSpec}, + { "SetFileSpec", _wrap_SBModuleSpec_SetFileSpec}, + { "GetPlatformFileSpec", _wrap_SBModuleSpec_GetPlatformFileSpec}, + { "SetPlatformFileSpec", _wrap_SBModuleSpec_SetPlatformFileSpec}, + { "GetSymbolFileSpec", _wrap_SBModuleSpec_GetSymbolFileSpec}, + { "SetSymbolFileSpec", _wrap_SBModuleSpec_SetSymbolFileSpec}, + { "GetObjectName", _wrap_SBModuleSpec_GetObjectName}, + { "SetObjectName", _wrap_SBModuleSpec_SetObjectName}, + { "GetTriple", _wrap_SBModuleSpec_GetTriple}, + { "SetTriple", _wrap_SBModuleSpec_SetTriple}, + { "GetUUIDBytes", _wrap_SBModuleSpec_GetUUIDBytes}, + { "GetUUIDLength", _wrap_SBModuleSpec_GetUUIDLength}, + { "SetUUIDBytes", _wrap_SBModuleSpec_SetUUIDBytes}, + { "GetObjectOffset", _wrap_SBModuleSpec_GetObjectOffset}, + { "SetObjectOffset", _wrap_SBModuleSpec_SetObjectOffset}, + { "GetObjectSize", _wrap_SBModuleSpec_GetObjectSize}, + { "SetObjectSize", _wrap_SBModuleSpec_SetObjectSize}, + { "GetDescription", _wrap_SBModuleSpec_GetDescription}, + { "__tostring", _wrap_SBModuleSpec___tostring}, + {0,0} +}; +static swig_lua_method swig_SBModuleSpec_meta[] = { + { "__tostring", _wrap_SBModuleSpec___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBModuleSpec_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBModuleSpec_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBModuleSpec_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBModuleSpec_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBModuleSpec_Sf_SwigStatic = { + "SBModuleSpec", + swig_SBModuleSpec_Sf_SwigStatic_methods, + swig_SBModuleSpec_Sf_SwigStatic_attributes, + swig_SBModuleSpec_Sf_SwigStatic_constants, + swig_SBModuleSpec_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBModuleSpec_bases[] = {0}; +static const char *swig_SBModuleSpec_base_names[] = {0}; +static swig_lua_class _wrap_class_SBModuleSpec = { "SBModuleSpec", "SBModuleSpec", &SWIGTYPE_p_lldb__SBModuleSpec,_proxy__wrap_new_SBModuleSpec, swig_delete_SBModuleSpec, swig_SBModuleSpec_methods, swig_SBModuleSpec_attributes, &swig_SBModuleSpec_Sf_SwigStatic, swig_SBModuleSpec_meta, swig_SBModuleSpec_bases, swig_SBModuleSpec_base_names }; + +static int _wrap_new_SBModuleSpecList__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModuleSpecList *result = 0 ; + + SWIG_check_num_args("lldb::SBModuleSpecList::SBModuleSpecList",0,0) + result = (lldb::SBModuleSpecList *)new lldb::SBModuleSpecList(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBModuleSpecList,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBModuleSpecList__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModuleSpecList *arg1 = 0 ; + lldb::SBModuleSpecList *result = 0 ; + + SWIG_check_num_args("lldb::SBModuleSpecList::SBModuleSpecList",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBModuleSpecList::SBModuleSpecList",1,"lldb::SBModuleSpecList const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpecList,0))){ + SWIG_fail_ptr("new_SBModuleSpecList",1,SWIGTYPE_p_lldb__SBModuleSpecList); + } + + result = (lldb::SBModuleSpecList *)new lldb::SBModuleSpecList((lldb::SBModuleSpecList const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBModuleSpecList,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBModuleSpecList(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBModuleSpecList__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBModuleSpecList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBModuleSpecList__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBModuleSpecList'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBModuleSpecList::SBModuleSpecList()\n" + " lldb::SBModuleSpecList::SBModuleSpecList(lldb::SBModuleSpecList const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBModuleSpecList_GetModuleSpecifications(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + lldb::SBModuleSpecList result; + + SWIG_check_num_args("lldb::SBModuleSpecList::GetModuleSpecifications",1,1) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBModuleSpecList::GetModuleSpecifications",1,"char const *"); + arg1 = (char *)lua_tostring(L, 1); + result = lldb::SBModuleSpecList::GetModuleSpecifications((char const *)arg1); + { + lldb::SBModuleSpecList * resultptr = new lldb::SBModuleSpecList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBModuleSpecList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModuleSpecList_Append__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModuleSpecList *arg1 = (lldb::SBModuleSpecList *) 0 ; + lldb::SBModuleSpec *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBModuleSpecList::Append",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpecList::Append",1,"lldb::SBModuleSpecList *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBModuleSpecList::Append",2,"lldb::SBModuleSpec const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpecList,0))){ + SWIG_fail_ptr("SBModuleSpecList_Append",1,SWIGTYPE_p_lldb__SBModuleSpecList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBModuleSpec,0))){ + SWIG_fail_ptr("SBModuleSpecList_Append",2,SWIGTYPE_p_lldb__SBModuleSpec); + } + + (arg1)->Append((lldb::SBModuleSpec const &)*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModuleSpecList_Append__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModuleSpecList *arg1 = (lldb::SBModuleSpecList *) 0 ; + lldb::SBModuleSpecList *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBModuleSpecList::Append",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpecList::Append",1,"lldb::SBModuleSpecList *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBModuleSpecList::Append",2,"lldb::SBModuleSpecList const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpecList,0))){ + SWIG_fail_ptr("SBModuleSpecList_Append",1,SWIGTYPE_p_lldb__SBModuleSpecList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBModuleSpecList,0))){ + SWIG_fail_ptr("SBModuleSpecList_Append",2,SWIGTYPE_p_lldb__SBModuleSpecList); + } + + (arg1)->Append((lldb::SBModuleSpecList const &)*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModuleSpecList_Append(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBModuleSpecList, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBModuleSpec, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBModuleSpecList_Append__SWIG_0(L); + } + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBModuleSpecList, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBModuleSpecList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBModuleSpecList_Append__SWIG_1(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBModuleSpecList_FindFirstMatchingSpec(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModuleSpecList *arg1 = (lldb::SBModuleSpecList *) 0 ; + lldb::SBModuleSpec *arg2 = 0 ; + lldb::SBModuleSpec result; + + SWIG_check_num_args("lldb::SBModuleSpecList::FindFirstMatchingSpec",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpecList::FindFirstMatchingSpec",1,"lldb::SBModuleSpecList *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBModuleSpecList::FindFirstMatchingSpec",2,"lldb::SBModuleSpec const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpecList,0))){ + SWIG_fail_ptr("SBModuleSpecList_FindFirstMatchingSpec",1,SWIGTYPE_p_lldb__SBModuleSpecList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBModuleSpec,0))){ + SWIG_fail_ptr("SBModuleSpecList_FindFirstMatchingSpec",2,SWIGTYPE_p_lldb__SBModuleSpec); + } + + result = (arg1)->FindFirstMatchingSpec((lldb::SBModuleSpec const &)*arg2); + { + lldb::SBModuleSpec * resultptr = new lldb::SBModuleSpec(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBModuleSpec,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModuleSpecList_FindMatchingSpecs(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModuleSpecList *arg1 = (lldb::SBModuleSpecList *) 0 ; + lldb::SBModuleSpec *arg2 = 0 ; + lldb::SBModuleSpecList result; + + SWIG_check_num_args("lldb::SBModuleSpecList::FindMatchingSpecs",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpecList::FindMatchingSpecs",1,"lldb::SBModuleSpecList *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBModuleSpecList::FindMatchingSpecs",2,"lldb::SBModuleSpec const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpecList,0))){ + SWIG_fail_ptr("SBModuleSpecList_FindMatchingSpecs",1,SWIGTYPE_p_lldb__SBModuleSpecList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBModuleSpec,0))){ + SWIG_fail_ptr("SBModuleSpecList_FindMatchingSpecs",2,SWIGTYPE_p_lldb__SBModuleSpec); + } + + result = (arg1)->FindMatchingSpecs((lldb::SBModuleSpec const &)*arg2); + { + lldb::SBModuleSpecList * resultptr = new lldb::SBModuleSpecList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBModuleSpecList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModuleSpecList_GetSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModuleSpecList *arg1 = (lldb::SBModuleSpecList *) 0 ; + size_t result; + + SWIG_check_num_args("lldb::SBModuleSpecList::GetSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpecList::GetSize",1,"lldb::SBModuleSpecList *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpecList,0))){ + SWIG_fail_ptr("SBModuleSpecList_GetSize",1,SWIGTYPE_p_lldb__SBModuleSpecList); + } + + result = (arg1)->GetSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModuleSpecList_GetSpecAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModuleSpecList *arg1 = (lldb::SBModuleSpecList *) 0 ; + size_t arg2 ; + lldb::SBModuleSpec result; + + SWIG_check_num_args("lldb::SBModuleSpecList::GetSpecAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpecList::GetSpecAtIndex",1,"lldb::SBModuleSpecList *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBModuleSpecList::GetSpecAtIndex",2,"size_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpecList,0))){ + SWIG_fail_ptr("SBModuleSpecList_GetSpecAtIndex",1,SWIGTYPE_p_lldb__SBModuleSpecList); + } + + arg2 = (size_t)lua_tointeger(L, 2); + result = (arg1)->GetSpecAtIndex(arg2); + { + lldb::SBModuleSpec * resultptr = new lldb::SBModuleSpec(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBModuleSpec,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModuleSpecList_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModuleSpecList *arg1 = (lldb::SBModuleSpecList *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBModuleSpecList::GetDescription",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpecList::GetDescription",1,"lldb::SBModuleSpecList *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBModuleSpecList::GetDescription",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpecList,0))){ + SWIG_fail_ptr("SBModuleSpecList_GetDescription",1,SWIGTYPE_p_lldb__SBModuleSpecList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBModuleSpecList_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)(arg1)->GetDescription(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBModuleSpecList___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBModuleSpecList *arg1 = (lldb::SBModuleSpecList *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBModuleSpecList::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBModuleSpecList::__repr__",1,"lldb::SBModuleSpecList *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBModuleSpecList,0))){ + SWIG_fail_ptr("SBModuleSpecList___tostring",1,SWIGTYPE_p_lldb__SBModuleSpecList); + } + + result = lldb_SBModuleSpecList___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBModuleSpecList(void *obj) { +lldb::SBModuleSpecList *arg1 = (lldb::SBModuleSpecList *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBModuleSpecList(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBModuleSpecList); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBModuleSpecList_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBModuleSpecList_methods[]= { + { "Append", _wrap_SBModuleSpecList_Append}, + { "FindFirstMatchingSpec", _wrap_SBModuleSpecList_FindFirstMatchingSpec}, + { "FindMatchingSpecs", _wrap_SBModuleSpecList_FindMatchingSpecs}, + { "GetSize", _wrap_SBModuleSpecList_GetSize}, + { "GetSpecAtIndex", _wrap_SBModuleSpecList_GetSpecAtIndex}, + { "GetDescription", _wrap_SBModuleSpecList_GetDescription}, + { "__tostring", _wrap_SBModuleSpecList___tostring}, + {0,0} +}; +static swig_lua_method swig_SBModuleSpecList_meta[] = { + { "__tostring", _wrap_SBModuleSpecList___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBModuleSpecList_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBModuleSpecList_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBModuleSpecList_Sf_SwigStatic_methods[]= { + { "GetModuleSpecifications", _wrap_SBModuleSpecList_GetModuleSpecifications}, + {0,0} +}; +static swig_lua_class* swig_SBModuleSpecList_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBModuleSpecList_Sf_SwigStatic = { + "SBModuleSpecList", + swig_SBModuleSpecList_Sf_SwigStatic_methods, + swig_SBModuleSpecList_Sf_SwigStatic_attributes, + swig_SBModuleSpecList_Sf_SwigStatic_constants, + swig_SBModuleSpecList_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBModuleSpecList_bases[] = {0}; +static const char *swig_SBModuleSpecList_base_names[] = {0}; +static swig_lua_class _wrap_class_SBModuleSpecList = { "SBModuleSpecList", "SBModuleSpecList", &SWIGTYPE_p_lldb__SBModuleSpecList,_proxy__wrap_new_SBModuleSpecList, swig_delete_SBModuleSpecList, swig_SBModuleSpecList_methods, swig_SBModuleSpecList_attributes, &swig_SBModuleSpecList_Sf_SwigStatic, swig_SBModuleSpecList_meta, swig_SBModuleSpecList_bases, swig_SBModuleSpecList_base_names }; + +static int _wrap_new_SBPlatformConnectOptions__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + lldb::SBPlatformConnectOptions *result = 0 ; + + SWIG_check_num_args("lldb::SBPlatformConnectOptions::SBPlatformConnectOptions",1,1) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBPlatformConnectOptions::SBPlatformConnectOptions",1,"char const *"); + arg1 = (char *)lua_tostring(L, 1); + result = (lldb::SBPlatformConnectOptions *)new lldb::SBPlatformConnectOptions((char const *)arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBPlatformConnectOptions,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBPlatformConnectOptions__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatformConnectOptions *arg1 = 0 ; + lldb::SBPlatformConnectOptions *result = 0 ; + + SWIG_check_num_args("lldb::SBPlatformConnectOptions::SBPlatformConnectOptions",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBPlatformConnectOptions::SBPlatformConnectOptions",1,"lldb::SBPlatformConnectOptions const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformConnectOptions,0))){ + SWIG_fail_ptr("new_SBPlatformConnectOptions",1,SWIGTYPE_p_lldb__SBPlatformConnectOptions); + } + + result = (lldb::SBPlatformConnectOptions *)new lldb::SBPlatformConnectOptions((lldb::SBPlatformConnectOptions const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBPlatformConnectOptions,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBPlatformConnectOptions(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBPlatformConnectOptions, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBPlatformConnectOptions__SWIG_1(L); + } + } + if (argc == 1) { + int _v = 0; + { + _v = SWIG_lua_isnilstring(L,argv[0]); + } + if (_v) { + return _wrap_new_SBPlatformConnectOptions__SWIG_0(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBPlatformConnectOptions_GetURL(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatformConnectOptions *arg1 = (lldb::SBPlatformConnectOptions *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBPlatformConnectOptions::GetURL",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformConnectOptions::GetURL",1,"lldb::SBPlatformConnectOptions *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformConnectOptions,0))){ + SWIG_fail_ptr("SBPlatformConnectOptions_GetURL",1,SWIGTYPE_p_lldb__SBPlatformConnectOptions); + } + + result = (char *)(arg1)->GetURL(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatformConnectOptions_SetURL(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatformConnectOptions *arg1 = (lldb::SBPlatformConnectOptions *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBPlatformConnectOptions::SetURL",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformConnectOptions::SetURL",1,"lldb::SBPlatformConnectOptions *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBPlatformConnectOptions::SetURL",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformConnectOptions,0))){ + SWIG_fail_ptr("SBPlatformConnectOptions_SetURL",1,SWIGTYPE_p_lldb__SBPlatformConnectOptions); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetURL((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatformConnectOptions_GetRsyncEnabled(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatformConnectOptions *arg1 = (lldb::SBPlatformConnectOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBPlatformConnectOptions::GetRsyncEnabled",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformConnectOptions::GetRsyncEnabled",1,"lldb::SBPlatformConnectOptions *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformConnectOptions,0))){ + SWIG_fail_ptr("SBPlatformConnectOptions_GetRsyncEnabled",1,SWIGTYPE_p_lldb__SBPlatformConnectOptions); + } + + result = (bool)(arg1)->GetRsyncEnabled(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatformConnectOptions_EnableRsync(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatformConnectOptions *arg1 = (lldb::SBPlatformConnectOptions *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + bool arg4 ; + + SWIG_check_num_args("lldb::SBPlatformConnectOptions::EnableRsync",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformConnectOptions::EnableRsync",1,"lldb::SBPlatformConnectOptions *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBPlatformConnectOptions::EnableRsync",2,"char const *"); + if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBPlatformConnectOptions::EnableRsync",3,"char const *"); + if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBPlatformConnectOptions::EnableRsync",4,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformConnectOptions,0))){ + SWIG_fail_ptr("SBPlatformConnectOptions_EnableRsync",1,SWIGTYPE_p_lldb__SBPlatformConnectOptions); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (char *)lua_tostring(L, 3); + arg4 = (lua_toboolean(L, 4)!=0); + (arg1)->EnableRsync((char const *)arg2,(char const *)arg3,arg4); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatformConnectOptions_DisableRsync(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatformConnectOptions *arg1 = (lldb::SBPlatformConnectOptions *) 0 ; + + SWIG_check_num_args("lldb::SBPlatformConnectOptions::DisableRsync",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformConnectOptions::DisableRsync",1,"lldb::SBPlatformConnectOptions *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformConnectOptions,0))){ + SWIG_fail_ptr("SBPlatformConnectOptions_DisableRsync",1,SWIGTYPE_p_lldb__SBPlatformConnectOptions); + } + + (arg1)->DisableRsync(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatformConnectOptions_GetLocalCacheDirectory(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatformConnectOptions *arg1 = (lldb::SBPlatformConnectOptions *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBPlatformConnectOptions::GetLocalCacheDirectory",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformConnectOptions::GetLocalCacheDirectory",1,"lldb::SBPlatformConnectOptions *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformConnectOptions,0))){ + SWIG_fail_ptr("SBPlatformConnectOptions_GetLocalCacheDirectory",1,SWIGTYPE_p_lldb__SBPlatformConnectOptions); + } + + result = (char *)(arg1)->GetLocalCacheDirectory(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatformConnectOptions_SetLocalCacheDirectory(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatformConnectOptions *arg1 = (lldb::SBPlatformConnectOptions *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBPlatformConnectOptions::SetLocalCacheDirectory",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformConnectOptions::SetLocalCacheDirectory",1,"lldb::SBPlatformConnectOptions *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBPlatformConnectOptions::SetLocalCacheDirectory",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformConnectOptions,0))){ + SWIG_fail_ptr("SBPlatformConnectOptions_SetLocalCacheDirectory",1,SWIGTYPE_p_lldb__SBPlatformConnectOptions); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetLocalCacheDirectory((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBPlatformConnectOptions(void *obj) { +lldb::SBPlatformConnectOptions *arg1 = (lldb::SBPlatformConnectOptions *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBPlatformConnectOptions(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBPlatformConnectOptions); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBPlatformConnectOptions_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBPlatformConnectOptions_methods[]= { + { "GetURL", _wrap_SBPlatformConnectOptions_GetURL}, + { "SetURL", _wrap_SBPlatformConnectOptions_SetURL}, + { "GetRsyncEnabled", _wrap_SBPlatformConnectOptions_GetRsyncEnabled}, + { "EnableRsync", _wrap_SBPlatformConnectOptions_EnableRsync}, + { "DisableRsync", _wrap_SBPlatformConnectOptions_DisableRsync}, + { "GetLocalCacheDirectory", _wrap_SBPlatformConnectOptions_GetLocalCacheDirectory}, + { "SetLocalCacheDirectory", _wrap_SBPlatformConnectOptions_SetLocalCacheDirectory}, + {0,0} +}; +static swig_lua_method swig_SBPlatformConnectOptions_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBPlatformConnectOptions_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBPlatformConnectOptions_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBPlatformConnectOptions_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBPlatformConnectOptions_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBPlatformConnectOptions_Sf_SwigStatic = { + "SBPlatformConnectOptions", + swig_SBPlatformConnectOptions_Sf_SwigStatic_methods, + swig_SBPlatformConnectOptions_Sf_SwigStatic_attributes, + swig_SBPlatformConnectOptions_Sf_SwigStatic_constants, + swig_SBPlatformConnectOptions_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBPlatformConnectOptions_bases[] = {0}; +static const char *swig_SBPlatformConnectOptions_base_names[] = {0}; +static swig_lua_class _wrap_class_SBPlatformConnectOptions = { "SBPlatformConnectOptions", "SBPlatformConnectOptions", &SWIGTYPE_p_lldb__SBPlatformConnectOptions,_proxy__wrap_new_SBPlatformConnectOptions, swig_delete_SBPlatformConnectOptions, swig_SBPlatformConnectOptions_methods, swig_SBPlatformConnectOptions_attributes, &swig_SBPlatformConnectOptions_Sf_SwigStatic, swig_SBPlatformConnectOptions_meta, swig_SBPlatformConnectOptions_bases, swig_SBPlatformConnectOptions_base_names }; + +static int _wrap_new_SBPlatformShellCommand__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBPlatformShellCommand *result = 0 ; + + SWIG_check_num_args("lldb::SBPlatformShellCommand::SBPlatformShellCommand",2,2) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBPlatformShellCommand::SBPlatformShellCommand",1,"char const *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBPlatformShellCommand::SBPlatformShellCommand",2,"char const *"); + arg1 = (char *)lua_tostring(L, 1); + arg2 = (char *)lua_tostring(L, 2); + result = (lldb::SBPlatformShellCommand *)new lldb::SBPlatformShellCommand((char const *)arg1,(char const *)arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBPlatformShellCommand,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBPlatformShellCommand__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + lldb::SBPlatformShellCommand *result = 0 ; + + SWIG_check_num_args("lldb::SBPlatformShellCommand::SBPlatformShellCommand",1,1) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBPlatformShellCommand::SBPlatformShellCommand",1,"char const *"); + arg1 = (char *)lua_tostring(L, 1); + result = (lldb::SBPlatformShellCommand *)new lldb::SBPlatformShellCommand((char const *)arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBPlatformShellCommand,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBPlatformShellCommand__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatformShellCommand *arg1 = 0 ; + lldb::SBPlatformShellCommand *result = 0 ; + + SWIG_check_num_args("lldb::SBPlatformShellCommand::SBPlatformShellCommand",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBPlatformShellCommand::SBPlatformShellCommand",1,"lldb::SBPlatformShellCommand const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformShellCommand,0))){ + SWIG_fail_ptr("new_SBPlatformShellCommand",1,SWIGTYPE_p_lldb__SBPlatformShellCommand); + } + + result = (lldb::SBPlatformShellCommand *)new lldb::SBPlatformShellCommand((lldb::SBPlatformShellCommand const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBPlatformShellCommand,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBPlatformShellCommand(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBPlatformShellCommand, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBPlatformShellCommand__SWIG_2(L); + } + } + if (argc == 1) { + int _v = 0; + { + _v = SWIG_lua_isnilstring(L,argv[0]); + } + if (_v) { + return _wrap_new_SBPlatformShellCommand__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + _v = SWIG_lua_isnilstring(L,argv[0]); + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + return _wrap_new_SBPlatformShellCommand__SWIG_0(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBPlatformShellCommand_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ; + + SWIG_check_num_args("lldb::SBPlatformShellCommand::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformShellCommand::Clear",1,"lldb::SBPlatformShellCommand *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformShellCommand,0))){ + SWIG_fail_ptr("SBPlatformShellCommand_Clear",1,SWIGTYPE_p_lldb__SBPlatformShellCommand); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatformShellCommand_GetShell(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBPlatformShellCommand::GetShell",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformShellCommand::GetShell",1,"lldb::SBPlatformShellCommand *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformShellCommand,0))){ + SWIG_fail_ptr("SBPlatformShellCommand_GetShell",1,SWIGTYPE_p_lldb__SBPlatformShellCommand); + } + + result = (char *)(arg1)->GetShell(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatformShellCommand_SetShell(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBPlatformShellCommand::SetShell",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformShellCommand::SetShell",1,"lldb::SBPlatformShellCommand *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBPlatformShellCommand::SetShell",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformShellCommand,0))){ + SWIG_fail_ptr("SBPlatformShellCommand_SetShell",1,SWIGTYPE_p_lldb__SBPlatformShellCommand); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetShell((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatformShellCommand_GetCommand(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBPlatformShellCommand::GetCommand",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformShellCommand::GetCommand",1,"lldb::SBPlatformShellCommand *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformShellCommand,0))){ + SWIG_fail_ptr("SBPlatformShellCommand_GetCommand",1,SWIGTYPE_p_lldb__SBPlatformShellCommand); + } + + result = (char *)(arg1)->GetCommand(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatformShellCommand_SetCommand(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBPlatformShellCommand::SetCommand",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformShellCommand::SetCommand",1,"lldb::SBPlatformShellCommand *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBPlatformShellCommand::SetCommand",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformShellCommand,0))){ + SWIG_fail_ptr("SBPlatformShellCommand_SetCommand",1,SWIGTYPE_p_lldb__SBPlatformShellCommand); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetCommand((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatformShellCommand_GetWorkingDirectory(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBPlatformShellCommand::GetWorkingDirectory",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformShellCommand::GetWorkingDirectory",1,"lldb::SBPlatformShellCommand *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformShellCommand,0))){ + SWIG_fail_ptr("SBPlatformShellCommand_GetWorkingDirectory",1,SWIGTYPE_p_lldb__SBPlatformShellCommand); + } + + result = (char *)(arg1)->GetWorkingDirectory(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatformShellCommand_SetWorkingDirectory(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBPlatformShellCommand::SetWorkingDirectory",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformShellCommand::SetWorkingDirectory",1,"lldb::SBPlatformShellCommand *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBPlatformShellCommand::SetWorkingDirectory",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformShellCommand,0))){ + SWIG_fail_ptr("SBPlatformShellCommand_SetWorkingDirectory",1,SWIGTYPE_p_lldb__SBPlatformShellCommand); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetWorkingDirectory((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatformShellCommand_GetTimeoutSeconds(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBPlatformShellCommand::GetTimeoutSeconds",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformShellCommand::GetTimeoutSeconds",1,"lldb::SBPlatformShellCommand *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformShellCommand,0))){ + SWIG_fail_ptr("SBPlatformShellCommand_GetTimeoutSeconds",1,SWIGTYPE_p_lldb__SBPlatformShellCommand); + } + + result = (uint32_t)(arg1)->GetTimeoutSeconds(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatformShellCommand_SetTimeoutSeconds(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ; + uint32_t arg2 ; + + SWIG_check_num_args("lldb::SBPlatformShellCommand::SetTimeoutSeconds",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformShellCommand::SetTimeoutSeconds",1,"lldb::SBPlatformShellCommand *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBPlatformShellCommand::SetTimeoutSeconds",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformShellCommand,0))){ + SWIG_fail_ptr("SBPlatformShellCommand_SetTimeoutSeconds",1,SWIGTYPE_p_lldb__SBPlatformShellCommand); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + (arg1)->SetTimeoutSeconds(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatformShellCommand_GetSignal(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ; + int result; + + SWIG_check_num_args("lldb::SBPlatformShellCommand::GetSignal",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformShellCommand::GetSignal",1,"lldb::SBPlatformShellCommand *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformShellCommand,0))){ + SWIG_fail_ptr("SBPlatformShellCommand_GetSignal",1,SWIGTYPE_p_lldb__SBPlatformShellCommand); + } + + result = (int)(arg1)->GetSignal(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatformShellCommand_GetStatus(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ; + int result; + + SWIG_check_num_args("lldb::SBPlatformShellCommand::GetStatus",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformShellCommand::GetStatus",1,"lldb::SBPlatformShellCommand *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformShellCommand,0))){ + SWIG_fail_ptr("SBPlatformShellCommand_GetStatus",1,SWIGTYPE_p_lldb__SBPlatformShellCommand); + } + + result = (int)(arg1)->GetStatus(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatformShellCommand_GetOutput(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBPlatformShellCommand::GetOutput",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatformShellCommand::GetOutput",1,"lldb::SBPlatformShellCommand *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatformShellCommand,0))){ + SWIG_fail_ptr("SBPlatformShellCommand_GetOutput",1,SWIGTYPE_p_lldb__SBPlatformShellCommand); + } + + result = (char *)(arg1)->GetOutput(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBPlatformShellCommand(void *obj) { +lldb::SBPlatformShellCommand *arg1 = (lldb::SBPlatformShellCommand *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBPlatformShellCommand(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBPlatformShellCommand); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBPlatformShellCommand_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBPlatformShellCommand_methods[]= { + { "Clear", _wrap_SBPlatformShellCommand_Clear}, + { "GetShell", _wrap_SBPlatformShellCommand_GetShell}, + { "SetShell", _wrap_SBPlatformShellCommand_SetShell}, + { "GetCommand", _wrap_SBPlatformShellCommand_GetCommand}, + { "SetCommand", _wrap_SBPlatformShellCommand_SetCommand}, + { "GetWorkingDirectory", _wrap_SBPlatformShellCommand_GetWorkingDirectory}, + { "SetWorkingDirectory", _wrap_SBPlatformShellCommand_SetWorkingDirectory}, + { "GetTimeoutSeconds", _wrap_SBPlatformShellCommand_GetTimeoutSeconds}, + { "SetTimeoutSeconds", _wrap_SBPlatformShellCommand_SetTimeoutSeconds}, + { "GetSignal", _wrap_SBPlatformShellCommand_GetSignal}, + { "GetStatus", _wrap_SBPlatformShellCommand_GetStatus}, + { "GetOutput", _wrap_SBPlatformShellCommand_GetOutput}, + {0,0} +}; +static swig_lua_method swig_SBPlatformShellCommand_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBPlatformShellCommand_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBPlatformShellCommand_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBPlatformShellCommand_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBPlatformShellCommand_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBPlatformShellCommand_Sf_SwigStatic = { + "SBPlatformShellCommand", + swig_SBPlatformShellCommand_Sf_SwigStatic_methods, + swig_SBPlatformShellCommand_Sf_SwigStatic_attributes, + swig_SBPlatformShellCommand_Sf_SwigStatic_constants, + swig_SBPlatformShellCommand_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBPlatformShellCommand_bases[] = {0}; +static const char *swig_SBPlatformShellCommand_base_names[] = {0}; +static swig_lua_class _wrap_class_SBPlatformShellCommand = { "SBPlatformShellCommand", "SBPlatformShellCommand", &SWIGTYPE_p_lldb__SBPlatformShellCommand,_proxy__wrap_new_SBPlatformShellCommand, swig_delete_SBPlatformShellCommand, swig_SBPlatformShellCommand_methods, swig_SBPlatformShellCommand_attributes, &swig_SBPlatformShellCommand_Sf_SwigStatic, swig_SBPlatformShellCommand_meta, swig_SBPlatformShellCommand_bases, swig_SBPlatformShellCommand_base_names }; + +static int _wrap_new_SBPlatform__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatform *result = 0 ; + + SWIG_check_num_args("lldb::SBPlatform::SBPlatform",0,0) + result = (lldb::SBPlatform *)new lldb::SBPlatform(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBPlatform,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBPlatform__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + lldb::SBPlatform *result = 0 ; + + SWIG_check_num_args("lldb::SBPlatform::SBPlatform",1,1) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBPlatform::SBPlatform",1,"char const *"); + arg1 = (char *)lua_tostring(L, 1); + result = (lldb::SBPlatform *)new lldb::SBPlatform((char const *)arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBPlatform,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBPlatform__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatform *arg1 = 0 ; + lldb::SBPlatform *result = 0 ; + + SWIG_check_num_args("lldb::SBPlatform::SBPlatform",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBPlatform::SBPlatform",1,"lldb::SBPlatform const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){ + SWIG_fail_ptr("new_SBPlatform",1,SWIGTYPE_p_lldb__SBPlatform); + } + + result = (lldb::SBPlatform *)new lldb::SBPlatform((lldb::SBPlatform const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBPlatform,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBPlatform(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBPlatform__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBPlatform, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBPlatform__SWIG_2(L); + } + } + if (argc == 1) { + int _v = 0; + { + _v = SWIG_lua_isnilstring(L,argv[0]); + } + if (_v) { + return _wrap_new_SBPlatform__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBPlatform_GetHostPlatform(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatform result; + + SWIG_check_num_args("lldb::SBPlatform::GetHostPlatform",0,0) + result = lldb::SBPlatform::GetHostPlatform(); + { + lldb::SBPlatform * resultptr = new lldb::SBPlatform(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBPlatform,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatform_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBPlatform::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::IsValid",1,"lldb::SBPlatform const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){ + SWIG_fail_ptr("SBPlatform_IsValid",1,SWIGTYPE_p_lldb__SBPlatform); + } + + result = (bool)((lldb::SBPlatform const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatform_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + + SWIG_check_num_args("lldb::SBPlatform::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::Clear",1,"lldb::SBPlatform *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){ + SWIG_fail_ptr("SBPlatform_Clear",1,SWIGTYPE_p_lldb__SBPlatform); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatform_GetWorkingDirectory(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBPlatform::GetWorkingDirectory",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::GetWorkingDirectory",1,"lldb::SBPlatform *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){ + SWIG_fail_ptr("SBPlatform_GetWorkingDirectory",1,SWIGTYPE_p_lldb__SBPlatform); + } + + result = (char *)(arg1)->GetWorkingDirectory(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatform_SetWorkingDirectory(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + char *arg2 = (char *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBPlatform::SetWorkingDirectory",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::SetWorkingDirectory",1,"lldb::SBPlatform *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBPlatform::SetWorkingDirectory",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){ + SWIG_fail_ptr("SBPlatform_SetWorkingDirectory",1,SWIGTYPE_p_lldb__SBPlatform); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (bool)(arg1)->SetWorkingDirectory((char const *)arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatform_GetName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBPlatform::GetName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::GetName",1,"lldb::SBPlatform *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){ + SWIG_fail_ptr("SBPlatform_GetName",1,SWIGTYPE_p_lldb__SBPlatform); + } + + result = (char *)(arg1)->GetName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatform_ConnectRemote(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBPlatformConnectOptions *arg2 = 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBPlatform::ConnectRemote",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::ConnectRemote",1,"lldb::SBPlatform *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBPlatform::ConnectRemote",2,"lldb::SBPlatformConnectOptions &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){ + SWIG_fail_ptr("SBPlatform_ConnectRemote",1,SWIGTYPE_p_lldb__SBPlatform); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBPlatformConnectOptions,0))){ + SWIG_fail_ptr("SBPlatform_ConnectRemote",2,SWIGTYPE_p_lldb__SBPlatformConnectOptions); + } + + result = (arg1)->ConnectRemote(*arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatform_DisconnectRemote(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + + SWIG_check_num_args("lldb::SBPlatform::DisconnectRemote",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::DisconnectRemote",1,"lldb::SBPlatform *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){ + SWIG_fail_ptr("SBPlatform_DisconnectRemote",1,SWIGTYPE_p_lldb__SBPlatform); + } + + (arg1)->DisconnectRemote(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatform_IsConnected(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBPlatform::IsConnected",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::IsConnected",1,"lldb::SBPlatform *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){ + SWIG_fail_ptr("SBPlatform_IsConnected",1,SWIGTYPE_p_lldb__SBPlatform); + } + + result = (bool)(arg1)->IsConnected(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatform_GetTriple(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBPlatform::GetTriple",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::GetTriple",1,"lldb::SBPlatform *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){ + SWIG_fail_ptr("SBPlatform_GetTriple",1,SWIGTYPE_p_lldb__SBPlatform); + } + + result = (char *)(arg1)->GetTriple(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatform_GetHostname(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBPlatform::GetHostname",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::GetHostname",1,"lldb::SBPlatform *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){ + SWIG_fail_ptr("SBPlatform_GetHostname",1,SWIGTYPE_p_lldb__SBPlatform); + } + + result = (char *)(arg1)->GetHostname(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatform_GetOSBuild(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBPlatform::GetOSBuild",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::GetOSBuild",1,"lldb::SBPlatform *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){ + SWIG_fail_ptr("SBPlatform_GetOSBuild",1,SWIGTYPE_p_lldb__SBPlatform); + } + + result = (char *)(arg1)->GetOSBuild(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatform_GetOSDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBPlatform::GetOSDescription",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::GetOSDescription",1,"lldb::SBPlatform *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){ + SWIG_fail_ptr("SBPlatform_GetOSDescription",1,SWIGTYPE_p_lldb__SBPlatform); + } + + result = (char *)(arg1)->GetOSDescription(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatform_GetOSMajorVersion(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBPlatform::GetOSMajorVersion",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::GetOSMajorVersion",1,"lldb::SBPlatform *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){ + SWIG_fail_ptr("SBPlatform_GetOSMajorVersion",1,SWIGTYPE_p_lldb__SBPlatform); + } + + result = (uint32_t)(arg1)->GetOSMajorVersion(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatform_GetOSMinorVersion(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBPlatform::GetOSMinorVersion",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::GetOSMinorVersion",1,"lldb::SBPlatform *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){ + SWIG_fail_ptr("SBPlatform_GetOSMinorVersion",1,SWIGTYPE_p_lldb__SBPlatform); + } + + result = (uint32_t)(arg1)->GetOSMinorVersion(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatform_GetOSUpdateVersion(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBPlatform::GetOSUpdateVersion",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::GetOSUpdateVersion",1,"lldb::SBPlatform *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){ + SWIG_fail_ptr("SBPlatform_GetOSUpdateVersion",1,SWIGTYPE_p_lldb__SBPlatform); + } + + result = (uint32_t)(arg1)->GetOSUpdateVersion(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatform_SetSDKRoot(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBPlatform::SetSDKRoot",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::SetSDKRoot",1,"lldb::SBPlatform *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBPlatform::SetSDKRoot",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){ + SWIG_fail_ptr("SBPlatform_SetSDKRoot",1,SWIGTYPE_p_lldb__SBPlatform); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetSDKRoot((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatform_Put(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBFileSpec *arg2 = 0 ; + lldb::SBFileSpec *arg3 = 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBPlatform::Put",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::Put",1,"lldb::SBPlatform *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBPlatform::Put",2,"lldb::SBFileSpec &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBPlatform::Put",3,"lldb::SBFileSpec &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){ + SWIG_fail_ptr("SBPlatform_Put",1,SWIGTYPE_p_lldb__SBPlatform); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBPlatform_Put",2,SWIGTYPE_p_lldb__SBFileSpec); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBPlatform_Put",3,SWIGTYPE_p_lldb__SBFileSpec); + } + + result = (arg1)->Put(*arg2,*arg3); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatform_Get(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBFileSpec *arg2 = 0 ; + lldb::SBFileSpec *arg3 = 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBPlatform::Get",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::Get",1,"lldb::SBPlatform *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBPlatform::Get",2,"lldb::SBFileSpec &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBPlatform::Get",3,"lldb::SBFileSpec &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){ + SWIG_fail_ptr("SBPlatform_Get",1,SWIGTYPE_p_lldb__SBPlatform); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBPlatform_Get",2,SWIGTYPE_p_lldb__SBFileSpec); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBPlatform_Get",3,SWIGTYPE_p_lldb__SBFileSpec); + } + + result = (arg1)->Get(*arg2,*arg3); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatform_Install(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBFileSpec *arg2 = 0 ; + lldb::SBFileSpec *arg3 = 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBPlatform::Install",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::Install",1,"lldb::SBPlatform *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBPlatform::Install",2,"lldb::SBFileSpec &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBPlatform::Install",3,"lldb::SBFileSpec &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){ + SWIG_fail_ptr("SBPlatform_Install",1,SWIGTYPE_p_lldb__SBPlatform); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBPlatform_Install",2,SWIGTYPE_p_lldb__SBFileSpec); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBPlatform_Install",3,SWIGTYPE_p_lldb__SBFileSpec); + } + + result = (arg1)->Install(*arg2,*arg3); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatform_Run(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBPlatformShellCommand *arg2 = 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBPlatform::Run",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::Run",1,"lldb::SBPlatform *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBPlatform::Run",2,"lldb::SBPlatformShellCommand &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){ + SWIG_fail_ptr("SBPlatform_Run",1,SWIGTYPE_p_lldb__SBPlatform); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBPlatformShellCommand,0))){ + SWIG_fail_ptr("SBPlatform_Run",2,SWIGTYPE_p_lldb__SBPlatformShellCommand); + } + + result = (arg1)->Run(*arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatform_Launch(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBLaunchInfo *arg2 = 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBPlatform::Launch",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::Launch",1,"lldb::SBPlatform *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBPlatform::Launch",2,"lldb::SBLaunchInfo &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){ + SWIG_fail_ptr("SBPlatform_Launch",1,SWIGTYPE_p_lldb__SBPlatform); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBPlatform_Launch",2,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + result = (arg1)->Launch(*arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatform_Attach(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBAttachInfo *arg2 = 0 ; + lldb::SBDebugger *arg3 = 0 ; + lldb::SBTarget *arg4 = 0 ; + lldb::SBError *arg5 = 0 ; + lldb::SBProcess result; + + SWIG_check_num_args("lldb::SBPlatform::Attach",5,5) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::Attach",1,"lldb::SBPlatform *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBPlatform::Attach",2,"lldb::SBAttachInfo &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBPlatform::Attach",3,"lldb::SBDebugger const &"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBPlatform::Attach",4,"lldb::SBTarget &"); + if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBPlatform::Attach",5,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){ + SWIG_fail_ptr("SBPlatform_Attach",1,SWIGTYPE_p_lldb__SBPlatform); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBPlatform_Attach",2,SWIGTYPE_p_lldb__SBAttachInfo); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBPlatform_Attach",3,SWIGTYPE_p_lldb__SBDebugger); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBPlatform_Attach",4,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBPlatform_Attach",5,SWIGTYPE_p_lldb__SBError); + } + + result = (arg1)->Attach(*arg2,(lldb::SBDebugger const &)*arg3,*arg4,*arg5); + { + lldb::SBProcess * resultptr = new lldb::SBProcess(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatform_GetAllProcesses(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBError *arg2 = 0 ; + lldb::SBProcessInfoList result; + + SWIG_check_num_args("lldb::SBPlatform::GetAllProcesses",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::GetAllProcesses",1,"lldb::SBPlatform *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBPlatform::GetAllProcesses",2,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){ + SWIG_fail_ptr("SBPlatform_GetAllProcesses",1,SWIGTYPE_p_lldb__SBPlatform); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBPlatform_GetAllProcesses",2,SWIGTYPE_p_lldb__SBError); + } + + result = (arg1)->GetAllProcesses(*arg2); + { + lldb::SBProcessInfoList * resultptr = new lldb::SBProcessInfoList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcessInfoList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatform_Kill(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::pid_t arg2 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBPlatform::Kill",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::Kill",1,"lldb::SBPlatform *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBPlatform::Kill",2,"lldb::pid_t const"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){ + SWIG_fail_ptr("SBPlatform_Kill",1,SWIGTYPE_p_lldb__SBPlatform); + } + + arg2 = (lldb::pid_t const)lua_tointeger(L, 2); + result = (arg1)->Kill(arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatform_MakeDirectory__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + char *arg2 = (char *) 0 ; + uint32_t arg3 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBPlatform::MakeDirectory",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::MakeDirectory",1,"lldb::SBPlatform *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBPlatform::MakeDirectory",2,"char const *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBPlatform::MakeDirectory",3,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){ + SWIG_fail_ptr("SBPlatform_MakeDirectory",1,SWIGTYPE_p_lldb__SBPlatform); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (uint32_t)lua_tointeger(L, 3); + result = (arg1)->MakeDirectory((char const *)arg2,arg3); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatform_MakeDirectory__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBPlatform::MakeDirectory",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::MakeDirectory",1,"lldb::SBPlatform *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBPlatform::MakeDirectory",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){ + SWIG_fail_ptr("SBPlatform_MakeDirectory",1,SWIGTYPE_p_lldb__SBPlatform); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->MakeDirectory((char const *)arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatform_MakeDirectory(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBPlatform, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + return _wrap_SBPlatform_MakeDirectory__SWIG_1(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBPlatform, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + return _wrap_SBPlatform_MakeDirectory__SWIG_0(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBPlatform_GetFilePermissions(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + char *arg2 = (char *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBPlatform::GetFilePermissions",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::GetFilePermissions",1,"lldb::SBPlatform *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBPlatform::GetFilePermissions",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){ + SWIG_fail_ptr("SBPlatform_GetFilePermissions",1,SWIGTYPE_p_lldb__SBPlatform); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (uint32_t)(arg1)->GetFilePermissions((char const *)arg2); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatform_SetFilePermissions(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + char *arg2 = (char *) 0 ; + uint32_t arg3 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBPlatform::SetFilePermissions",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::SetFilePermissions",1,"lldb::SBPlatform *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBPlatform::SetFilePermissions",2,"char const *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBPlatform::SetFilePermissions",3,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){ + SWIG_fail_ptr("SBPlatform_SetFilePermissions",1,SWIGTYPE_p_lldb__SBPlatform); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (uint32_t)lua_tointeger(L, 3); + result = (arg1)->SetFilePermissions((char const *)arg2,arg3); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatform_GetUnixSignals(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBUnixSignals result; + + SWIG_check_num_args("lldb::SBPlatform::GetUnixSignals",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::GetUnixSignals",1,"lldb::SBPlatform const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){ + SWIG_fail_ptr("SBPlatform_GetUnixSignals",1,SWIGTYPE_p_lldb__SBPlatform); + } + + result = ((lldb::SBPlatform const *)arg1)->GetUnixSignals(); + { + lldb::SBUnixSignals * resultptr = new lldb::SBUnixSignals(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBUnixSignals,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatform_GetEnvironment(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBEnvironment result; + + SWIG_check_num_args("lldb::SBPlatform::GetEnvironment",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::GetEnvironment",1,"lldb::SBPlatform *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){ + SWIG_fail_ptr("SBPlatform_GetEnvironment",1,SWIGTYPE_p_lldb__SBPlatform); + } + + result = (arg1)->GetEnvironment(); + { + lldb::SBEnvironment * resultptr = new lldb::SBEnvironment(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBEnvironment,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBPlatform_SetLocateModuleCallback(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBPlatform *arg1 = (lldb::SBPlatform *) 0 ; + lldb::SBPlatformLocateModuleCallback arg2 = (lldb::SBPlatformLocateModuleCallback) 0 ; + void *arg3 = (void *) 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBPlatform::SetLocateModuleCallback",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBPlatform::SetLocateModuleCallback",1,"lldb::SBPlatform *"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("lldb::SBPlatform::SetLocateModuleCallback",2,"lldb::SBPlatformLocateModuleCallback"); + if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("lldb::SBPlatform::SetLocateModuleCallback",3,"void *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBPlatform,0))){ + SWIG_fail_ptr("SBPlatform_SetLocateModuleCallback",1,SWIGTYPE_p_lldb__SBPlatform); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_f_p_void_r_q_const__lldb__SBModuleSpec_r_lldb__SBFileSpec_r_lldb__SBFileSpec__lldb__SBError,0))){ + SWIG_fail_ptr("SBPlatform_SetLocateModuleCallback",2,SWIGTYPE_p_f_p_void_r_q_const__lldb__SBModuleSpec_r_lldb__SBFileSpec_r_lldb__SBFileSpec__lldb__SBError); + } + + arg3=(void *)SWIG_MustGetPtr(L,3,0,0,3,"SBPlatform_SetLocateModuleCallback"); + result = (arg1)->SetLocateModuleCallback(arg2,arg3); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBPlatform(void *obj) { +lldb::SBPlatform *arg1 = (lldb::SBPlatform *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBPlatform(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBPlatform); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBPlatform_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBPlatform_methods[]= { + { "IsValid", _wrap_SBPlatform_IsValid}, + { "Clear", _wrap_SBPlatform_Clear}, + { "GetWorkingDirectory", _wrap_SBPlatform_GetWorkingDirectory}, + { "SetWorkingDirectory", _wrap_SBPlatform_SetWorkingDirectory}, + { "GetName", _wrap_SBPlatform_GetName}, + { "ConnectRemote", _wrap_SBPlatform_ConnectRemote}, + { "DisconnectRemote", _wrap_SBPlatform_DisconnectRemote}, + { "IsConnected", _wrap_SBPlatform_IsConnected}, + { "GetTriple", _wrap_SBPlatform_GetTriple}, + { "GetHostname", _wrap_SBPlatform_GetHostname}, + { "GetOSBuild", _wrap_SBPlatform_GetOSBuild}, + { "GetOSDescription", _wrap_SBPlatform_GetOSDescription}, + { "GetOSMajorVersion", _wrap_SBPlatform_GetOSMajorVersion}, + { "GetOSMinorVersion", _wrap_SBPlatform_GetOSMinorVersion}, + { "GetOSUpdateVersion", _wrap_SBPlatform_GetOSUpdateVersion}, + { "SetSDKRoot", _wrap_SBPlatform_SetSDKRoot}, + { "Put", _wrap_SBPlatform_Put}, + { "Get", _wrap_SBPlatform_Get}, + { "Install", _wrap_SBPlatform_Install}, + { "Run", _wrap_SBPlatform_Run}, + { "Launch", _wrap_SBPlatform_Launch}, + { "Attach", _wrap_SBPlatform_Attach}, + { "GetAllProcesses", _wrap_SBPlatform_GetAllProcesses}, + { "Kill", _wrap_SBPlatform_Kill}, + { "MakeDirectory", _wrap_SBPlatform_MakeDirectory}, + { "GetFilePermissions", _wrap_SBPlatform_GetFilePermissions}, + { "SetFilePermissions", _wrap_SBPlatform_SetFilePermissions}, + { "GetUnixSignals", _wrap_SBPlatform_GetUnixSignals}, + { "GetEnvironment", _wrap_SBPlatform_GetEnvironment}, + { "SetLocateModuleCallback", _wrap_SBPlatform_SetLocateModuleCallback}, + {0,0} +}; +static swig_lua_method swig_SBPlatform_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBPlatform_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBPlatform_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBPlatform_Sf_SwigStatic_methods[]= { + { "GetHostPlatform", _wrap_SBPlatform_GetHostPlatform}, + {0,0} +}; +static swig_lua_class* swig_SBPlatform_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBPlatform_Sf_SwigStatic = { + "SBPlatform", + swig_SBPlatform_Sf_SwigStatic_methods, + swig_SBPlatform_Sf_SwigStatic_attributes, + swig_SBPlatform_Sf_SwigStatic_constants, + swig_SBPlatform_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBPlatform_bases[] = {0}; +static const char *swig_SBPlatform_base_names[] = {0}; +static swig_lua_class _wrap_class_SBPlatform = { "SBPlatform", "SBPlatform", &SWIGTYPE_p_lldb__SBPlatform,_proxy__wrap_new_SBPlatform, swig_delete_SBPlatform, swig_SBPlatform_methods, swig_SBPlatform_attributes, &swig_SBPlatform_Sf_SwigStatic, swig_SBPlatform_meta, swig_SBPlatform_bases, swig_SBPlatform_base_names }; + +static int _wrap_new_SBProcess__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *result = 0 ; + + SWIG_check_num_args("lldb::SBProcess::SBProcess",0,0) + result = (lldb::SBProcess *)new lldb::SBProcess(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBProcess__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = 0 ; + lldb::SBProcess *result = 0 ; + + SWIG_check_num_args("lldb::SBProcess::SBProcess",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBProcess::SBProcess",1,"lldb::SBProcess const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("new_SBProcess",1,SWIGTYPE_p_lldb__SBProcess); + } + + result = (lldb::SBProcess *)new lldb::SBProcess((lldb::SBProcess const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBProcess(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBProcess__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBProcess, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBProcess__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBProcess'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBProcess::SBProcess()\n" + " lldb::SBProcess::SBProcess(lldb::SBProcess const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBProcess_GetBroadcasterClassName(lua_State* L) { + { + int SWIG_arg = 0; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBProcess::GetBroadcasterClassName",0,0) + result = (char *)lldb::SBProcess::GetBroadcasterClassName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetPluginName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBProcess::GetPluginName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetPluginName",1,"lldb::SBProcess *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetPluginName",1,SWIGTYPE_p_lldb__SBProcess); + } + + result = (char *)(arg1)->GetPluginName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetShortPluginName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBProcess::GetShortPluginName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetShortPluginName",1,"lldb::SBProcess *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetShortPluginName",1,SWIGTYPE_p_lldb__SBProcess); + } + + result = (char *)(arg1)->GetShortPluginName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + + SWIG_check_num_args("lldb::SBProcess::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::Clear",1,"lldb::SBProcess *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_Clear",1,SWIGTYPE_p_lldb__SBProcess); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBProcess::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::IsValid",1,"lldb::SBProcess const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_IsValid",1,SWIGTYPE_p_lldb__SBProcess); + } + + result = (bool)((lldb::SBProcess const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetTarget(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBTarget result; + + SWIG_check_num_args("lldb::SBProcess::GetTarget",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetTarget",1,"lldb::SBProcess const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetTarget",1,SWIGTYPE_p_lldb__SBProcess); + } + + result = ((lldb::SBProcess const *)arg1)->GetTarget(); + { + lldb::SBTarget * resultptr = new lldb::SBTarget(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTarget,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetByteOrder(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::ByteOrder result; + + SWIG_check_num_args("lldb::SBProcess::GetByteOrder",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetByteOrder",1,"lldb::SBProcess const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetByteOrder",1,SWIGTYPE_p_lldb__SBProcess); + } + + result = (lldb::ByteOrder)((lldb::SBProcess const *)arg1)->GetByteOrder(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_PutSTDIN(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + char *arg2 = (char *) 0 ; + size_t arg3 ; + size_t result; + + SWIG_check_num_args("lldb::SBProcess::PutSTDIN",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::PutSTDIN",1,"lldb::SBProcess *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_PutSTDIN",1,SWIGTYPE_p_lldb__SBProcess); + } + + { + arg2 = (char *)luaL_checklstring(L, 2, &arg3); + } + result = (arg1)->PutSTDIN((char const *)arg2,arg3); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetSTDOUT(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + char *arg2 = (char *) 0 ; + size_t arg3 ; + size_t result; + + SWIG_check_num_args("lldb::SBProcess::GetSTDOUT",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetSTDOUT",1,"lldb::SBProcess const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetSTDOUT",1,SWIGTYPE_p_lldb__SBProcess); + } + + { + arg3 = luaL_checkinteger(L, 2); + if (arg3 <= 0) { + return luaL_error(L, "Positive integer expected"); + } + arg2 = (char *)malloc(arg3); + } + result = ((lldb::SBProcess const *)arg1)->GetSTDOUT(arg2,arg3); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + { + lua_pop(L, 1); // Blow away the previous result + if (result == 0) { + lua_pushliteral(L, ""); + } else { + lua_pushlstring(L, (const char *)arg2, result); + } + free(arg2); + // SWIG_arg was already incremented + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetSTDERR(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + char *arg2 = (char *) 0 ; + size_t arg3 ; + size_t result; + + SWIG_check_num_args("lldb::SBProcess::GetSTDERR",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetSTDERR",1,"lldb::SBProcess const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetSTDERR",1,SWIGTYPE_p_lldb__SBProcess); + } + + { + arg3 = luaL_checkinteger(L, 2); + if (arg3 <= 0) { + return luaL_error(L, "Positive integer expected"); + } + arg2 = (char *)malloc(arg3); + } + result = ((lldb::SBProcess const *)arg1)->GetSTDERR(arg2,arg3); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + { + lua_pop(L, 1); // Blow away the previous result + if (result == 0) { + lua_pushliteral(L, ""); + } else { + lua_pushlstring(L, (const char *)arg2, result); + } + free(arg2); + // SWIG_arg was already incremented + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetAsyncProfileData(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + char *arg2 = (char *) 0 ; + size_t arg3 ; + size_t result; + + SWIG_check_num_args("lldb::SBProcess::GetAsyncProfileData",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetAsyncProfileData",1,"lldb::SBProcess const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetAsyncProfileData",1,SWIGTYPE_p_lldb__SBProcess); + } + + { + arg3 = luaL_checkinteger(L, 2); + if (arg3 <= 0) { + return luaL_error(L, "Positive integer expected"); + } + arg2 = (char *)malloc(arg3); + } + result = ((lldb::SBProcess const *)arg1)->GetAsyncProfileData(arg2,arg3); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + { + lua_pop(L, 1); // Blow away the previous result + if (result == 0) { + lua_pushliteral(L, ""); + } else { + lua_pushlstring(L, (const char *)arg2, result); + } + free(arg2); + // SWIG_arg was already incremented + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_ReportEventState__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBEvent *arg2 = 0 ; + lldb::SBFile arg3 ; + lldb::SBFile *argp3 ; + + SWIG_check_num_args("lldb::SBProcess::ReportEventState",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::ReportEventState",1,"lldb::SBProcess const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBProcess::ReportEventState",2,"lldb::SBEvent const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBProcess::ReportEventState",3,"lldb::SBFile"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_ReportEventState",1,SWIGTYPE_p_lldb__SBProcess); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBProcess_ReportEventState",2,SWIGTYPE_p_lldb__SBEvent); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_lldb__SBFile,0))){ + SWIG_fail_ptr("SBProcess_ReportEventState",3,SWIGTYPE_p_lldb__SBFile); + } + arg3 = *argp3; + + ((lldb::SBProcess const *)arg1)->ReportEventState((lldb::SBEvent const &)*arg2,arg3); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_ReportEventState__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBEvent *arg2 = 0 ; + SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg3 ; + + SWIG_check_num_args("lldb::SBProcess::ReportEventState",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::ReportEventState",1,"lldb::SBProcess const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBProcess::ReportEventState",2,"lldb::SBEvent const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_ReportEventState",1,SWIGTYPE_p_lldb__SBProcess); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBProcess_ReportEventState",2,SWIGTYPE_p_lldb__SBEvent); + } + + { + luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 3, LUA_FILEHANDLE); + lldb::FileSP file_sp; + file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false); + if (!file_sp->IsValid()) + return luaL_error(L, "Invalid file"); + arg3 = file_sp; + } + ((lldb::SBProcess const *)arg1)->ReportEventState((lldb::SBEvent const &)*arg2,arg3); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_ReportEventState(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBProcess, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBEvent, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBProcess_ReportEventState__SWIG_0(L); + } + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBProcess, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBEvent, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = (lua_isuserdata(L, argv[2])) && + (luaL_testudata(L, argv[2], LUA_FILEHANDLE) != nullptr); + } + if (_v) { + return _wrap_SBProcess_ReportEventState__SWIG_1(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBProcess_AppendEventStateReport(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBEvent *arg2 = 0 ; + lldb::SBCommandReturnObject *arg3 = 0 ; + + SWIG_check_num_args("lldb::SBProcess::AppendEventStateReport",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::AppendEventStateReport",1,"lldb::SBProcess *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBProcess::AppendEventStateReport",2,"lldb::SBEvent const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBProcess::AppendEventStateReport",3,"lldb::SBCommandReturnObject &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_AppendEventStateReport",1,SWIGTYPE_p_lldb__SBProcess); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBProcess_AppendEventStateReport",2,SWIGTYPE_p_lldb__SBEvent); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBCommandReturnObject,0))){ + SWIG_fail_ptr("SBProcess_AppendEventStateReport",3,SWIGTYPE_p_lldb__SBCommandReturnObject); + } + + (arg1)->AppendEventStateReport((lldb::SBEvent const &)*arg2,*arg3); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_RemoteAttachToProcessWithID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::pid_t arg2 ; + lldb::SBError *arg3 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBProcess::RemoteAttachToProcessWithID",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::RemoteAttachToProcessWithID",1,"lldb::SBProcess *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::RemoteAttachToProcessWithID",2,"lldb::pid_t"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBProcess::RemoteAttachToProcessWithID",3,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_RemoteAttachToProcessWithID",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (lldb::pid_t)lua_tointeger(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBProcess_RemoteAttachToProcessWithID",3,SWIGTYPE_p_lldb__SBError); + } + + result = (bool)(arg1)->RemoteAttachToProcessWithID(arg2,*arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_RemoteLaunch(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + char **arg2 = (char **) 0 ; + char **arg3 = (char **) 0 ; + char *arg4 = (char *) 0 ; + char *arg5 = (char *) 0 ; + char *arg6 = (char *) 0 ; + char *arg7 = (char *) 0 ; + uint32_t arg8 ; + bool arg9 ; + lldb::SBError *arg10 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBProcess::RemoteLaunch",10,10) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::RemoteLaunch",1,"lldb::SBProcess *"); + if(!SWIG_lua_isnilstring(L,4)) SWIG_fail_arg("lldb::SBProcess::RemoteLaunch",4,"char const *"); + if(!SWIG_lua_isnilstring(L,5)) SWIG_fail_arg("lldb::SBProcess::RemoteLaunch",5,"char const *"); + if(!SWIG_lua_isnilstring(L,6)) SWIG_fail_arg("lldb::SBProcess::RemoteLaunch",6,"char const *"); + if(!SWIG_lua_isnilstring(L,7)) SWIG_fail_arg("lldb::SBProcess::RemoteLaunch",7,"char const *"); + if(!lua_isinteger(L,8)) SWIG_fail_arg("lldb::SBProcess::RemoteLaunch",8,"uint32_t"); + if(!lua_isboolean(L,9)) SWIG_fail_arg("lldb::SBProcess::RemoteLaunch",9,"bool"); + if(!lua_isuserdata(L,10)) SWIG_fail_arg("lldb::SBProcess::RemoteLaunch",10,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_RemoteLaunch",1,SWIGTYPE_p_lldb__SBProcess); + } + + { + if (lua_istable(L, 2)) { + size_t size = lua_rawlen(L, 2); + arg2 = (char **)malloc((size + 1) * sizeof(char *)); + int i = 0, j = 0; + while (i++ < size) { + lua_rawgeti(L, 2, i); + if (!lua_isstring(L, -1)) { + // if current element cannot be converted to string, raise an error + lua_pop(L, 1); + return luaL_error(L, "List should only contain strings"); + } + arg2[j++] = (char *)lua_tostring(L, -1); + lua_pop(L, 1); + } + arg2[j] = 0; + } else if (lua_isnil(L, 2)) { + // "nil" is also acceptable, equivalent as an empty table + arg2 = NULL; + } else { + return luaL_error(L, "A list of strings expected"); + } + } + { + if (lua_istable(L, 3)) { + size_t size = lua_rawlen(L, 3); + arg3 = (char **)malloc((size + 1) * sizeof(char *)); + int i = 0, j = 0; + while (i++ < size) { + lua_rawgeti(L, 3, i); + if (!lua_isstring(L, -1)) { + // if current element cannot be converted to string, raise an error + lua_pop(L, 1); + return luaL_error(L, "List should only contain strings"); + } + arg3[j++] = (char *)lua_tostring(L, -1); + lua_pop(L, 1); + } + arg3[j] = 0; + } else if (lua_isnil(L, 3)) { + // "nil" is also acceptable, equivalent as an empty table + arg3 = NULL; + } else { + return luaL_error(L, "A list of strings expected"); + } + } + arg4 = (char *)lua_tostring(L, 4); + arg5 = (char *)lua_tostring(L, 5); + arg6 = (char *)lua_tostring(L, 6); + arg7 = (char *)lua_tostring(L, 7); + arg8 = (uint32_t)lua_tointeger(L, 8); + arg9 = (lua_toboolean(L, 9)!=0); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,10,(void**)&arg10,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBProcess_RemoteLaunch",10,SWIGTYPE_p_lldb__SBError); + } + + 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); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + { + free((char *) arg2); + } + { + free((char *) arg3); + } + return SWIG_arg; + + fail: SWIGUNUSED; + { + free((char *) arg2); + } + { + free((char *) arg3); + } + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetNumThreads(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBProcess::GetNumThreads",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetNumThreads",1,"lldb::SBProcess *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetNumThreads",1,SWIGTYPE_p_lldb__SBProcess); + } + + result = (uint32_t)(arg1)->GetNumThreads(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetThreadAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + size_t arg2 ; + lldb::SBThread result; + + SWIG_check_num_args("lldb::SBProcess::GetThreadAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetThreadAtIndex",1,"lldb::SBProcess *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::GetThreadAtIndex",2,"size_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetThreadAtIndex",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (size_t)lua_tointeger(L, 2); + result = (arg1)->GetThreadAtIndex(arg2); + { + lldb::SBThread * resultptr = new lldb::SBThread(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThread,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetThreadByID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::tid_t arg2 ; + lldb::SBThread result; + + SWIG_check_num_args("lldb::SBProcess::GetThreadByID",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetThreadByID",1,"lldb::SBProcess *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::GetThreadByID",2,"lldb::tid_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetThreadByID",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (lldb::tid_t)lua_tointeger(L, 2); + result = (arg1)->GetThreadByID(arg2); + { + lldb::SBThread * resultptr = new lldb::SBThread(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThread,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetThreadByIndexID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + uint32_t arg2 ; + lldb::SBThread result; + + SWIG_check_num_args("lldb::SBProcess::GetThreadByIndexID",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetThreadByIndexID",1,"lldb::SBProcess *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::GetThreadByIndexID",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetThreadByIndexID",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetThreadByIndexID(arg2); + { + lldb::SBThread * resultptr = new lldb::SBThread(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThread,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetSelectedThread(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBThread result; + + SWIG_check_num_args("lldb::SBProcess::GetSelectedThread",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetSelectedThread",1,"lldb::SBProcess const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetSelectedThread",1,SWIGTYPE_p_lldb__SBProcess); + } + + result = ((lldb::SBProcess const *)arg1)->GetSelectedThread(); + { + lldb::SBThread * resultptr = new lldb::SBThread(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThread,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_CreateOSPluginThread(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::tid_t arg2 ; + lldb::addr_t arg3 ; + lldb::SBThread result; + + SWIG_check_num_args("lldb::SBProcess::CreateOSPluginThread",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::CreateOSPluginThread",1,"lldb::SBProcess *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::CreateOSPluginThread",2,"lldb::tid_t"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBProcess::CreateOSPluginThread",3,"lldb::addr_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_CreateOSPluginThread",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (lldb::tid_t)lua_tointeger(L, 2); + arg3 = (lldb::addr_t)lua_tointeger(L, 3); + result = (arg1)->CreateOSPluginThread(arg2,arg3); + { + lldb::SBThread * resultptr = new lldb::SBThread(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThread,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_SetSelectedThread(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBThread *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBProcess::SetSelectedThread",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::SetSelectedThread",1,"lldb::SBProcess *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBProcess::SetSelectedThread",2,"lldb::SBThread const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_SetSelectedThread",1,SWIGTYPE_p_lldb__SBProcess); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBProcess_SetSelectedThread",2,SWIGTYPE_p_lldb__SBThread); + } + + result = (bool)(arg1)->SetSelectedThread((lldb::SBThread const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_SetSelectedThreadByID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::tid_t arg2 ; + bool result; + + SWIG_check_num_args("lldb::SBProcess::SetSelectedThreadByID",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::SetSelectedThreadByID",1,"lldb::SBProcess *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::SetSelectedThreadByID",2,"lldb::tid_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_SetSelectedThreadByID",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (lldb::tid_t)lua_tointeger(L, 2); + result = (bool)(arg1)->SetSelectedThreadByID(arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_SetSelectedThreadByIndexID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + uint32_t arg2 ; + bool result; + + SWIG_check_num_args("lldb::SBProcess::SetSelectedThreadByIndexID",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::SetSelectedThreadByIndexID",1,"lldb::SBProcess *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::SetSelectedThreadByIndexID",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_SetSelectedThreadByIndexID",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (bool)(arg1)->SetSelectedThreadByIndexID(arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetNumQueues(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBProcess::GetNumQueues",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetNumQueues",1,"lldb::SBProcess *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetNumQueues",1,SWIGTYPE_p_lldb__SBProcess); + } + + result = (uint32_t)(arg1)->GetNumQueues(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetQueueAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + size_t arg2 ; + lldb::SBQueue result; + + SWIG_check_num_args("lldb::SBProcess::GetQueueAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetQueueAtIndex",1,"lldb::SBProcess *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::GetQueueAtIndex",2,"size_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetQueueAtIndex",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (size_t)lua_tointeger(L, 2); + result = (arg1)->GetQueueAtIndex(arg2); + { + lldb::SBQueue * resultptr = new lldb::SBQueue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBQueue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetState(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::StateType result; + + SWIG_check_num_args("lldb::SBProcess::GetState",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetState",1,"lldb::SBProcess *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetState",1,SWIGTYPE_p_lldb__SBProcess); + } + + result = (lldb::StateType)(arg1)->GetState(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetExitStatus(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + int result; + + SWIG_check_num_args("lldb::SBProcess::GetExitStatus",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetExitStatus",1,"lldb::SBProcess *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetExitStatus",1,SWIGTYPE_p_lldb__SBProcess); + } + + result = (int)(arg1)->GetExitStatus(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetExitDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBProcess::GetExitDescription",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetExitDescription",1,"lldb::SBProcess *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetExitDescription",1,SWIGTYPE_p_lldb__SBProcess); + } + + result = (char *)(arg1)->GetExitDescription(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetProcessID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::pid_t result; + + SWIG_check_num_args("lldb::SBProcess::GetProcessID",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetProcessID",1,"lldb::SBProcess *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetProcessID",1,SWIGTYPE_p_lldb__SBProcess); + } + + result = (lldb::pid_t)(arg1)->GetProcessID(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetUniqueID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBProcess::GetUniqueID",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetUniqueID",1,"lldb::SBProcess *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetUniqueID",1,SWIGTYPE_p_lldb__SBProcess); + } + + result = (uint32_t)(arg1)->GetUniqueID(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetAddressByteSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBProcess::GetAddressByteSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetAddressByteSize",1,"lldb::SBProcess const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetAddressByteSize",1,SWIGTYPE_p_lldb__SBProcess); + } + + result = (uint32_t)((lldb::SBProcess const *)arg1)->GetAddressByteSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_Destroy(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBProcess::Destroy",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::Destroy",1,"lldb::SBProcess *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_Destroy",1,SWIGTYPE_p_lldb__SBProcess); + } + + result = (arg1)->Destroy(); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_Continue(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBProcess::Continue",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::Continue",1,"lldb::SBProcess *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_Continue",1,SWIGTYPE_p_lldb__SBProcess); + } + + result = (arg1)->Continue(); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_Stop(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBProcess::Stop",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::Stop",1,"lldb::SBProcess *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_Stop",1,SWIGTYPE_p_lldb__SBProcess); + } + + result = (arg1)->Stop(); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_Kill(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBProcess::Kill",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::Kill",1,"lldb::SBProcess *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_Kill",1,SWIGTYPE_p_lldb__SBProcess); + } + + result = (arg1)->Kill(); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_Detach__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBProcess::Detach",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::Detach",1,"lldb::SBProcess *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_Detach",1,SWIGTYPE_p_lldb__SBProcess); + } + + result = (arg1)->Detach(); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_Detach__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + bool arg2 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBProcess::Detach",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::Detach",1,"lldb::SBProcess *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBProcess::Detach",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_Detach",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (lua_toboolean(L, 2)!=0); + result = (arg1)->Detach(arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_Detach(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBProcess, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBProcess_Detach__SWIG_0(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBProcess, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[1]); + } + if (_v) { + return _wrap_SBProcess_Detach__SWIG_1(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBProcess_Detach'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBProcess::Detach()\n" + " lldb::SBProcess::Detach(bool)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBProcess_Signal(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + int arg2 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBProcess::Signal",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::Signal",1,"lldb::SBProcess *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::Signal",2,"int"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_Signal",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (int)lua_tointeger(L, 2); + result = (arg1)->Signal(arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetUnixSignals(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBUnixSignals result; + + SWIG_check_num_args("lldb::SBProcess::GetUnixSignals",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetUnixSignals",1,"lldb::SBProcess *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetUnixSignals",1,SWIGTYPE_p_lldb__SBProcess); + } + + result = (arg1)->GetUnixSignals(); + { + lldb::SBUnixSignals * resultptr = new lldb::SBUnixSignals(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBUnixSignals,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_SendAsyncInterrupt(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + + SWIG_check_num_args("lldb::SBProcess::SendAsyncInterrupt",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::SendAsyncInterrupt",1,"lldb::SBProcess *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_SendAsyncInterrupt",1,SWIGTYPE_p_lldb__SBProcess); + } + + (arg1)->SendAsyncInterrupt(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetStopID__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + bool arg2 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBProcess::GetStopID",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetStopID",1,"lldb::SBProcess *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBProcess::GetStopID",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetStopID",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (lua_toboolean(L, 2)!=0); + result = (uint32_t)(arg1)->GetStopID(arg2); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetStopID__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBProcess::GetStopID",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetStopID",1,"lldb::SBProcess *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetStopID",1,SWIGTYPE_p_lldb__SBProcess); + } + + result = (uint32_t)(arg1)->GetStopID(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetStopID(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBProcess, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBProcess_GetStopID__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBProcess, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[1]); + } + if (_v) { + return _wrap_SBProcess_GetStopID__SWIG_0(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBProcess_GetStopID'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBProcess::GetStopID(bool)\n" + " lldb::SBProcess::GetStopID()\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBProcess_GetStopEventForStopID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + uint32_t arg2 ; + lldb::SBEvent result; + + SWIG_check_num_args("lldb::SBProcess::GetStopEventForStopID",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetStopEventForStopID",1,"lldb::SBProcess *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::GetStopEventForStopID",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetStopEventForStopID",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetStopEventForStopID(arg2); + { + lldb::SBEvent * resultptr = new lldb::SBEvent(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBEvent,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_ForceScriptedState(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::StateType arg2 ; + + SWIG_check_num_args("lldb::SBProcess::ForceScriptedState",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::ForceScriptedState",1,"lldb::SBProcess *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::ForceScriptedState",2,"lldb::StateType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_ForceScriptedState",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (lldb::StateType)lua_tointeger(L, 2); + (arg1)->ForceScriptedState(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_ReadMemory(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::addr_t arg2 ; + void *arg3 = (void *) 0 ; + size_t arg4 ; + lldb::SBError *arg5 = 0 ; + size_t result; + + SWIG_check_num_args("lldb::SBProcess::ReadMemory",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::ReadMemory",1,"lldb::SBProcess *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::ReadMemory",2,"lldb::addr_t"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBProcess::ReadMemory",4,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_ReadMemory",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (lldb::addr_t)lua_tointeger(L, 2); + { + arg4 = luaL_checkinteger(L, 3); + if (arg4 <= 0) { + return luaL_error(L, "Positive integer expected"); + } + arg3 = (char *)malloc(arg4); + } + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg5,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBProcess_ReadMemory",5,SWIGTYPE_p_lldb__SBError); + } + + result = (arg1)->ReadMemory(arg2,arg3,arg4,*arg5); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + { + lua_pop(L, 1); // Blow away the previous result + if (result == 0) { + lua_pushliteral(L, ""); + } else { + lua_pushlstring(L, (const char *)arg3, result); + } + free(arg3); + // SWIG_arg was already incremented + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_WriteMemory(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::addr_t arg2 ; + void *arg3 = (void *) 0 ; + size_t arg4 ; + lldb::SBError *arg5 = 0 ; + size_t result; + + SWIG_check_num_args("lldb::SBProcess::WriteMemory",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::WriteMemory",1,"lldb::SBProcess *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::WriteMemory",2,"lldb::addr_t"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBProcess::WriteMemory",4,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_WriteMemory",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (lldb::addr_t)lua_tointeger(L, 2); + { + arg3 = (void *)luaL_checklstring(L, 3, &arg4); + } + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg5,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBProcess_WriteMemory",5,SWIGTYPE_p_lldb__SBError); + } + + result = (arg1)->WriteMemory(arg2,(void const *)arg3,arg4,*arg5); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_ReadCStringFromMemory(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::addr_t arg2 ; + void *arg3 = (void *) 0 ; + size_t arg4 ; + lldb::SBError *arg5 = 0 ; + size_t result; + + SWIG_check_num_args("lldb::SBProcess::ReadCStringFromMemory",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::ReadCStringFromMemory",1,"lldb::SBProcess *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::ReadCStringFromMemory",2,"lldb::addr_t"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBProcess::ReadCStringFromMemory",4,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_ReadCStringFromMemory",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (lldb::addr_t)lua_tointeger(L, 2); + { + arg4 = luaL_checkinteger(L, 3); + if (arg4 <= 0) { + return luaL_error(L, "Positive integer expected"); + } + arg3 = (char *)malloc(arg4); + } + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg5,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBProcess_ReadCStringFromMemory",5,SWIGTYPE_p_lldb__SBError); + } + + result = (arg1)->ReadCStringFromMemory(arg2,arg3,arg4,*arg5); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + { + lua_pop(L, 1); // Blow away the previous result + if (result == 0) { + lua_pushliteral(L, ""); + } else { + lua_pushlstring(L, (const char *)arg3, result); + } + free(arg3); + // SWIG_arg was already incremented + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_ReadUnsignedFromMemory(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::addr_t arg2 ; + uint32_t arg3 ; + lldb::SBError *arg4 = 0 ; + uint64_t result; + + SWIG_check_num_args("lldb::SBProcess::ReadUnsignedFromMemory",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::ReadUnsignedFromMemory",1,"lldb::SBProcess *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::ReadUnsignedFromMemory",2,"lldb::addr_t"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBProcess::ReadUnsignedFromMemory",3,"uint32_t"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBProcess::ReadUnsignedFromMemory",4,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_ReadUnsignedFromMemory",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (lldb::addr_t)lua_tointeger(L, 2); + arg3 = (uint32_t)lua_tointeger(L, 3); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBProcess_ReadUnsignedFromMemory",4,SWIGTYPE_p_lldb__SBError); + } + + result = (uint64_t)(arg1)->ReadUnsignedFromMemory(arg2,arg3,*arg4); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_ReadPointerFromMemory(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::addr_t arg2 ; + lldb::SBError *arg3 = 0 ; + lldb::addr_t result; + + SWIG_check_num_args("lldb::SBProcess::ReadPointerFromMemory",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::ReadPointerFromMemory",1,"lldb::SBProcess *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::ReadPointerFromMemory",2,"lldb::addr_t"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBProcess::ReadPointerFromMemory",3,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_ReadPointerFromMemory",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (lldb::addr_t)lua_tointeger(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBProcess_ReadPointerFromMemory",3,SWIGTYPE_p_lldb__SBError); + } + + result = (lldb::addr_t)(arg1)->ReadPointerFromMemory(arg2,*arg3); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_FindRangesInMemory(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + void *arg2 = (void *) 0 ; + uint64_t arg3 ; + lldb::SBAddressRangeList *arg4 = 0 ; + uint32_t arg5 ; + uint32_t arg6 ; + lldb::SBError *arg7 = 0 ; + lldb::SBAddressRangeList result; + + SWIG_check_num_args("lldb::SBProcess::FindRangesInMemory",7,7) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::FindRangesInMemory",1,"lldb::SBProcess *"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("lldb::SBProcess::FindRangesInMemory",2,"void const *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBProcess::FindRangesInMemory",3,"uint64_t"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBProcess::FindRangesInMemory",4,"lldb::SBAddressRangeList const &"); + if(!lua_isinteger(L,5)) SWIG_fail_arg("lldb::SBProcess::FindRangesInMemory",5,"uint32_t"); + if(!lua_isinteger(L,6)) SWIG_fail_arg("lldb::SBProcess::FindRangesInMemory",6,"uint32_t"); + if(!lua_isuserdata(L,7)) SWIG_fail_arg("lldb::SBProcess::FindRangesInMemory",7,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_FindRangesInMemory",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2=(void *)SWIG_MustGetPtr(L,2,0,0,2,"SBProcess_FindRangesInMemory"); + arg3 = (uint64_t)lua_tointeger(L, 3); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBAddressRangeList,0))){ + SWIG_fail_ptr("SBProcess_FindRangesInMemory",4,SWIGTYPE_p_lldb__SBAddressRangeList); + } + + arg5 = (uint32_t)lua_tointeger(L, 5); + arg6 = (uint32_t)lua_tointeger(L, 6); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,7,(void**)&arg7,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBProcess_FindRangesInMemory",7,SWIGTYPE_p_lldb__SBError); + } + + result = (arg1)->FindRangesInMemory((void const *)arg2,arg3,(lldb::SBAddressRangeList const &)*arg4,arg5,arg6,*arg7); + { + lldb::SBAddressRangeList * resultptr = new lldb::SBAddressRangeList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddressRangeList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_FindInMemory(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + void *arg2 = (void *) 0 ; + uint64_t arg3 ; + lldb::SBAddressRange *arg4 = 0 ; + uint32_t arg5 ; + lldb::SBError *arg6 = 0 ; + lldb::addr_t result; + + SWIG_check_num_args("lldb::SBProcess::FindInMemory",6,6) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::FindInMemory",1,"lldb::SBProcess *"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("lldb::SBProcess::FindInMemory",2,"void const *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBProcess::FindInMemory",3,"uint64_t"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBProcess::FindInMemory",4,"lldb::SBAddressRange const &"); + if(!lua_isinteger(L,5)) SWIG_fail_arg("lldb::SBProcess::FindInMemory",5,"uint32_t"); + if(!lua_isuserdata(L,6)) SWIG_fail_arg("lldb::SBProcess::FindInMemory",6,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_FindInMemory",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2=(void *)SWIG_MustGetPtr(L,2,0,0,2,"SBProcess_FindInMemory"); + arg3 = (uint64_t)lua_tointeger(L, 3); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBAddressRange,0))){ + SWIG_fail_ptr("SBProcess_FindInMemory",4,SWIGTYPE_p_lldb__SBAddressRange); + } + + arg5 = (uint32_t)lua_tointeger(L, 5); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBProcess_FindInMemory",6,SWIGTYPE_p_lldb__SBError); + } + + result = (lldb::addr_t)(arg1)->FindInMemory((void const *)arg2,arg3,(lldb::SBAddressRange const &)*arg4,arg5,*arg6); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetStateFromEvent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = 0 ; + lldb::StateType result; + + SWIG_check_num_args("lldb::SBProcess::GetStateFromEvent",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBProcess::GetStateFromEvent",1,"lldb::SBEvent const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBProcess_GetStateFromEvent",1,SWIGTYPE_p_lldb__SBEvent); + } + + result = (lldb::StateType)lldb::SBProcess::GetStateFromEvent((lldb::SBEvent const &)*arg1); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetRestartedFromEvent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBProcess::GetRestartedFromEvent",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBProcess::GetRestartedFromEvent",1,"lldb::SBEvent const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBProcess_GetRestartedFromEvent",1,SWIGTYPE_p_lldb__SBEvent); + } + + result = (bool)lldb::SBProcess::GetRestartedFromEvent((lldb::SBEvent const &)*arg1); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetNumRestartedReasonsFromEvent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = 0 ; + size_t result; + + SWIG_check_num_args("lldb::SBProcess::GetNumRestartedReasonsFromEvent",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBProcess::GetNumRestartedReasonsFromEvent",1,"lldb::SBEvent const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBProcess_GetNumRestartedReasonsFromEvent",1,SWIGTYPE_p_lldb__SBEvent); + } + + result = lldb::SBProcess::GetNumRestartedReasonsFromEvent((lldb::SBEvent const &)*arg1); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetRestartedReasonAtIndexFromEvent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = 0 ; + size_t arg2 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBProcess::GetRestartedReasonAtIndexFromEvent",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBProcess::GetRestartedReasonAtIndexFromEvent",1,"lldb::SBEvent const &"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::GetRestartedReasonAtIndexFromEvent",2,"size_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBProcess_GetRestartedReasonAtIndexFromEvent",1,SWIGTYPE_p_lldb__SBEvent); + } + + arg2 = (size_t)lua_tointeger(L, 2); + result = (char *)lldb::SBProcess::GetRestartedReasonAtIndexFromEvent((lldb::SBEvent const &)*arg1,SWIG_STD_MOVE(arg2)); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetProcessFromEvent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = 0 ; + lldb::SBProcess result; + + SWIG_check_num_args("lldb::SBProcess::GetProcessFromEvent",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBProcess::GetProcessFromEvent",1,"lldb::SBEvent const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBProcess_GetProcessFromEvent",1,SWIGTYPE_p_lldb__SBEvent); + } + + result = lldb::SBProcess::GetProcessFromEvent((lldb::SBEvent const &)*arg1); + { + lldb::SBProcess * resultptr = new lldb::SBProcess(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetInterruptedFromEvent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBProcess::GetInterruptedFromEvent",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBProcess::GetInterruptedFromEvent",1,"lldb::SBEvent const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBProcess_GetInterruptedFromEvent",1,SWIGTYPE_p_lldb__SBEvent); + } + + result = (bool)lldb::SBProcess::GetInterruptedFromEvent((lldb::SBEvent const &)*arg1); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetStructuredDataFromEvent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = 0 ; + lldb::SBStructuredData result; + + SWIG_check_num_args("lldb::SBProcess::GetStructuredDataFromEvent",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBProcess::GetStructuredDataFromEvent",1,"lldb::SBEvent const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBProcess_GetStructuredDataFromEvent",1,SWIGTYPE_p_lldb__SBEvent); + } + + result = lldb::SBProcess::GetStructuredDataFromEvent((lldb::SBEvent const &)*arg1); + { + lldb::SBStructuredData * resultptr = new lldb::SBStructuredData(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBStructuredData,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_EventIsProcessEvent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBProcess::EventIsProcessEvent",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBProcess::EventIsProcessEvent",1,"lldb::SBEvent const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBProcess_EventIsProcessEvent",1,SWIGTYPE_p_lldb__SBEvent); + } + + result = (bool)lldb::SBProcess::EventIsProcessEvent((lldb::SBEvent const &)*arg1); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_EventIsStructuredDataEvent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBProcess::EventIsStructuredDataEvent",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBProcess::EventIsStructuredDataEvent",1,"lldb::SBEvent const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBProcess_EventIsStructuredDataEvent",1,SWIGTYPE_p_lldb__SBEvent); + } + + result = (bool)lldb::SBProcess::EventIsStructuredDataEvent((lldb::SBEvent const &)*arg1); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetBroadcaster(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBBroadcaster result; + + SWIG_check_num_args("lldb::SBProcess::GetBroadcaster",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetBroadcaster",1,"lldb::SBProcess const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetBroadcaster",1,SWIGTYPE_p_lldb__SBProcess); + } + + result = ((lldb::SBProcess const *)arg1)->GetBroadcaster(); + { + lldb::SBBroadcaster * resultptr = new lldb::SBBroadcaster(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBroadcaster,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetBroadcasterClass(lua_State* L) { + { + int SWIG_arg = 0; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBProcess::GetBroadcasterClass",0,0) + result = (char *)lldb::SBProcess::GetBroadcasterClass(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBProcess::GetDescription",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetDescription",1,"lldb::SBProcess *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBProcess::GetDescription",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetDescription",1,SWIGTYPE_p_lldb__SBProcess); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBProcess_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)(arg1)->GetDescription(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetExtendedCrashInformation(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBStructuredData result; + + SWIG_check_num_args("lldb::SBProcess::GetExtendedCrashInformation",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetExtendedCrashInformation",1,"lldb::SBProcess *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetExtendedCrashInformation",1,SWIGTYPE_p_lldb__SBProcess); + } + + result = (arg1)->GetExtendedCrashInformation(); + { + lldb::SBStructuredData * resultptr = new lldb::SBStructuredData(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBStructuredData,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetNumSupportedHardwareWatchpoints(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBError *arg2 = 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBProcess::GetNumSupportedHardwareWatchpoints",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetNumSupportedHardwareWatchpoints",1,"lldb::SBProcess const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBProcess::GetNumSupportedHardwareWatchpoints",2,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetNumSupportedHardwareWatchpoints",1,SWIGTYPE_p_lldb__SBProcess); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBProcess_GetNumSupportedHardwareWatchpoints",2,SWIGTYPE_p_lldb__SBError); + } + + result = (uint32_t)((lldb::SBProcess const *)arg1)->GetNumSupportedHardwareWatchpoints(*arg2); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_LoadImage__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBFileSpec *arg2 = 0 ; + lldb::SBError *arg3 = 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBProcess::LoadImage",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::LoadImage",1,"lldb::SBProcess *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBProcess::LoadImage",2,"lldb::SBFileSpec &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBProcess::LoadImage",3,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_LoadImage",1,SWIGTYPE_p_lldb__SBProcess); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBProcess_LoadImage",2,SWIGTYPE_p_lldb__SBFileSpec); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBProcess_LoadImage",3,SWIGTYPE_p_lldb__SBError); + } + + result = (uint32_t)(arg1)->LoadImage(*arg2,*arg3); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_LoadImage__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBFileSpec *arg2 = 0 ; + lldb::SBFileSpec *arg3 = 0 ; + lldb::SBError *arg4 = 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBProcess::LoadImage",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::LoadImage",1,"lldb::SBProcess *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBProcess::LoadImage",2,"lldb::SBFileSpec const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBProcess::LoadImage",3,"lldb::SBFileSpec const &"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBProcess::LoadImage",4,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_LoadImage",1,SWIGTYPE_p_lldb__SBProcess); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBProcess_LoadImage",2,SWIGTYPE_p_lldb__SBFileSpec); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBProcess_LoadImage",3,SWIGTYPE_p_lldb__SBFileSpec); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBProcess_LoadImage",4,SWIGTYPE_p_lldb__SBError); + } + + result = (uint32_t)(arg1)->LoadImage((lldb::SBFileSpec const &)*arg2,(lldb::SBFileSpec const &)*arg3,*arg4); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_LoadImage(lua_State* L) { + int argc; + int argv[5]={ + 1,2,3,4,5 + }; + + argc = lua_gettop(L); + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBProcess, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBProcess_LoadImage__SWIG_0(L); + } + } + } + } + if (argc == 4) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBProcess, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBProcess_LoadImage__SWIG_1(L); + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBProcess_LoadImageUsingPaths(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBFileSpec *arg2 = 0 ; + lldb::SBStringList *arg3 = 0 ; + lldb::SBFileSpec *arg4 = 0 ; + lldb::SBError *arg5 = 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBProcess::LoadImageUsingPaths",5,5) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::LoadImageUsingPaths",1,"lldb::SBProcess *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBProcess::LoadImageUsingPaths",2,"lldb::SBFileSpec const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBProcess::LoadImageUsingPaths",3,"lldb::SBStringList &"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBProcess::LoadImageUsingPaths",4,"lldb::SBFileSpec &"); + if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBProcess::LoadImageUsingPaths",5,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_LoadImageUsingPaths",1,SWIGTYPE_p_lldb__SBProcess); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBProcess_LoadImageUsingPaths",2,SWIGTYPE_p_lldb__SBFileSpec); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBStringList,0))){ + SWIG_fail_ptr("SBProcess_LoadImageUsingPaths",3,SWIGTYPE_p_lldb__SBStringList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBProcess_LoadImageUsingPaths",4,SWIGTYPE_p_lldb__SBFileSpec); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBProcess_LoadImageUsingPaths",5,SWIGTYPE_p_lldb__SBError); + } + + result = (uint32_t)(arg1)->LoadImageUsingPaths((lldb::SBFileSpec const &)*arg2,*arg3,*arg4,*arg5); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_UnloadImage(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + uint32_t arg2 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBProcess::UnloadImage",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::UnloadImage",1,"lldb::SBProcess *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::UnloadImage",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_UnloadImage",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->UnloadImage(arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_SendEventData(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBProcess::SendEventData",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::SendEventData",1,"lldb::SBProcess *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBProcess::SendEventData",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_SendEventData",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->SendEventData((char const *)arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetNumExtendedBacktraceTypes(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBProcess::GetNumExtendedBacktraceTypes",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetNumExtendedBacktraceTypes",1,"lldb::SBProcess *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetNumExtendedBacktraceTypes",1,SWIGTYPE_p_lldb__SBProcess); + } + + result = (uint32_t)(arg1)->GetNumExtendedBacktraceTypes(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetExtendedBacktraceTypeAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + uint32_t arg2 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBProcess::GetExtendedBacktraceTypeAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetExtendedBacktraceTypeAtIndex",1,"lldb::SBProcess *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::GetExtendedBacktraceTypeAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetExtendedBacktraceTypeAtIndex",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (char *)(arg1)->GetExtendedBacktraceTypeAtIndex(arg2); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetHistoryThreads(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::addr_t arg2 ; + lldb::SBThreadCollection result; + + SWIG_check_num_args("lldb::SBProcess::GetHistoryThreads",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetHistoryThreads",1,"lldb::SBProcess *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::GetHistoryThreads",2,"lldb::addr_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetHistoryThreads",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (lldb::addr_t)lua_tointeger(L, 2); + result = (arg1)->GetHistoryThreads(arg2); + { + lldb::SBThreadCollection * resultptr = new lldb::SBThreadCollection(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThreadCollection,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_IsInstrumentationRuntimePresent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::InstrumentationRuntimeType arg2 ; + bool result; + + SWIG_check_num_args("lldb::SBProcess::IsInstrumentationRuntimePresent",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::IsInstrumentationRuntimePresent",1,"lldb::SBProcess *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::IsInstrumentationRuntimePresent",2,"lldb::InstrumentationRuntimeType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_IsInstrumentationRuntimePresent",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (lldb::InstrumentationRuntimeType)lua_tointeger(L, 2); + result = (bool)(arg1)->IsInstrumentationRuntimePresent(arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_SaveCore__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + lldb::SaveCoreStyle arg4 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBProcess::SaveCore",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::SaveCore",1,"lldb::SBProcess *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBProcess::SaveCore",2,"char const *"); + if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBProcess::SaveCore",3,"char const *"); + if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBProcess::SaveCore",4,"lldb::SaveCoreStyle"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_SaveCore",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (char *)lua_tostring(L, 3); + arg4 = (lldb::SaveCoreStyle)lua_tointeger(L, 4); + result = (arg1)->SaveCore((char const *)arg2,(char const *)arg3,arg4); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_SaveCore__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBProcess::SaveCore",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::SaveCore",1,"lldb::SBProcess *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBProcess::SaveCore",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_SaveCore",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->SaveCore((char const *)arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_SaveCore__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBSaveCoreOptions *arg2 = 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBProcess::SaveCore",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::SaveCore",1,"lldb::SBProcess *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBProcess::SaveCore",2,"lldb::SBSaveCoreOptions &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_SaveCore",1,SWIGTYPE_p_lldb__SBProcess); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBSaveCoreOptions,0))){ + SWIG_fail_ptr("SBProcess_SaveCore",2,SWIGTYPE_p_lldb__SBSaveCoreOptions); + } + + result = (arg1)->SaveCore(*arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_SaveCore(lua_State* L) { + int argc; + int argv[5]={ + 1,2,3,4,5 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBProcess, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBSaveCoreOptions, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBProcess_SaveCore__SWIG_2(L); + } + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBProcess, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + return _wrap_SBProcess_SaveCore__SWIG_1(L); + } + } + } + if (argc == 4) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBProcess, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[2]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[3]); + } + if (_v) { + return _wrap_SBProcess_SaveCore__SWIG_0(L); + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBProcess_GetMemoryRegionInfo(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::addr_t arg2 ; + lldb::SBMemoryRegionInfo *arg3 = 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBProcess::GetMemoryRegionInfo",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetMemoryRegionInfo",1,"lldb::SBProcess *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::GetMemoryRegionInfo",2,"lldb::addr_t"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBProcess::GetMemoryRegionInfo",3,"lldb::SBMemoryRegionInfo &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetMemoryRegionInfo",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (lldb::addr_t)lua_tointeger(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBMemoryRegionInfo,0))){ + SWIG_fail_ptr("SBProcess_GetMemoryRegionInfo",3,SWIGTYPE_p_lldb__SBMemoryRegionInfo); + } + + result = (arg1)->GetMemoryRegionInfo(arg2,*arg3); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetMemoryRegions(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBMemoryRegionInfoList result; + + SWIG_check_num_args("lldb::SBProcess::GetMemoryRegions",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetMemoryRegions",1,"lldb::SBProcess *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetMemoryRegions",1,SWIGTYPE_p_lldb__SBProcess); + } + + result = (arg1)->GetMemoryRegions(); + { + lldb::SBMemoryRegionInfoList * resultptr = new lldb::SBMemoryRegionInfoList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBMemoryRegionInfoList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetProcessInfo(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBProcessInfo result; + + SWIG_check_num_args("lldb::SBProcess::GetProcessInfo",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetProcessInfo",1,"lldb::SBProcess *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetProcessInfo",1,SWIGTYPE_p_lldb__SBProcess); + } + + result = (arg1)->GetProcessInfo(); + { + lldb::SBProcessInfo * resultptr = new lldb::SBProcessInfo(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcessInfo,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetCoreFile(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBFileSpec result; + + SWIG_check_num_args("lldb::SBProcess::GetCoreFile",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetCoreFile",1,"lldb::SBProcess *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetCoreFile",1,SWIGTYPE_p_lldb__SBProcess); + } + + result = (arg1)->GetCoreFile(); + { + lldb::SBFileSpec * resultptr = new lldb::SBFileSpec(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetAddressMask__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::AddressMaskType arg2 ; + lldb::AddressMaskRange arg3 ; + lldb::addr_t result; + + SWIG_check_num_args("lldb::SBProcess::GetAddressMask",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetAddressMask",1,"lldb::SBProcess *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::GetAddressMask",2,"lldb::AddressMaskType"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBProcess::GetAddressMask",3,"lldb::AddressMaskRange"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetAddressMask",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (lldb::AddressMaskType)lua_tointeger(L, 2); + arg3 = (lldb::AddressMaskRange)lua_tointeger(L, 3); + result = (lldb::addr_t)(arg1)->GetAddressMask(arg2,arg3); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetAddressMask__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::AddressMaskType arg2 ; + lldb::addr_t result; + + SWIG_check_num_args("lldb::SBProcess::GetAddressMask",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetAddressMask",1,"lldb::SBProcess *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::GetAddressMask",2,"lldb::AddressMaskType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetAddressMask",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (lldb::AddressMaskType)lua_tointeger(L, 2); + result = (lldb::addr_t)(arg1)->GetAddressMask(arg2); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetAddressMask(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBProcess, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_SBProcess_GetAddressMask__SWIG_1(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBProcess, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + return _wrap_SBProcess_GetAddressMask__SWIG_0(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBProcess_SetAddressMask__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::AddressMaskType arg2 ; + lldb::addr_t arg3 ; + lldb::AddressMaskRange arg4 ; + + SWIG_check_num_args("lldb::SBProcess::SetAddressMask",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::SetAddressMask",1,"lldb::SBProcess *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::SetAddressMask",2,"lldb::AddressMaskType"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBProcess::SetAddressMask",3,"lldb::addr_t"); + if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBProcess::SetAddressMask",4,"lldb::AddressMaskRange"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_SetAddressMask",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (lldb::AddressMaskType)lua_tointeger(L, 2); + arg3 = (lldb::addr_t)lua_tointeger(L, 3); + arg4 = (lldb::AddressMaskRange)lua_tointeger(L, 4); + (arg1)->SetAddressMask(arg2,arg3,arg4); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_SetAddressMask__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::AddressMaskType arg2 ; + lldb::addr_t arg3 ; + + SWIG_check_num_args("lldb::SBProcess::SetAddressMask",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::SetAddressMask",1,"lldb::SBProcess *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::SetAddressMask",2,"lldb::AddressMaskType"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBProcess::SetAddressMask",3,"lldb::addr_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_SetAddressMask",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (lldb::AddressMaskType)lua_tointeger(L, 2); + arg3 = (lldb::addr_t)lua_tointeger(L, 3); + (arg1)->SetAddressMask(arg2,arg3); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_SetAddressMask(lua_State* L) { + int argc; + int argv[5]={ + 1,2,3,4,5 + }; + + argc = lua_gettop(L); + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBProcess, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + return _wrap_SBProcess_SetAddressMask__SWIG_1(L); + } + } + } + } + if (argc == 4) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBProcess, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[3]); + } + if (_v) { + return _wrap_SBProcess_SetAddressMask__SWIG_0(L); + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBProcess_SetAddressableBits__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::AddressMaskType arg2 ; + uint32_t arg3 ; + lldb::AddressMaskRange arg4 ; + + SWIG_check_num_args("lldb::SBProcess::SetAddressableBits",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::SetAddressableBits",1,"lldb::SBProcess *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::SetAddressableBits",2,"lldb::AddressMaskType"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBProcess::SetAddressableBits",3,"uint32_t"); + if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBProcess::SetAddressableBits",4,"lldb::AddressMaskRange"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_SetAddressableBits",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (lldb::AddressMaskType)lua_tointeger(L, 2); + arg3 = (uint32_t)lua_tointeger(L, 3); + arg4 = (lldb::AddressMaskRange)lua_tointeger(L, 4); + (arg1)->SetAddressableBits(arg2,arg3,arg4); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_SetAddressableBits__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::AddressMaskType arg2 ; + uint32_t arg3 ; + + SWIG_check_num_args("lldb::SBProcess::SetAddressableBits",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::SetAddressableBits",1,"lldb::SBProcess *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::SetAddressableBits",2,"lldb::AddressMaskType"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBProcess::SetAddressableBits",3,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_SetAddressableBits",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (lldb::AddressMaskType)lua_tointeger(L, 2); + arg3 = (uint32_t)lua_tointeger(L, 3); + (arg1)->SetAddressableBits(arg2,arg3); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_SetAddressableBits(lua_State* L) { + int argc; + int argv[5]={ + 1,2,3,4,5 + }; + + argc = lua_gettop(L); + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBProcess, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + return _wrap_SBProcess_SetAddressableBits__SWIG_1(L); + } + } + } + } + if (argc == 4) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBProcess, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[3]); + } + if (_v) { + return _wrap_SBProcess_SetAddressableBits__SWIG_0(L); + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBProcess_FixAddress__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::addr_t arg2 ; + lldb::AddressMaskType arg3 ; + lldb::addr_t result; + + SWIG_check_num_args("lldb::SBProcess::FixAddress",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::FixAddress",1,"lldb::SBProcess *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::FixAddress",2,"lldb::addr_t"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBProcess::FixAddress",3,"lldb::AddressMaskType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_FixAddress",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (lldb::addr_t)lua_tointeger(L, 2); + arg3 = (lldb::AddressMaskType)lua_tointeger(L, 3); + result = (lldb::addr_t)(arg1)->FixAddress(arg2,arg3); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_FixAddress__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::addr_t arg2 ; + lldb::addr_t result; + + SWIG_check_num_args("lldb::SBProcess::FixAddress",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::FixAddress",1,"lldb::SBProcess *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::FixAddress",2,"lldb::addr_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_FixAddress",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (lldb::addr_t)lua_tointeger(L, 2); + result = (lldb::addr_t)(arg1)->FixAddress(arg2); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_FixAddress(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBProcess, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_SBProcess_FixAddress__SWIG_1(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBProcess, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + return _wrap_SBProcess_FixAddress__SWIG_0(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBProcess_AllocateMemory(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + size_t arg2 ; + uint32_t arg3 ; + lldb::SBError *arg4 = 0 ; + lldb::addr_t result; + + SWIG_check_num_args("lldb::SBProcess::AllocateMemory",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::AllocateMemory",1,"lldb::SBProcess *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::AllocateMemory",2,"size_t"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBProcess::AllocateMemory",3,"uint32_t"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBProcess::AllocateMemory",4,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_AllocateMemory",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (size_t)lua_tointeger(L, 2); + arg3 = (uint32_t)lua_tointeger(L, 3); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBProcess_AllocateMemory",4,SWIGTYPE_p_lldb__SBError); + } + + result = (lldb::addr_t)(arg1)->AllocateMemory(arg2,arg3,*arg4); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_DeallocateMemory(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::addr_t arg2 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBProcess::DeallocateMemory",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::DeallocateMemory",1,"lldb::SBProcess *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcess::DeallocateMemory",2,"lldb::addr_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_DeallocateMemory",1,SWIGTYPE_p_lldb__SBProcess); + } + + arg2 = (lldb::addr_t)lua_tointeger(L, 2); + result = (arg1)->DeallocateMemory(arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetScriptedImplementation(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + SwigValueWrapper< lldb::SBScriptObject > result; + + SWIG_check_num_args("lldb::SBProcess::GetScriptedImplementation",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetScriptedImplementation",1,"lldb::SBProcess *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetScriptedImplementation",1,SWIGTYPE_p_lldb__SBProcess); + } + + result = (arg1)->GetScriptedImplementation(); + { + lldb::SBScriptObject * resultptr = new lldb::SBScriptObject(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBScriptObject,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess_GetStatus(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + lldb::SBStream *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBProcess::GetStatus",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::GetStatus",1,"lldb::SBProcess *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBProcess::GetStatus",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess_GetStatus",1,SWIGTYPE_p_lldb__SBProcess); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBProcess_GetStatus",2,SWIGTYPE_p_lldb__SBStream); + } + + (arg1)->GetStatus(*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcess___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcess *arg1 = (lldb::SBProcess *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBProcess::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcess::__repr__",1,"lldb::SBProcess *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcess,0))){ + SWIG_fail_ptr("SBProcess___tostring",1,SWIGTYPE_p_lldb__SBProcess); + } + + result = lldb_SBProcess___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBProcess(void *obj) { +lldb::SBProcess *arg1 = (lldb::SBProcess *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBProcess(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBProcess); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBProcess_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBProcess_methods[]= { + { "GetPluginName", _wrap_SBProcess_GetPluginName}, + { "GetShortPluginName", _wrap_SBProcess_GetShortPluginName}, + { "Clear", _wrap_SBProcess_Clear}, + { "IsValid", _wrap_SBProcess_IsValid}, + { "GetTarget", _wrap_SBProcess_GetTarget}, + { "GetByteOrder", _wrap_SBProcess_GetByteOrder}, + { "PutSTDIN", _wrap_SBProcess_PutSTDIN}, + { "GetSTDOUT", _wrap_SBProcess_GetSTDOUT}, + { "GetSTDERR", _wrap_SBProcess_GetSTDERR}, + { "GetAsyncProfileData", _wrap_SBProcess_GetAsyncProfileData}, + { "ReportEventState", _wrap_SBProcess_ReportEventState}, + { "AppendEventStateReport", _wrap_SBProcess_AppendEventStateReport}, + { "RemoteAttachToProcessWithID", _wrap_SBProcess_RemoteAttachToProcessWithID}, + { "RemoteLaunch", _wrap_SBProcess_RemoteLaunch}, + { "GetNumThreads", _wrap_SBProcess_GetNumThreads}, + { "GetThreadAtIndex", _wrap_SBProcess_GetThreadAtIndex}, + { "GetThreadByID", _wrap_SBProcess_GetThreadByID}, + { "GetThreadByIndexID", _wrap_SBProcess_GetThreadByIndexID}, + { "GetSelectedThread", _wrap_SBProcess_GetSelectedThread}, + { "CreateOSPluginThread", _wrap_SBProcess_CreateOSPluginThread}, + { "SetSelectedThread", _wrap_SBProcess_SetSelectedThread}, + { "SetSelectedThreadByID", _wrap_SBProcess_SetSelectedThreadByID}, + { "SetSelectedThreadByIndexID", _wrap_SBProcess_SetSelectedThreadByIndexID}, + { "GetNumQueues", _wrap_SBProcess_GetNumQueues}, + { "GetQueueAtIndex", _wrap_SBProcess_GetQueueAtIndex}, + { "GetState", _wrap_SBProcess_GetState}, + { "GetExitStatus", _wrap_SBProcess_GetExitStatus}, + { "GetExitDescription", _wrap_SBProcess_GetExitDescription}, + { "GetProcessID", _wrap_SBProcess_GetProcessID}, + { "GetUniqueID", _wrap_SBProcess_GetUniqueID}, + { "GetAddressByteSize", _wrap_SBProcess_GetAddressByteSize}, + { "Destroy", _wrap_SBProcess_Destroy}, + { "Continue", _wrap_SBProcess_Continue}, + { "Stop", _wrap_SBProcess_Stop}, + { "Kill", _wrap_SBProcess_Kill}, + { "Detach", _wrap_SBProcess_Detach}, + { "Signal", _wrap_SBProcess_Signal}, + { "GetUnixSignals", _wrap_SBProcess_GetUnixSignals}, + { "SendAsyncInterrupt", _wrap_SBProcess_SendAsyncInterrupt}, + { "GetStopID", _wrap_SBProcess_GetStopID}, + { "GetStopEventForStopID", _wrap_SBProcess_GetStopEventForStopID}, + { "ForceScriptedState", _wrap_SBProcess_ForceScriptedState}, + { "ReadMemory", _wrap_SBProcess_ReadMemory}, + { "WriteMemory", _wrap_SBProcess_WriteMemory}, + { "ReadCStringFromMemory", _wrap_SBProcess_ReadCStringFromMemory}, + { "ReadUnsignedFromMemory", _wrap_SBProcess_ReadUnsignedFromMemory}, + { "ReadPointerFromMemory", _wrap_SBProcess_ReadPointerFromMemory}, + { "FindRangesInMemory", _wrap_SBProcess_FindRangesInMemory}, + { "FindInMemory", _wrap_SBProcess_FindInMemory}, + { "GetBroadcaster", _wrap_SBProcess_GetBroadcaster}, + { "GetDescription", _wrap_SBProcess_GetDescription}, + { "GetExtendedCrashInformation", _wrap_SBProcess_GetExtendedCrashInformation}, + { "GetNumSupportedHardwareWatchpoints", _wrap_SBProcess_GetNumSupportedHardwareWatchpoints}, + { "LoadImage", _wrap_SBProcess_LoadImage}, + { "LoadImageUsingPaths", _wrap_SBProcess_LoadImageUsingPaths}, + { "UnloadImage", _wrap_SBProcess_UnloadImage}, + { "SendEventData", _wrap_SBProcess_SendEventData}, + { "GetNumExtendedBacktraceTypes", _wrap_SBProcess_GetNumExtendedBacktraceTypes}, + { "GetExtendedBacktraceTypeAtIndex", _wrap_SBProcess_GetExtendedBacktraceTypeAtIndex}, + { "GetHistoryThreads", _wrap_SBProcess_GetHistoryThreads}, + { "IsInstrumentationRuntimePresent", _wrap_SBProcess_IsInstrumentationRuntimePresent}, + { "SaveCore", _wrap_SBProcess_SaveCore}, + { "GetMemoryRegionInfo", _wrap_SBProcess_GetMemoryRegionInfo}, + { "GetMemoryRegions", _wrap_SBProcess_GetMemoryRegions}, + { "GetProcessInfo", _wrap_SBProcess_GetProcessInfo}, + { "GetCoreFile", _wrap_SBProcess_GetCoreFile}, + { "GetAddressMask", _wrap_SBProcess_GetAddressMask}, + { "SetAddressMask", _wrap_SBProcess_SetAddressMask}, + { "SetAddressableBits", _wrap_SBProcess_SetAddressableBits}, + { "FixAddress", _wrap_SBProcess_FixAddress}, + { "AllocateMemory", _wrap_SBProcess_AllocateMemory}, + { "DeallocateMemory", _wrap_SBProcess_DeallocateMemory}, + { "GetScriptedImplementation", _wrap_SBProcess_GetScriptedImplementation}, + { "GetStatus", _wrap_SBProcess_GetStatus}, + { "__tostring", _wrap_SBProcess___tostring}, + {0,0} +}; +static swig_lua_method swig_SBProcess_meta[] = { + { "__tostring", _wrap_SBProcess___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBProcess_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBProcess_Sf_SwigStatic_constants[]= { + {SWIG_LUA_CONSTTAB_INT("eBroadcastBitStateChanged", (lldb::SBProcess::eBroadcastBitStateChanged))}, + {SWIG_LUA_CONSTTAB_INT("eBroadcastBitInterrupt", (lldb::SBProcess::eBroadcastBitInterrupt))}, + {SWIG_LUA_CONSTTAB_INT("eBroadcastBitSTDOUT", (lldb::SBProcess::eBroadcastBitSTDOUT))}, + {SWIG_LUA_CONSTTAB_INT("eBroadcastBitSTDERR", (lldb::SBProcess::eBroadcastBitSTDERR))}, + {SWIG_LUA_CONSTTAB_INT("eBroadcastBitProfileData", (lldb::SBProcess::eBroadcastBitProfileData))}, + {SWIG_LUA_CONSTTAB_INT("eBroadcastBitStructuredData", (lldb::SBProcess::eBroadcastBitStructuredData))}, + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBProcess_Sf_SwigStatic_methods[]= { + { "GetBroadcasterClassName", _wrap_SBProcess_GetBroadcasterClassName}, + { "GetStateFromEvent", _wrap_SBProcess_GetStateFromEvent}, + { "GetRestartedFromEvent", _wrap_SBProcess_GetRestartedFromEvent}, + { "GetNumRestartedReasonsFromEvent", _wrap_SBProcess_GetNumRestartedReasonsFromEvent}, + { "GetRestartedReasonAtIndexFromEvent", _wrap_SBProcess_GetRestartedReasonAtIndexFromEvent}, + { "GetProcessFromEvent", _wrap_SBProcess_GetProcessFromEvent}, + { "GetInterruptedFromEvent", _wrap_SBProcess_GetInterruptedFromEvent}, + { "GetStructuredDataFromEvent", _wrap_SBProcess_GetStructuredDataFromEvent}, + { "EventIsProcessEvent", _wrap_SBProcess_EventIsProcessEvent}, + { "EventIsStructuredDataEvent", _wrap_SBProcess_EventIsStructuredDataEvent}, + { "GetBroadcasterClass", _wrap_SBProcess_GetBroadcasterClass}, + {0,0} +}; +static swig_lua_class* swig_SBProcess_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBProcess_Sf_SwigStatic = { + "SBProcess", + swig_SBProcess_Sf_SwigStatic_methods, + swig_SBProcess_Sf_SwigStatic_attributes, + swig_SBProcess_Sf_SwigStatic_constants, + swig_SBProcess_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBProcess_bases[] = {0}; +static const char *swig_SBProcess_base_names[] = {0}; +static swig_lua_class _wrap_class_SBProcess = { "SBProcess", "SBProcess", &SWIGTYPE_p_lldb__SBProcess,_proxy__wrap_new_SBProcess, swig_delete_SBProcess, swig_SBProcess_methods, swig_SBProcess_attributes, &swig_SBProcess_Sf_SwigStatic, swig_SBProcess_meta, swig_SBProcess_bases, swig_SBProcess_base_names }; + +static int _wrap_new_SBProcessInfo__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcessInfo *result = 0 ; + + SWIG_check_num_args("lldb::SBProcessInfo::SBProcessInfo",0,0) + result = (lldb::SBProcessInfo *)new lldb::SBProcessInfo(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBProcessInfo,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBProcessInfo__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcessInfo *arg1 = 0 ; + lldb::SBProcessInfo *result = 0 ; + + SWIG_check_num_args("lldb::SBProcessInfo::SBProcessInfo",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBProcessInfo::SBProcessInfo",1,"lldb::SBProcessInfo const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcessInfo,0))){ + SWIG_fail_ptr("new_SBProcessInfo",1,SWIGTYPE_p_lldb__SBProcessInfo); + } + + result = (lldb::SBProcessInfo *)new lldb::SBProcessInfo((lldb::SBProcessInfo const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBProcessInfo,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBProcessInfo(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBProcessInfo__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBProcessInfo, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBProcessInfo__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBProcessInfo'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBProcessInfo::SBProcessInfo()\n" + " lldb::SBProcessInfo::SBProcessInfo(lldb::SBProcessInfo const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBProcessInfo_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBProcessInfo::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcessInfo::IsValid",1,"lldb::SBProcessInfo const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcessInfo,0))){ + SWIG_fail_ptr("SBProcessInfo_IsValid",1,SWIGTYPE_p_lldb__SBProcessInfo); + } + + result = (bool)((lldb::SBProcessInfo const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcessInfo_GetName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBProcessInfo::GetName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcessInfo::GetName",1,"lldb::SBProcessInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcessInfo,0))){ + SWIG_fail_ptr("SBProcessInfo_GetName",1,SWIGTYPE_p_lldb__SBProcessInfo); + } + + result = (char *)(arg1)->GetName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcessInfo_GetExecutableFile(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ; + lldb::SBFileSpec result; + + SWIG_check_num_args("lldb::SBProcessInfo::GetExecutableFile",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcessInfo::GetExecutableFile",1,"lldb::SBProcessInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcessInfo,0))){ + SWIG_fail_ptr("SBProcessInfo_GetExecutableFile",1,SWIGTYPE_p_lldb__SBProcessInfo); + } + + result = (arg1)->GetExecutableFile(); + { + lldb::SBFileSpec * resultptr = new lldb::SBFileSpec(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcessInfo_GetProcessID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ; + lldb::pid_t result; + + SWIG_check_num_args("lldb::SBProcessInfo::GetProcessID",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcessInfo::GetProcessID",1,"lldb::SBProcessInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcessInfo,0))){ + SWIG_fail_ptr("SBProcessInfo_GetProcessID",1,SWIGTYPE_p_lldb__SBProcessInfo); + } + + result = (lldb::pid_t)(arg1)->GetProcessID(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcessInfo_GetUserID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBProcessInfo::GetUserID",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcessInfo::GetUserID",1,"lldb::SBProcessInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcessInfo,0))){ + SWIG_fail_ptr("SBProcessInfo_GetUserID",1,SWIGTYPE_p_lldb__SBProcessInfo); + } + + result = (uint32_t)(arg1)->GetUserID(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcessInfo_GetGroupID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBProcessInfo::GetGroupID",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcessInfo::GetGroupID",1,"lldb::SBProcessInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcessInfo,0))){ + SWIG_fail_ptr("SBProcessInfo_GetGroupID",1,SWIGTYPE_p_lldb__SBProcessInfo); + } + + result = (uint32_t)(arg1)->GetGroupID(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcessInfo_UserIDIsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBProcessInfo::UserIDIsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcessInfo::UserIDIsValid",1,"lldb::SBProcessInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcessInfo,0))){ + SWIG_fail_ptr("SBProcessInfo_UserIDIsValid",1,SWIGTYPE_p_lldb__SBProcessInfo); + } + + result = (bool)(arg1)->UserIDIsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcessInfo_GroupIDIsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBProcessInfo::GroupIDIsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcessInfo::GroupIDIsValid",1,"lldb::SBProcessInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcessInfo,0))){ + SWIG_fail_ptr("SBProcessInfo_GroupIDIsValid",1,SWIGTYPE_p_lldb__SBProcessInfo); + } + + result = (bool)(arg1)->GroupIDIsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcessInfo_GetEffectiveUserID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBProcessInfo::GetEffectiveUserID",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcessInfo::GetEffectiveUserID",1,"lldb::SBProcessInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcessInfo,0))){ + SWIG_fail_ptr("SBProcessInfo_GetEffectiveUserID",1,SWIGTYPE_p_lldb__SBProcessInfo); + } + + result = (uint32_t)(arg1)->GetEffectiveUserID(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcessInfo_GetEffectiveGroupID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBProcessInfo::GetEffectiveGroupID",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcessInfo::GetEffectiveGroupID",1,"lldb::SBProcessInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcessInfo,0))){ + SWIG_fail_ptr("SBProcessInfo_GetEffectiveGroupID",1,SWIGTYPE_p_lldb__SBProcessInfo); + } + + result = (uint32_t)(arg1)->GetEffectiveGroupID(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcessInfo_EffectiveUserIDIsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBProcessInfo::EffectiveUserIDIsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcessInfo::EffectiveUserIDIsValid",1,"lldb::SBProcessInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcessInfo,0))){ + SWIG_fail_ptr("SBProcessInfo_EffectiveUserIDIsValid",1,SWIGTYPE_p_lldb__SBProcessInfo); + } + + result = (bool)(arg1)->EffectiveUserIDIsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcessInfo_EffectiveGroupIDIsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBProcessInfo::EffectiveGroupIDIsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcessInfo::EffectiveGroupIDIsValid",1,"lldb::SBProcessInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcessInfo,0))){ + SWIG_fail_ptr("SBProcessInfo_EffectiveGroupIDIsValid",1,SWIGTYPE_p_lldb__SBProcessInfo); + } + + result = (bool)(arg1)->EffectiveGroupIDIsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcessInfo_GetParentProcessID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ; + lldb::pid_t result; + + SWIG_check_num_args("lldb::SBProcessInfo::GetParentProcessID",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcessInfo::GetParentProcessID",1,"lldb::SBProcessInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcessInfo,0))){ + SWIG_fail_ptr("SBProcessInfo_GetParentProcessID",1,SWIGTYPE_p_lldb__SBProcessInfo); + } + + result = (lldb::pid_t)(arg1)->GetParentProcessID(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcessInfo_GetTriple(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBProcessInfo::GetTriple",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcessInfo::GetTriple",1,"lldb::SBProcessInfo *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcessInfo,0))){ + SWIG_fail_ptr("SBProcessInfo_GetTriple",1,SWIGTYPE_p_lldb__SBProcessInfo); + } + + result = (char *)(arg1)->GetTriple(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBProcessInfo(void *obj) { +lldb::SBProcessInfo *arg1 = (lldb::SBProcessInfo *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBProcessInfo(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBProcessInfo); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBProcessInfo_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBProcessInfo_methods[]= { + { "IsValid", _wrap_SBProcessInfo_IsValid}, + { "GetName", _wrap_SBProcessInfo_GetName}, + { "GetExecutableFile", _wrap_SBProcessInfo_GetExecutableFile}, + { "GetProcessID", _wrap_SBProcessInfo_GetProcessID}, + { "GetUserID", _wrap_SBProcessInfo_GetUserID}, + { "GetGroupID", _wrap_SBProcessInfo_GetGroupID}, + { "UserIDIsValid", _wrap_SBProcessInfo_UserIDIsValid}, + { "GroupIDIsValid", _wrap_SBProcessInfo_GroupIDIsValid}, + { "GetEffectiveUserID", _wrap_SBProcessInfo_GetEffectiveUserID}, + { "GetEffectiveGroupID", _wrap_SBProcessInfo_GetEffectiveGroupID}, + { "EffectiveUserIDIsValid", _wrap_SBProcessInfo_EffectiveUserIDIsValid}, + { "EffectiveGroupIDIsValid", _wrap_SBProcessInfo_EffectiveGroupIDIsValid}, + { "GetParentProcessID", _wrap_SBProcessInfo_GetParentProcessID}, + { "GetTriple", _wrap_SBProcessInfo_GetTriple}, + {0,0} +}; +static swig_lua_method swig_SBProcessInfo_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBProcessInfo_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBProcessInfo_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBProcessInfo_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBProcessInfo_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBProcessInfo_Sf_SwigStatic = { + "SBProcessInfo", + swig_SBProcessInfo_Sf_SwigStatic_methods, + swig_SBProcessInfo_Sf_SwigStatic_attributes, + swig_SBProcessInfo_Sf_SwigStatic_constants, + swig_SBProcessInfo_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBProcessInfo_bases[] = {0}; +static const char *swig_SBProcessInfo_base_names[] = {0}; +static swig_lua_class _wrap_class_SBProcessInfo = { "SBProcessInfo", "SBProcessInfo", &SWIGTYPE_p_lldb__SBProcessInfo,_proxy__wrap_new_SBProcessInfo, swig_delete_SBProcessInfo, swig_SBProcessInfo_methods, swig_SBProcessInfo_attributes, &swig_SBProcessInfo_Sf_SwigStatic, swig_SBProcessInfo_meta, swig_SBProcessInfo_bases, swig_SBProcessInfo_base_names }; + +static int _wrap_new_SBProcessInfoList__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcessInfoList *result = 0 ; + + SWIG_check_num_args("lldb::SBProcessInfoList::SBProcessInfoList",0,0) + result = (lldb::SBProcessInfoList *)new lldb::SBProcessInfoList(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBProcessInfoList,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBProcessInfoList__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcessInfoList *arg1 = 0 ; + lldb::SBProcessInfoList *result = 0 ; + + SWIG_check_num_args("lldb::SBProcessInfoList::SBProcessInfoList",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBProcessInfoList::SBProcessInfoList",1,"lldb::SBProcessInfoList const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcessInfoList,0))){ + SWIG_fail_ptr("new_SBProcessInfoList",1,SWIGTYPE_p_lldb__SBProcessInfoList); + } + + result = (lldb::SBProcessInfoList *)new lldb::SBProcessInfoList((lldb::SBProcessInfoList const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBProcessInfoList,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBProcessInfoList(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBProcessInfoList__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBProcessInfoList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBProcessInfoList__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBProcessInfoList'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBProcessInfoList::SBProcessInfoList()\n" + " lldb::SBProcessInfoList::SBProcessInfoList(lldb::SBProcessInfoList const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBProcessInfoList_GetSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcessInfoList *arg1 = (lldb::SBProcessInfoList *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBProcessInfoList::GetSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcessInfoList::GetSize",1,"lldb::SBProcessInfoList const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcessInfoList,0))){ + SWIG_fail_ptr("SBProcessInfoList_GetSize",1,SWIGTYPE_p_lldb__SBProcessInfoList); + } + + result = (uint32_t)((lldb::SBProcessInfoList const *)arg1)->GetSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcessInfoList_GetProcessInfoAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcessInfoList *arg1 = (lldb::SBProcessInfoList *) 0 ; + uint32_t arg2 ; + lldb::SBProcessInfo *arg3 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBProcessInfoList::GetProcessInfoAtIndex",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcessInfoList::GetProcessInfoAtIndex",1,"lldb::SBProcessInfoList *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBProcessInfoList::GetProcessInfoAtIndex",2,"uint32_t"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBProcessInfoList::GetProcessInfoAtIndex",3,"lldb::SBProcessInfo &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcessInfoList,0))){ + SWIG_fail_ptr("SBProcessInfoList_GetProcessInfoAtIndex",1,SWIGTYPE_p_lldb__SBProcessInfoList); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBProcessInfo,0))){ + SWIG_fail_ptr("SBProcessInfoList_GetProcessInfoAtIndex",3,SWIGTYPE_p_lldb__SBProcessInfo); + } + + result = (bool)(arg1)->GetProcessInfoAtIndex(arg2,*arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBProcessInfoList_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBProcessInfoList *arg1 = (lldb::SBProcessInfoList *) 0 ; + + SWIG_check_num_args("lldb::SBProcessInfoList::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBProcessInfoList::Clear",1,"lldb::SBProcessInfoList *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBProcessInfoList,0))){ + SWIG_fail_ptr("SBProcessInfoList_Clear",1,SWIGTYPE_p_lldb__SBProcessInfoList); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBProcessInfoList(void *obj) { +lldb::SBProcessInfoList *arg1 = (lldb::SBProcessInfoList *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBProcessInfoList(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBProcessInfoList); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBProcessInfoList_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBProcessInfoList_methods[]= { + { "GetSize", _wrap_SBProcessInfoList_GetSize}, + { "GetProcessInfoAtIndex", _wrap_SBProcessInfoList_GetProcessInfoAtIndex}, + { "Clear", _wrap_SBProcessInfoList_Clear}, + {0,0} +}; +static swig_lua_method swig_SBProcessInfoList_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBProcessInfoList_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBProcessInfoList_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBProcessInfoList_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBProcessInfoList_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBProcessInfoList_Sf_SwigStatic = { + "SBProcessInfoList", + swig_SBProcessInfoList_Sf_SwigStatic_methods, + swig_SBProcessInfoList_Sf_SwigStatic_attributes, + swig_SBProcessInfoList_Sf_SwigStatic_constants, + swig_SBProcessInfoList_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBProcessInfoList_bases[] = {0}; +static const char *swig_SBProcessInfoList_base_names[] = {0}; +static swig_lua_class _wrap_class_SBProcessInfoList = { "SBProcessInfoList", "SBProcessInfoList", &SWIGTYPE_p_lldb__SBProcessInfoList,_proxy__wrap_new_SBProcessInfoList, swig_delete_SBProcessInfoList, swig_SBProcessInfoList_methods, swig_SBProcessInfoList_attributes, &swig_SBProcessInfoList_Sf_SwigStatic, swig_SBProcessInfoList_meta, swig_SBProcessInfoList_bases, swig_SBProcessInfoList_base_names }; + +static int _wrap_new_SBQueue__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBQueue *result = 0 ; + + SWIG_check_num_args("lldb::SBQueue::SBQueue",0,0) + result = (lldb::SBQueue *)new lldb::SBQueue(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBQueue,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBQueue__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBQueue *arg1 = 0 ; + lldb::SBQueue *result = 0 ; + + SWIG_check_num_args("lldb::SBQueue::SBQueue",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBQueue::SBQueue",1,"lldb::SBQueue const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueue,0))){ + SWIG_fail_ptr("new_SBQueue",1,SWIGTYPE_p_lldb__SBQueue); + } + + result = (lldb::SBQueue *)new lldb::SBQueue((lldb::SBQueue const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBQueue,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBQueue(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBQueue__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBQueue, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBQueue__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBQueue'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBQueue::SBQueue()\n" + " lldb::SBQueue::SBQueue(lldb::SBQueue const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBQueue_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBQueue::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueue::IsValid",1,"lldb::SBQueue const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueue,0))){ + SWIG_fail_ptr("SBQueue_IsValid",1,SWIGTYPE_p_lldb__SBQueue); + } + + result = (bool)((lldb::SBQueue const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBQueue_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ; + + SWIG_check_num_args("lldb::SBQueue::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueue::Clear",1,"lldb::SBQueue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueue,0))){ + SWIG_fail_ptr("SBQueue_Clear",1,SWIGTYPE_p_lldb__SBQueue); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBQueue_GetProcess(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ; + lldb::SBProcess result; + + SWIG_check_num_args("lldb::SBQueue::GetProcess",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueue::GetProcess",1,"lldb::SBQueue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueue,0))){ + SWIG_fail_ptr("SBQueue_GetProcess",1,SWIGTYPE_p_lldb__SBQueue); + } + + result = (arg1)->GetProcess(); + { + lldb::SBProcess * resultptr = new lldb::SBProcess(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBQueue_GetQueueID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ; + lldb::queue_id_t result; + + SWIG_check_num_args("lldb::SBQueue::GetQueueID",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueue::GetQueueID",1,"lldb::SBQueue const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueue,0))){ + SWIG_fail_ptr("SBQueue_GetQueueID",1,SWIGTYPE_p_lldb__SBQueue); + } + + result = (lldb::queue_id_t)((lldb::SBQueue const *)arg1)->GetQueueID(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBQueue_GetName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBQueue::GetName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueue::GetName",1,"lldb::SBQueue const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueue,0))){ + SWIG_fail_ptr("SBQueue_GetName",1,SWIGTYPE_p_lldb__SBQueue); + } + + result = (char *)((lldb::SBQueue const *)arg1)->GetName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBQueue_GetIndexID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBQueue::GetIndexID",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueue::GetIndexID",1,"lldb::SBQueue const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueue,0))){ + SWIG_fail_ptr("SBQueue_GetIndexID",1,SWIGTYPE_p_lldb__SBQueue); + } + + result = (uint32_t)((lldb::SBQueue const *)arg1)->GetIndexID(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBQueue_GetNumThreads(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBQueue::GetNumThreads",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueue::GetNumThreads",1,"lldb::SBQueue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueue,0))){ + SWIG_fail_ptr("SBQueue_GetNumThreads",1,SWIGTYPE_p_lldb__SBQueue); + } + + result = (uint32_t)(arg1)->GetNumThreads(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBQueue_GetThreadAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ; + uint32_t arg2 ; + lldb::SBThread result; + + SWIG_check_num_args("lldb::SBQueue::GetThreadAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueue::GetThreadAtIndex",1,"lldb::SBQueue *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBQueue::GetThreadAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueue,0))){ + SWIG_fail_ptr("SBQueue_GetThreadAtIndex",1,SWIGTYPE_p_lldb__SBQueue); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetThreadAtIndex(arg2); + { + lldb::SBThread * resultptr = new lldb::SBThread(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThread,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBQueue_GetNumPendingItems(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBQueue::GetNumPendingItems",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueue::GetNumPendingItems",1,"lldb::SBQueue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueue,0))){ + SWIG_fail_ptr("SBQueue_GetNumPendingItems",1,SWIGTYPE_p_lldb__SBQueue); + } + + result = (uint32_t)(arg1)->GetNumPendingItems(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBQueue_GetPendingItemAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ; + uint32_t arg2 ; + lldb::SBQueueItem result; + + SWIG_check_num_args("lldb::SBQueue::GetPendingItemAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueue::GetPendingItemAtIndex",1,"lldb::SBQueue *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBQueue::GetPendingItemAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueue,0))){ + SWIG_fail_ptr("SBQueue_GetPendingItemAtIndex",1,SWIGTYPE_p_lldb__SBQueue); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetPendingItemAtIndex(arg2); + { + lldb::SBQueueItem * resultptr = new lldb::SBQueueItem(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBQueueItem,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBQueue_GetNumRunningItems(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBQueue::GetNumRunningItems",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueue::GetNumRunningItems",1,"lldb::SBQueue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueue,0))){ + SWIG_fail_ptr("SBQueue_GetNumRunningItems",1,SWIGTYPE_p_lldb__SBQueue); + } + + result = (uint32_t)(arg1)->GetNumRunningItems(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBQueue_GetKind(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBQueue *arg1 = (lldb::SBQueue *) 0 ; + lldb::QueueKind result; + + SWIG_check_num_args("lldb::SBQueue::GetKind",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueue::GetKind",1,"lldb::SBQueue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueue,0))){ + SWIG_fail_ptr("SBQueue_GetKind",1,SWIGTYPE_p_lldb__SBQueue); + } + + result = (lldb::QueueKind)(arg1)->GetKind(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBQueue(void *obj) { +lldb::SBQueue *arg1 = (lldb::SBQueue *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBQueue(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBQueue); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBQueue_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBQueue_methods[]= { + { "IsValid", _wrap_SBQueue_IsValid}, + { "Clear", _wrap_SBQueue_Clear}, + { "GetProcess", _wrap_SBQueue_GetProcess}, + { "GetQueueID", _wrap_SBQueue_GetQueueID}, + { "GetName", _wrap_SBQueue_GetName}, + { "GetIndexID", _wrap_SBQueue_GetIndexID}, + { "GetNumThreads", _wrap_SBQueue_GetNumThreads}, + { "GetThreadAtIndex", _wrap_SBQueue_GetThreadAtIndex}, + { "GetNumPendingItems", _wrap_SBQueue_GetNumPendingItems}, + { "GetPendingItemAtIndex", _wrap_SBQueue_GetPendingItemAtIndex}, + { "GetNumRunningItems", _wrap_SBQueue_GetNumRunningItems}, + { "GetKind", _wrap_SBQueue_GetKind}, + {0,0} +}; +static swig_lua_method swig_SBQueue_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBQueue_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBQueue_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBQueue_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBQueue_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBQueue_Sf_SwigStatic = { + "SBQueue", + swig_SBQueue_Sf_SwigStatic_methods, + swig_SBQueue_Sf_SwigStatic_attributes, + swig_SBQueue_Sf_SwigStatic_constants, + swig_SBQueue_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBQueue_bases[] = {0}; +static const char *swig_SBQueue_base_names[] = {0}; +static swig_lua_class _wrap_class_SBQueue = { "SBQueue", "SBQueue", &SWIGTYPE_p_lldb__SBQueue,_proxy__wrap_new_SBQueue, swig_delete_SBQueue, swig_SBQueue_methods, swig_SBQueue_attributes, &swig_SBQueue_Sf_SwigStatic, swig_SBQueue_meta, swig_SBQueue_bases, swig_SBQueue_base_names }; + +static int _wrap_new_SBQueueItem(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBQueueItem *result = 0 ; + + SWIG_check_num_args("lldb::SBQueueItem::SBQueueItem",0,0) + result = (lldb::SBQueueItem *)new lldb::SBQueueItem(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBQueueItem,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBQueueItem_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBQueueItem *arg1 = (lldb::SBQueueItem *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBQueueItem::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueueItem::IsValid",1,"lldb::SBQueueItem const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueueItem,0))){ + SWIG_fail_ptr("SBQueueItem_IsValid",1,SWIGTYPE_p_lldb__SBQueueItem); + } + + result = (bool)((lldb::SBQueueItem const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBQueueItem_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBQueueItem *arg1 = (lldb::SBQueueItem *) 0 ; + + SWIG_check_num_args("lldb::SBQueueItem::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueueItem::Clear",1,"lldb::SBQueueItem *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueueItem,0))){ + SWIG_fail_ptr("SBQueueItem_Clear",1,SWIGTYPE_p_lldb__SBQueueItem); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBQueueItem_GetKind(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBQueueItem *arg1 = (lldb::SBQueueItem *) 0 ; + lldb::QueueItemKind result; + + SWIG_check_num_args("lldb::SBQueueItem::GetKind",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueueItem::GetKind",1,"lldb::SBQueueItem const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueueItem,0))){ + SWIG_fail_ptr("SBQueueItem_GetKind",1,SWIGTYPE_p_lldb__SBQueueItem); + } + + result = (lldb::QueueItemKind)((lldb::SBQueueItem const *)arg1)->GetKind(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBQueueItem_SetKind(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBQueueItem *arg1 = (lldb::SBQueueItem *) 0 ; + lldb::QueueItemKind arg2 ; + + SWIG_check_num_args("lldb::SBQueueItem::SetKind",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueueItem::SetKind",1,"lldb::SBQueueItem *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBQueueItem::SetKind",2,"lldb::QueueItemKind"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueueItem,0))){ + SWIG_fail_ptr("SBQueueItem_SetKind",1,SWIGTYPE_p_lldb__SBQueueItem); + } + + arg2 = (lldb::QueueItemKind)lua_tointeger(L, 2); + (arg1)->SetKind(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBQueueItem_GetAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBQueueItem *arg1 = (lldb::SBQueueItem *) 0 ; + lldb::SBAddress result; + + SWIG_check_num_args("lldb::SBQueueItem::GetAddress",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueueItem::GetAddress",1,"lldb::SBQueueItem const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueueItem,0))){ + SWIG_fail_ptr("SBQueueItem_GetAddress",1,SWIGTYPE_p_lldb__SBQueueItem); + } + + result = ((lldb::SBQueueItem const *)arg1)->GetAddress(); + { + lldb::SBAddress * resultptr = new lldb::SBAddress(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBQueueItem_SetAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBQueueItem *arg1 = (lldb::SBQueueItem *) 0 ; + lldb::SBAddress arg2 ; + lldb::SBAddress *argp2 ; + + SWIG_check_num_args("lldb::SBQueueItem::SetAddress",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueueItem::SetAddress",1,"lldb::SBQueueItem *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBQueueItem::SetAddress",2,"lldb::SBAddress"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueueItem,0))){ + SWIG_fail_ptr("SBQueueItem_SetAddress",1,SWIGTYPE_p_lldb__SBQueueItem); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBQueueItem_SetAddress",2,SWIGTYPE_p_lldb__SBAddress); + } + arg2 = *argp2; + + (arg1)->SetAddress(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBQueueItem_GetExtendedBacktraceThread(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBQueueItem *arg1 = (lldb::SBQueueItem *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBThread result; + + SWIG_check_num_args("lldb::SBQueueItem::GetExtendedBacktraceThread",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBQueueItem::GetExtendedBacktraceThread",1,"lldb::SBQueueItem *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBQueueItem::GetExtendedBacktraceThread",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBQueueItem,0))){ + SWIG_fail_ptr("SBQueueItem_GetExtendedBacktraceThread",1,SWIGTYPE_p_lldb__SBQueueItem); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->GetExtendedBacktraceThread((char const *)arg2); + { + lldb::SBThread * resultptr = new lldb::SBThread(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThread,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBQueueItem(void *obj) { +lldb::SBQueueItem *arg1 = (lldb::SBQueueItem *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBQueueItem(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBQueueItem); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBQueueItem_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBQueueItem_methods[]= { + { "IsValid", _wrap_SBQueueItem_IsValid}, + { "Clear", _wrap_SBQueueItem_Clear}, + { "GetKind", _wrap_SBQueueItem_GetKind}, + { "SetKind", _wrap_SBQueueItem_SetKind}, + { "GetAddress", _wrap_SBQueueItem_GetAddress}, + { "SetAddress", _wrap_SBQueueItem_SetAddress}, + { "GetExtendedBacktraceThread", _wrap_SBQueueItem_GetExtendedBacktraceThread}, + {0,0} +}; +static swig_lua_method swig_SBQueueItem_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBQueueItem_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBQueueItem_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBQueueItem_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBQueueItem_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBQueueItem_Sf_SwigStatic = { + "SBQueueItem", + swig_SBQueueItem_Sf_SwigStatic_methods, + swig_SBQueueItem_Sf_SwigStatic_attributes, + swig_SBQueueItem_Sf_SwigStatic_constants, + swig_SBQueueItem_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBQueueItem_bases[] = {0}; +static const char *swig_SBQueueItem_base_names[] = {0}; +static swig_lua_class _wrap_class_SBQueueItem = { "SBQueueItem", "SBQueueItem", &SWIGTYPE_p_lldb__SBQueueItem,_proxy__wrap_new_SBQueueItem, swig_delete_SBQueueItem, swig_SBQueueItem_methods, swig_SBQueueItem_attributes, &swig_SBQueueItem_Sf_SwigStatic, swig_SBQueueItem_meta, swig_SBQueueItem_bases, swig_SBQueueItem_base_names }; + +static int _wrap_SBReproducer_Capture(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBReproducer::Capture",1,1) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBReproducer::Capture",1,"char const *"); + arg1 = (char *)lua_tostring(L, 1); + result = (char *)lldb::SBReproducer::Capture((char const *)arg1); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBReproducer_PassiveReplay(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBReproducer::PassiveReplay",1,1) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBReproducer::PassiveReplay",1,"char const *"); + arg1 = (char *)lua_tostring(L, 1); + result = (char *)lldb::SBReproducer::PassiveReplay((char const *)arg1); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBReproducer_SetAutoGenerate(lua_State* L) { + { + int SWIG_arg = 0; + bool arg1 ; + bool result; + + SWIG_check_num_args("lldb::SBReproducer::SetAutoGenerate",1,1) + if(!lua_isboolean(L,1)) SWIG_fail_arg("lldb::SBReproducer::SetAutoGenerate",1,"bool"); + arg1 = (lua_toboolean(L, 1)!=0); + result = (bool)lldb::SBReproducer::SetAutoGenerate(arg1); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBReproducer_SetWorkingDirectory(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBReproducer::SetWorkingDirectory",1,1) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBReproducer::SetWorkingDirectory",1,"char const *"); + arg1 = (char *)lua_tostring(L, 1); + lldb::SBReproducer::SetWorkingDirectory((char const *)arg1); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBReproducer(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBReproducer *result = 0 ; + + SWIG_check_num_args("lldb::SBReproducer::SBReproducer",0,0) + result = (lldb::SBReproducer *)new lldb::SBReproducer(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBReproducer,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBReproducer(void *obj) { +lldb::SBReproducer *arg1 = (lldb::SBReproducer *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBReproducer(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBReproducer); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBReproducer_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBReproducer_methods[]= { + {0,0} +}; +static swig_lua_method swig_SBReproducer_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBReproducer_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBReproducer_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBReproducer_Sf_SwigStatic_methods[]= { + { "Capture", _wrap_SBReproducer_Capture}, + { "PassiveReplay", _wrap_SBReproducer_PassiveReplay}, + { "SetAutoGenerate", _wrap_SBReproducer_SetAutoGenerate}, + { "SetWorkingDirectory", _wrap_SBReproducer_SetWorkingDirectory}, + {0,0} +}; +static swig_lua_class* swig_SBReproducer_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBReproducer_Sf_SwigStatic = { + "SBReproducer", + swig_SBReproducer_Sf_SwigStatic_methods, + swig_SBReproducer_Sf_SwigStatic_attributes, + swig_SBReproducer_Sf_SwigStatic_constants, + swig_SBReproducer_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBReproducer_bases[] = {0}; +static const char *swig_SBReproducer_base_names[] = {0}; +static swig_lua_class _wrap_class_SBReproducer = { "SBReproducer", "SBReproducer", &SWIGTYPE_p_lldb__SBReproducer,_proxy__wrap_new_SBReproducer, swig_delete_SBReproducer, swig_SBReproducer_methods, swig_SBReproducer_attributes, &swig_SBReproducer_Sf_SwigStatic, swig_SBReproducer_meta, swig_SBReproducer_bases, swig_SBReproducer_base_names }; + +static int _wrap_new_SBScriptObject__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::ScriptObjectPtr arg1 = (lldb::ScriptObjectPtr) (lldb::ScriptObjectPtr)0 ; + lldb::ScriptLanguage arg2 ; + lldb::SBScriptObject *result = 0 ; + + SWIG_check_num_args("lldb::SBScriptObject::SBScriptObject",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBScriptObject::SBScriptObject",1,"lldb::ScriptObjectPtr const"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBScriptObject::SBScriptObject",2,"lldb::ScriptLanguage"); + arg1=(lldb::ScriptObjectPtr)SWIG_MustGetPtr(L,1,0,0,1,"new_SBScriptObject"); + arg2 = (lldb::ScriptLanguage)lua_tointeger(L, 2); + result = (lldb::SBScriptObject *)new lldb::SBScriptObject(arg1,arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBScriptObject,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBScriptObject__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBScriptObject *arg1 = 0 ; + lldb::SBScriptObject *result = 0 ; + + SWIG_check_num_args("lldb::SBScriptObject::SBScriptObject",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBScriptObject::SBScriptObject",1,"lldb::SBScriptObject const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBScriptObject,0))){ + SWIG_fail_ptr("new_SBScriptObject",1,SWIGTYPE_p_lldb__SBScriptObject); + } + + result = (lldb::SBScriptObject *)new lldb::SBScriptObject((lldb::SBScriptObject const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBScriptObject,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBScriptObject(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBScriptObject, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBScriptObject__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, 0, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_new_SBScriptObject__SWIG_0(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBScriptObject_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBScriptObject *arg1 = (lldb::SBScriptObject *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBScriptObject::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBScriptObject::IsValid",1,"lldb::SBScriptObject const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBScriptObject,0))){ + SWIG_fail_ptr("SBScriptObject_IsValid",1,SWIGTYPE_p_lldb__SBScriptObject); + } + + result = (bool)((lldb::SBScriptObject const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBScriptObject_GetPointer(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBScriptObject *arg1 = (lldb::SBScriptObject *) 0 ; + lldb::ScriptObjectPtr result; + + SWIG_check_num_args("lldb::SBScriptObject::GetPointer",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBScriptObject::GetPointer",1,"lldb::SBScriptObject const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBScriptObject,0))){ + SWIG_fail_ptr("SBScriptObject_GetPointer",1,SWIGTYPE_p_lldb__SBScriptObject); + } + + result = (lldb::ScriptObjectPtr)((lldb::SBScriptObject const *)arg1)->GetPointer(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_void,0); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBScriptObject_GetLanguage(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBScriptObject *arg1 = (lldb::SBScriptObject *) 0 ; + lldb::ScriptLanguage result; + + SWIG_check_num_args("lldb::SBScriptObject::GetLanguage",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBScriptObject::GetLanguage",1,"lldb::SBScriptObject const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBScriptObject,0))){ + SWIG_fail_ptr("SBScriptObject_GetLanguage",1,SWIGTYPE_p_lldb__SBScriptObject); + } + + result = (lldb::ScriptLanguage)((lldb::SBScriptObject const *)arg1)->GetLanguage(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBScriptObject(void *obj) { +lldb::SBScriptObject *arg1 = (lldb::SBScriptObject *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBScriptObject(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBScriptObject); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBScriptObject_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBScriptObject_methods[]= { + { "IsValid", _wrap_SBScriptObject_IsValid}, + { "GetPointer", _wrap_SBScriptObject_GetPointer}, + { "GetLanguage", _wrap_SBScriptObject_GetLanguage}, + {0,0} +}; +static swig_lua_method swig_SBScriptObject_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBScriptObject_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBScriptObject_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBScriptObject_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBScriptObject_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBScriptObject_Sf_SwigStatic = { + "SBScriptObject", + swig_SBScriptObject_Sf_SwigStatic_methods, + swig_SBScriptObject_Sf_SwigStatic_attributes, + swig_SBScriptObject_Sf_SwigStatic_constants, + swig_SBScriptObject_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBScriptObject_bases[] = {0}; +static const char *swig_SBScriptObject_base_names[] = {0}; +static swig_lua_class _wrap_class_SBScriptObject = { "SBScriptObject", "SBScriptObject", &SWIGTYPE_p_lldb__SBScriptObject,_proxy__wrap_new_SBScriptObject, swig_delete_SBScriptObject, swig_SBScriptObject_methods, swig_SBScriptObject_attributes, &swig_SBScriptObject_Sf_SwigStatic, swig_SBScriptObject_meta, swig_SBScriptObject_bases, swig_SBScriptObject_base_names }; + +static int _wrap_new_SBSection__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSection *result = 0 ; + + SWIG_check_num_args("lldb::SBSection::SBSection",0,0) + result = (lldb::SBSection *)new lldb::SBSection(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBSection,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBSection__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSection *arg1 = 0 ; + lldb::SBSection *result = 0 ; + + SWIG_check_num_args("lldb::SBSection::SBSection",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBSection::SBSection",1,"lldb::SBSection const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){ + SWIG_fail_ptr("new_SBSection",1,SWIGTYPE_p_lldb__SBSection); + } + + result = (lldb::SBSection *)new lldb::SBSection((lldb::SBSection const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBSection,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBSection(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBSection__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBSection, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBSection__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBSection'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBSection::SBSection()\n" + " lldb::SBSection::SBSection(lldb::SBSection const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBSection_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBSection::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::IsValid",1,"lldb::SBSection const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){ + SWIG_fail_ptr("SBSection_IsValid",1,SWIGTYPE_p_lldb__SBSection); + } + + result = (bool)((lldb::SBSection const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSection_GetName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBSection::GetName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::GetName",1,"lldb::SBSection *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){ + SWIG_fail_ptr("SBSection_GetName",1,SWIGTYPE_p_lldb__SBSection); + } + + result = (char *)(arg1)->GetName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSection_GetParent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + lldb::SBSection result; + + SWIG_check_num_args("lldb::SBSection::GetParent",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::GetParent",1,"lldb::SBSection *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){ + SWIG_fail_ptr("SBSection_GetParent",1,SWIGTYPE_p_lldb__SBSection); + } + + result = (arg1)->GetParent(); + { + lldb::SBSection * resultptr = new lldb::SBSection(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSection,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSection_FindSubSection(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBSection result; + + SWIG_check_num_args("lldb::SBSection::FindSubSection",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::FindSubSection",1,"lldb::SBSection *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBSection::FindSubSection",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){ + SWIG_fail_ptr("SBSection_FindSubSection",1,SWIGTYPE_p_lldb__SBSection); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->FindSubSection((char const *)arg2); + { + lldb::SBSection * resultptr = new lldb::SBSection(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSection,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSection_GetNumSubSections(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + size_t result; + + SWIG_check_num_args("lldb::SBSection::GetNumSubSections",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::GetNumSubSections",1,"lldb::SBSection *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){ + SWIG_fail_ptr("SBSection_GetNumSubSections",1,SWIGTYPE_p_lldb__SBSection); + } + + result = (arg1)->GetNumSubSections(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSection_GetSubSectionAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + size_t arg2 ; + lldb::SBSection result; + + SWIG_check_num_args("lldb::SBSection::GetSubSectionAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::GetSubSectionAtIndex",1,"lldb::SBSection *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBSection::GetSubSectionAtIndex",2,"size_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){ + SWIG_fail_ptr("SBSection_GetSubSectionAtIndex",1,SWIGTYPE_p_lldb__SBSection); + } + + arg2 = (size_t)lua_tointeger(L, 2); + result = (arg1)->GetSubSectionAtIndex(arg2); + { + lldb::SBSection * resultptr = new lldb::SBSection(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSection,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSection_GetFileAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + lldb::addr_t result; + + SWIG_check_num_args("lldb::SBSection::GetFileAddress",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::GetFileAddress",1,"lldb::SBSection *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){ + SWIG_fail_ptr("SBSection_GetFileAddress",1,SWIGTYPE_p_lldb__SBSection); + } + + result = (lldb::addr_t)(arg1)->GetFileAddress(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSection_GetLoadAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + lldb::SBTarget *arg2 = 0 ; + lldb::addr_t result; + + SWIG_check_num_args("lldb::SBSection::GetLoadAddress",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::GetLoadAddress",1,"lldb::SBSection *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSection::GetLoadAddress",2,"lldb::SBTarget &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){ + SWIG_fail_ptr("SBSection_GetLoadAddress",1,SWIGTYPE_p_lldb__SBSection); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBSection_GetLoadAddress",2,SWIGTYPE_p_lldb__SBTarget); + } + + result = (lldb::addr_t)(arg1)->GetLoadAddress(*arg2); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSection_GetByteSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + lldb::addr_t result; + + SWIG_check_num_args("lldb::SBSection::GetByteSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::GetByteSize",1,"lldb::SBSection *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){ + SWIG_fail_ptr("SBSection_GetByteSize",1,SWIGTYPE_p_lldb__SBSection); + } + + result = (lldb::addr_t)(arg1)->GetByteSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSection_GetFileOffset(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + uint64_t result; + + SWIG_check_num_args("lldb::SBSection::GetFileOffset",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::GetFileOffset",1,"lldb::SBSection *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){ + SWIG_fail_ptr("SBSection_GetFileOffset",1,SWIGTYPE_p_lldb__SBSection); + } + + result = (uint64_t)(arg1)->GetFileOffset(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSection_GetFileByteSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + uint64_t result; + + SWIG_check_num_args("lldb::SBSection::GetFileByteSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::GetFileByteSize",1,"lldb::SBSection *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){ + SWIG_fail_ptr("SBSection_GetFileByteSize",1,SWIGTYPE_p_lldb__SBSection); + } + + result = (uint64_t)(arg1)->GetFileByteSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSection_GetSectionData__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + lldb::SBData result; + + SWIG_check_num_args("lldb::SBSection::GetSectionData",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::GetSectionData",1,"lldb::SBSection *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){ + SWIG_fail_ptr("SBSection_GetSectionData",1,SWIGTYPE_p_lldb__SBSection); + } + + result = (arg1)->GetSectionData(); + { + lldb::SBData * resultptr = new lldb::SBData(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBData,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSection_GetSectionData__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + uint64_t arg2 ; + uint64_t arg3 ; + lldb::SBData result; + + SWIG_check_num_args("lldb::SBSection::GetSectionData",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::GetSectionData",1,"lldb::SBSection *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBSection::GetSectionData",2,"uint64_t"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBSection::GetSectionData",3,"uint64_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){ + SWIG_fail_ptr("SBSection_GetSectionData",1,SWIGTYPE_p_lldb__SBSection); + } + + arg2 = (uint64_t)lua_tointeger(L, 2); + arg3 = (uint64_t)lua_tointeger(L, 3); + result = (arg1)->GetSectionData(arg2,arg3); + { + lldb::SBData * resultptr = new lldb::SBData(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBData,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSection_GetSectionData(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBSection, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBSection_GetSectionData__SWIG_0(L); + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBSection, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + return _wrap_SBSection_GetSectionData__SWIG_1(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBSection_GetSectionType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + lldb::SectionType result; + + SWIG_check_num_args("lldb::SBSection::GetSectionType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::GetSectionType",1,"lldb::SBSection *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){ + SWIG_fail_ptr("SBSection_GetSectionType",1,SWIGTYPE_p_lldb__SBSection); + } + + result = (lldb::SectionType)(arg1)->GetSectionType(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSection_GetPermissions(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBSection::GetPermissions",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::GetPermissions",1,"lldb::SBSection const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){ + SWIG_fail_ptr("SBSection_GetPermissions",1,SWIGTYPE_p_lldb__SBSection); + } + + result = (uint32_t)((lldb::SBSection const *)arg1)->GetPermissions(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSection_GetTargetByteSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBSection::GetTargetByteSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::GetTargetByteSize",1,"lldb::SBSection *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){ + SWIG_fail_ptr("SBSection_GetTargetByteSize",1,SWIGTYPE_p_lldb__SBSection); + } + + result = (uint32_t)(arg1)->GetTargetByteSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSection_GetAlignment(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBSection::GetAlignment",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::GetAlignment",1,"lldb::SBSection *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){ + SWIG_fail_ptr("SBSection_GetAlignment",1,SWIGTYPE_p_lldb__SBSection); + } + + result = (uint32_t)(arg1)->GetAlignment(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSection___eq(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + lldb::SBSection *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBSection::operator ==",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::operator ==",1,"lldb::SBSection *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSection::operator ==",2,"lldb::SBSection const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){ + SWIG_fail_ptr("SBSection___eq",1,SWIGTYPE_p_lldb__SBSection); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBSection,0))){ + SWIG_fail_ptr("SBSection___eq",2,SWIGTYPE_p_lldb__SBSection); + } + + result = (bool)(arg1)->operator ==((lldb::SBSection const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSection_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBSection::GetDescription",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::GetDescription",1,"lldb::SBSection *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSection::GetDescription",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){ + SWIG_fail_ptr("SBSection_GetDescription",1,SWIGTYPE_p_lldb__SBSection); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBSection_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)(arg1)->GetDescription(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSection___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSection *arg1 = (lldb::SBSection *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBSection::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSection::__repr__",1,"lldb::SBSection *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSection,0))){ + SWIG_fail_ptr("SBSection___tostring",1,SWIGTYPE_p_lldb__SBSection); + } + + result = lldb_SBSection___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBSection(void *obj) { +lldb::SBSection *arg1 = (lldb::SBSection *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBSection(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBSection); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBSection_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBSection_methods[]= { + { "IsValid", _wrap_SBSection_IsValid}, + { "GetName", _wrap_SBSection_GetName}, + { "GetParent", _wrap_SBSection_GetParent}, + { "FindSubSection", _wrap_SBSection_FindSubSection}, + { "GetNumSubSections", _wrap_SBSection_GetNumSubSections}, + { "GetSubSectionAtIndex", _wrap_SBSection_GetSubSectionAtIndex}, + { "GetFileAddress", _wrap_SBSection_GetFileAddress}, + { "GetLoadAddress", _wrap_SBSection_GetLoadAddress}, + { "GetByteSize", _wrap_SBSection_GetByteSize}, + { "GetFileOffset", _wrap_SBSection_GetFileOffset}, + { "GetFileByteSize", _wrap_SBSection_GetFileByteSize}, + { "GetSectionData", _wrap_SBSection_GetSectionData}, + { "GetSectionType", _wrap_SBSection_GetSectionType}, + { "GetPermissions", _wrap_SBSection_GetPermissions}, + { "GetTargetByteSize", _wrap_SBSection_GetTargetByteSize}, + { "GetAlignment", _wrap_SBSection_GetAlignment}, + { "__eq", _wrap_SBSection___eq}, + { "GetDescription", _wrap_SBSection_GetDescription}, + { "__tostring", _wrap_SBSection___tostring}, + {0,0} +}; +static swig_lua_method swig_SBSection_meta[] = { + { "__eq", _wrap_SBSection___eq}, + { "__tostring", _wrap_SBSection___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBSection_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBSection_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBSection_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBSection_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBSection_Sf_SwigStatic = { + "SBSection", + swig_SBSection_Sf_SwigStatic_methods, + swig_SBSection_Sf_SwigStatic_attributes, + swig_SBSection_Sf_SwigStatic_constants, + swig_SBSection_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBSection_bases[] = {0}; +static const char *swig_SBSection_base_names[] = {0}; +static swig_lua_class _wrap_class_SBSection = { "SBSection", "SBSection", &SWIGTYPE_p_lldb__SBSection,_proxy__wrap_new_SBSection, swig_delete_SBSection, swig_SBSection_methods, swig_SBSection_attributes, &swig_SBSection_Sf_SwigStatic, swig_SBSection_meta, swig_SBSection_bases, swig_SBSection_base_names }; + +static int _wrap_new_SBSourceManager__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBDebugger *arg1 = 0 ; + lldb::SBSourceManager *result = 0 ; + + SWIG_check_num_args("lldb::SBSourceManager::SBSourceManager",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBSourceManager::SBSourceManager",1,"lldb::SBDebugger const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("new_SBSourceManager",1,SWIGTYPE_p_lldb__SBDebugger); + } + + result = (lldb::SBSourceManager *)new lldb::SBSourceManager((lldb::SBDebugger const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBSourceManager,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBSourceManager__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = 0 ; + lldb::SBSourceManager *result = 0 ; + + SWIG_check_num_args("lldb::SBSourceManager::SBSourceManager",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBSourceManager::SBSourceManager",1,"lldb::SBTarget const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("new_SBSourceManager",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = (lldb::SBSourceManager *)new lldb::SBSourceManager((lldb::SBTarget const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBSourceManager,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBSourceManager__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSourceManager *arg1 = 0 ; + lldb::SBSourceManager *result = 0 ; + + SWIG_check_num_args("lldb::SBSourceManager::SBSourceManager",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBSourceManager::SBSourceManager",1,"lldb::SBSourceManager const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSourceManager,0))){ + SWIG_fail_ptr("new_SBSourceManager",1,SWIGTYPE_p_lldb__SBSourceManager); + } + + result = (lldb::SBSourceManager *)new lldb::SBSourceManager((lldb::SBSourceManager const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBSourceManager,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBSourceManager(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBDebugger, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBSourceManager__SWIG_0(L); + } + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBSourceManager__SWIG_1(L); + } + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBSourceManager, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBSourceManager__SWIG_2(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBSourceManager_DisplaySourceLinesWithLineNumbers(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSourceManager *arg1 = (lldb::SBSourceManager *) 0 ; + lldb::SBFileSpec *arg2 = 0 ; + uint32_t arg3 ; + uint32_t arg4 ; + uint32_t arg5 ; + char *arg6 = (char *) 0 ; + lldb::SBStream *arg7 = 0 ; + size_t result; + + SWIG_check_num_args("lldb::SBSourceManager::DisplaySourceLinesWithLineNumbers",7,7) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSourceManager::DisplaySourceLinesWithLineNumbers",1,"lldb::SBSourceManager *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSourceManager::DisplaySourceLinesWithLineNumbers",2,"lldb::SBFileSpec const &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBSourceManager::DisplaySourceLinesWithLineNumbers",3,"uint32_t"); + if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBSourceManager::DisplaySourceLinesWithLineNumbers",4,"uint32_t"); + if(!lua_isinteger(L,5)) SWIG_fail_arg("lldb::SBSourceManager::DisplaySourceLinesWithLineNumbers",5,"uint32_t"); + if(!SWIG_lua_isnilstring(L,6)) SWIG_fail_arg("lldb::SBSourceManager::DisplaySourceLinesWithLineNumbers",6,"char const *"); + if(!lua_isuserdata(L,7)) SWIG_fail_arg("lldb::SBSourceManager::DisplaySourceLinesWithLineNumbers",7,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSourceManager,0))){ + SWIG_fail_ptr("SBSourceManager_DisplaySourceLinesWithLineNumbers",1,SWIGTYPE_p_lldb__SBSourceManager); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBSourceManager_DisplaySourceLinesWithLineNumbers",2,SWIGTYPE_p_lldb__SBFileSpec); + } + + arg3 = (uint32_t)lua_tointeger(L, 3); + arg4 = (uint32_t)lua_tointeger(L, 4); + arg5 = (uint32_t)lua_tointeger(L, 5); + arg6 = (char *)lua_tostring(L, 6); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,7,(void**)&arg7,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBSourceManager_DisplaySourceLinesWithLineNumbers",7,SWIGTYPE_p_lldb__SBStream); + } + + result = (arg1)->DisplaySourceLinesWithLineNumbers((lldb::SBFileSpec const &)*arg2,arg3,arg4,arg5,(char const *)arg6,*arg7); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSourceManager_DisplaySourceLinesWithLineNumbersAndColumn(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSourceManager *arg1 = (lldb::SBSourceManager *) 0 ; + lldb::SBFileSpec *arg2 = 0 ; + uint32_t arg3 ; + uint32_t arg4 ; + uint32_t arg5 ; + uint32_t arg6 ; + char *arg7 = (char *) 0 ; + lldb::SBStream *arg8 = 0 ; + size_t result; + + SWIG_check_num_args("lldb::SBSourceManager::DisplaySourceLinesWithLineNumbersAndColumn",8,8) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSourceManager::DisplaySourceLinesWithLineNumbersAndColumn",1,"lldb::SBSourceManager *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSourceManager::DisplaySourceLinesWithLineNumbersAndColumn",2,"lldb::SBFileSpec const &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBSourceManager::DisplaySourceLinesWithLineNumbersAndColumn",3,"uint32_t"); + if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBSourceManager::DisplaySourceLinesWithLineNumbersAndColumn",4,"uint32_t"); + if(!lua_isinteger(L,5)) SWIG_fail_arg("lldb::SBSourceManager::DisplaySourceLinesWithLineNumbersAndColumn",5,"uint32_t"); + if(!lua_isinteger(L,6)) SWIG_fail_arg("lldb::SBSourceManager::DisplaySourceLinesWithLineNumbersAndColumn",6,"uint32_t"); + if(!SWIG_lua_isnilstring(L,7)) SWIG_fail_arg("lldb::SBSourceManager::DisplaySourceLinesWithLineNumbersAndColumn",7,"char const *"); + if(!lua_isuserdata(L,8)) SWIG_fail_arg("lldb::SBSourceManager::DisplaySourceLinesWithLineNumbersAndColumn",8,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSourceManager,0))){ + SWIG_fail_ptr("SBSourceManager_DisplaySourceLinesWithLineNumbersAndColumn",1,SWIGTYPE_p_lldb__SBSourceManager); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBSourceManager_DisplaySourceLinesWithLineNumbersAndColumn",2,SWIGTYPE_p_lldb__SBFileSpec); + } + + arg3 = (uint32_t)lua_tointeger(L, 3); + arg4 = (uint32_t)lua_tointeger(L, 4); + arg5 = (uint32_t)lua_tointeger(L, 5); + arg6 = (uint32_t)lua_tointeger(L, 6); + arg7 = (char *)lua_tostring(L, 7); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,8,(void**)&arg8,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBSourceManager_DisplaySourceLinesWithLineNumbersAndColumn",8,SWIGTYPE_p_lldb__SBStream); + } + + result = (arg1)->DisplaySourceLinesWithLineNumbersAndColumn((lldb::SBFileSpec const &)*arg2,arg3,arg4,arg5,arg6,(char const *)arg7,*arg8); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBSourceManager(void *obj) { +lldb::SBSourceManager *arg1 = (lldb::SBSourceManager *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBSourceManager(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBSourceManager); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBSourceManager_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBSourceManager_methods[]= { + { "DisplaySourceLinesWithLineNumbers", _wrap_SBSourceManager_DisplaySourceLinesWithLineNumbers}, + { "DisplaySourceLinesWithLineNumbersAndColumn", _wrap_SBSourceManager_DisplaySourceLinesWithLineNumbersAndColumn}, + {0,0} +}; +static swig_lua_method swig_SBSourceManager_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBSourceManager_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBSourceManager_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBSourceManager_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBSourceManager_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBSourceManager_Sf_SwigStatic = { + "SBSourceManager", + swig_SBSourceManager_Sf_SwigStatic_methods, + swig_SBSourceManager_Sf_SwigStatic_attributes, + swig_SBSourceManager_Sf_SwigStatic_constants, + swig_SBSourceManager_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBSourceManager_bases[] = {0}; +static const char *swig_SBSourceManager_base_names[] = {0}; +static swig_lua_class _wrap_class_SBSourceManager = { "SBSourceManager", "SBSourceManager", &SWIGTYPE_p_lldb__SBSourceManager,_proxy__wrap_new_SBSourceManager, swig_delete_SBSourceManager, swig_SBSourceManager_methods, swig_SBSourceManager_attributes, &swig_SBSourceManager_Sf_SwigStatic, swig_SBSourceManager_meta, swig_SBSourceManager_bases, swig_SBSourceManager_base_names }; + +static int _wrap_new_SBStatisticsOptions__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStatisticsOptions *result = 0 ; + + SWIG_check_num_args("lldb::SBStatisticsOptions::SBStatisticsOptions",0,0) + result = (lldb::SBStatisticsOptions *)new lldb::SBStatisticsOptions(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBStatisticsOptions,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBStatisticsOptions__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStatisticsOptions *arg1 = 0 ; + lldb::SBStatisticsOptions *result = 0 ; + + SWIG_check_num_args("lldb::SBStatisticsOptions::SBStatisticsOptions",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBStatisticsOptions::SBStatisticsOptions",1,"lldb::SBStatisticsOptions const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStatisticsOptions,0))){ + SWIG_fail_ptr("new_SBStatisticsOptions",1,SWIGTYPE_p_lldb__SBStatisticsOptions); + } + + result = (lldb::SBStatisticsOptions *)new lldb::SBStatisticsOptions((lldb::SBStatisticsOptions const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBStatisticsOptions,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBStatisticsOptions(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBStatisticsOptions__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStatisticsOptions, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBStatisticsOptions__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBStatisticsOptions'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBStatisticsOptions::SBStatisticsOptions()\n" + " lldb::SBStatisticsOptions::SBStatisticsOptions(lldb::SBStatisticsOptions const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBStatisticsOptions_SetSummaryOnly(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStatisticsOptions *arg1 = (lldb::SBStatisticsOptions *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBStatisticsOptions::SetSummaryOnly",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStatisticsOptions::SetSummaryOnly",1,"lldb::SBStatisticsOptions *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBStatisticsOptions::SetSummaryOnly",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStatisticsOptions,0))){ + SWIG_fail_ptr("SBStatisticsOptions_SetSummaryOnly",1,SWIGTYPE_p_lldb__SBStatisticsOptions); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetSummaryOnly(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStatisticsOptions_GetSummaryOnly(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStatisticsOptions *arg1 = (lldb::SBStatisticsOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBStatisticsOptions::GetSummaryOnly",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStatisticsOptions::GetSummaryOnly",1,"lldb::SBStatisticsOptions *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStatisticsOptions,0))){ + SWIG_fail_ptr("SBStatisticsOptions_GetSummaryOnly",1,SWIGTYPE_p_lldb__SBStatisticsOptions); + } + + result = (bool)(arg1)->GetSummaryOnly(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStatisticsOptions_SetIncludeTargets(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStatisticsOptions *arg1 = (lldb::SBStatisticsOptions *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBStatisticsOptions::SetIncludeTargets",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStatisticsOptions::SetIncludeTargets",1,"lldb::SBStatisticsOptions *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBStatisticsOptions::SetIncludeTargets",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStatisticsOptions,0))){ + SWIG_fail_ptr("SBStatisticsOptions_SetIncludeTargets",1,SWIGTYPE_p_lldb__SBStatisticsOptions); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetIncludeTargets(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStatisticsOptions_GetIncludeTargets(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStatisticsOptions *arg1 = (lldb::SBStatisticsOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBStatisticsOptions::GetIncludeTargets",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStatisticsOptions::GetIncludeTargets",1,"lldb::SBStatisticsOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStatisticsOptions,0))){ + SWIG_fail_ptr("SBStatisticsOptions_GetIncludeTargets",1,SWIGTYPE_p_lldb__SBStatisticsOptions); + } + + result = (bool)((lldb::SBStatisticsOptions const *)arg1)->GetIncludeTargets(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStatisticsOptions_SetIncludeModules(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStatisticsOptions *arg1 = (lldb::SBStatisticsOptions *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBStatisticsOptions::SetIncludeModules",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStatisticsOptions::SetIncludeModules",1,"lldb::SBStatisticsOptions *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBStatisticsOptions::SetIncludeModules",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStatisticsOptions,0))){ + SWIG_fail_ptr("SBStatisticsOptions_SetIncludeModules",1,SWIGTYPE_p_lldb__SBStatisticsOptions); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetIncludeModules(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStatisticsOptions_GetIncludeModules(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStatisticsOptions *arg1 = (lldb::SBStatisticsOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBStatisticsOptions::GetIncludeModules",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStatisticsOptions::GetIncludeModules",1,"lldb::SBStatisticsOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStatisticsOptions,0))){ + SWIG_fail_ptr("SBStatisticsOptions_GetIncludeModules",1,SWIGTYPE_p_lldb__SBStatisticsOptions); + } + + result = (bool)((lldb::SBStatisticsOptions const *)arg1)->GetIncludeModules(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStatisticsOptions_SetIncludeTranscript(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStatisticsOptions *arg1 = (lldb::SBStatisticsOptions *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBStatisticsOptions::SetIncludeTranscript",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStatisticsOptions::SetIncludeTranscript",1,"lldb::SBStatisticsOptions *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBStatisticsOptions::SetIncludeTranscript",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStatisticsOptions,0))){ + SWIG_fail_ptr("SBStatisticsOptions_SetIncludeTranscript",1,SWIGTYPE_p_lldb__SBStatisticsOptions); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetIncludeTranscript(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStatisticsOptions_GetIncludeTranscript(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStatisticsOptions *arg1 = (lldb::SBStatisticsOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBStatisticsOptions::GetIncludeTranscript",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStatisticsOptions::GetIncludeTranscript",1,"lldb::SBStatisticsOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStatisticsOptions,0))){ + SWIG_fail_ptr("SBStatisticsOptions_GetIncludeTranscript",1,SWIGTYPE_p_lldb__SBStatisticsOptions); + } + + result = (bool)((lldb::SBStatisticsOptions const *)arg1)->GetIncludeTranscript(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStatisticsOptions_SetReportAllAvailableDebugInfo(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStatisticsOptions *arg1 = (lldb::SBStatisticsOptions *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBStatisticsOptions::SetReportAllAvailableDebugInfo",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStatisticsOptions::SetReportAllAvailableDebugInfo",1,"lldb::SBStatisticsOptions *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBStatisticsOptions::SetReportAllAvailableDebugInfo",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStatisticsOptions,0))){ + SWIG_fail_ptr("SBStatisticsOptions_SetReportAllAvailableDebugInfo",1,SWIGTYPE_p_lldb__SBStatisticsOptions); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetReportAllAvailableDebugInfo(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStatisticsOptions_GetReportAllAvailableDebugInfo(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStatisticsOptions *arg1 = (lldb::SBStatisticsOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBStatisticsOptions::GetReportAllAvailableDebugInfo",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStatisticsOptions::GetReportAllAvailableDebugInfo",1,"lldb::SBStatisticsOptions *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStatisticsOptions,0))){ + SWIG_fail_ptr("SBStatisticsOptions_GetReportAllAvailableDebugInfo",1,SWIGTYPE_p_lldb__SBStatisticsOptions); + } + + result = (bool)(arg1)->GetReportAllAvailableDebugInfo(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBStatisticsOptions(void *obj) { +lldb::SBStatisticsOptions *arg1 = (lldb::SBStatisticsOptions *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBStatisticsOptions(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBStatisticsOptions); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBStatisticsOptions_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBStatisticsOptions_methods[]= { + { "SetSummaryOnly", _wrap_SBStatisticsOptions_SetSummaryOnly}, + { "GetSummaryOnly", _wrap_SBStatisticsOptions_GetSummaryOnly}, + { "SetIncludeTargets", _wrap_SBStatisticsOptions_SetIncludeTargets}, + { "GetIncludeTargets", _wrap_SBStatisticsOptions_GetIncludeTargets}, + { "SetIncludeModules", _wrap_SBStatisticsOptions_SetIncludeModules}, + { "GetIncludeModules", _wrap_SBStatisticsOptions_GetIncludeModules}, + { "SetIncludeTranscript", _wrap_SBStatisticsOptions_SetIncludeTranscript}, + { "GetIncludeTranscript", _wrap_SBStatisticsOptions_GetIncludeTranscript}, + { "SetReportAllAvailableDebugInfo", _wrap_SBStatisticsOptions_SetReportAllAvailableDebugInfo}, + { "GetReportAllAvailableDebugInfo", _wrap_SBStatisticsOptions_GetReportAllAvailableDebugInfo}, + {0,0} +}; +static swig_lua_method swig_SBStatisticsOptions_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBStatisticsOptions_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBStatisticsOptions_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBStatisticsOptions_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBStatisticsOptions_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBStatisticsOptions_Sf_SwigStatic = { + "SBStatisticsOptions", + swig_SBStatisticsOptions_Sf_SwigStatic_methods, + swig_SBStatisticsOptions_Sf_SwigStatic_attributes, + swig_SBStatisticsOptions_Sf_SwigStatic_constants, + swig_SBStatisticsOptions_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBStatisticsOptions_bases[] = {0}; +static const char *swig_SBStatisticsOptions_base_names[] = {0}; +static swig_lua_class _wrap_class_SBStatisticsOptions = { "SBStatisticsOptions", "SBStatisticsOptions", &SWIGTYPE_p_lldb__SBStatisticsOptions,_proxy__wrap_new_SBStatisticsOptions, swig_delete_SBStatisticsOptions, swig_SBStatisticsOptions_methods, swig_SBStatisticsOptions_attributes, &swig_SBStatisticsOptions_Sf_SwigStatic, swig_SBStatisticsOptions_meta, swig_SBStatisticsOptions_bases, swig_SBStatisticsOptions_base_names }; + +static int _wrap_new_SBStream(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStream *result = 0 ; + + SWIG_check_num_args("lldb::SBStream::SBStream",0,0) + result = (lldb::SBStream *)new lldb::SBStream(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBStream,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStream_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStream *arg1 = (lldb::SBStream *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBStream::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStream::IsValid",1,"lldb::SBStream const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBStream_IsValid",1,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)((lldb::SBStream const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStream_GetData(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStream *arg1 = (lldb::SBStream *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBStream::GetData",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStream::GetData",1,"lldb::SBStream *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBStream_GetData",1,SWIGTYPE_p_lldb__SBStream); + } + + result = (char *)(arg1)->GetData(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStream_GetSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStream *arg1 = (lldb::SBStream *) 0 ; + size_t result; + + SWIG_check_num_args("lldb::SBStream::GetSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStream::GetSize",1,"lldb::SBStream *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBStream_GetSize",1,SWIGTYPE_p_lldb__SBStream); + } + + result = (arg1)->GetSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStream_Print(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStream *arg1 = (lldb::SBStream *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBStream::Print",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStream::Print",1,"lldb::SBStream *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBStream::Print",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBStream_Print",1,SWIGTYPE_p_lldb__SBStream); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->Print((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStream_RedirectToFile__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStream *arg1 = (lldb::SBStream *) 0 ; + char *arg2 = (char *) 0 ; + bool arg3 ; + + SWIG_check_num_args("lldb::SBStream::RedirectToFile",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStream::RedirectToFile",1,"lldb::SBStream *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBStream::RedirectToFile",2,"char const *"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBStream::RedirectToFile",3,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBStream_RedirectToFile",1,SWIGTYPE_p_lldb__SBStream); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (lua_toboolean(L, 3)!=0); + (arg1)->RedirectToFile((char const *)arg2,arg3); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStream_RedirectToFile__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStream *arg1 = (lldb::SBStream *) 0 ; + lldb::SBFile arg2 ; + lldb::SBFile *argp2 ; + + SWIG_check_num_args("lldb::SBStream::RedirectToFile",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStream::RedirectToFile",1,"lldb::SBStream *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBStream::RedirectToFile",2,"lldb::SBFile"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBStream_RedirectToFile",1,SWIGTYPE_p_lldb__SBStream); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBFile,0))){ + SWIG_fail_ptr("SBStream_RedirectToFile",2,SWIGTYPE_p_lldb__SBFile); + } + arg2 = *argp2; + + (arg1)->RedirectToFile(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStream_RedirectToFile__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStream *arg1 = (lldb::SBStream *) 0 ; + SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ; + + SWIG_check_num_args("lldb::SBStream::RedirectToFile",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStream::RedirectToFile",1,"lldb::SBStream *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBStream_RedirectToFile",1,SWIGTYPE_p_lldb__SBStream); + } + + { + luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 2, LUA_FILEHANDLE); + lldb::FileSP file_sp; + file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false); + if (!file_sp->IsValid()) + return luaL_error(L, "Invalid file"); + arg2 = file_sp; + } + (arg1)->RedirectToFile(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStream_RedirectToFile(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStream, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFile, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBStream_RedirectToFile__SWIG_1(L); + } + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStream, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = (lua_isuserdata(L, argv[1])) && + (luaL_testudata(L, argv[1], LUA_FILEHANDLE) != nullptr); + } + if (_v) { + return _wrap_SBStream_RedirectToFile__SWIG_2(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStream, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[2]); + } + if (_v) { + return _wrap_SBStream_RedirectToFile__SWIG_0(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBStream_RedirectToFileDescriptor(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStream *arg1 = (lldb::SBStream *) 0 ; + int arg2 ; + bool arg3 ; + + SWIG_check_num_args("lldb::SBStream::RedirectToFileDescriptor",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStream::RedirectToFileDescriptor",1,"lldb::SBStream *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBStream::RedirectToFileDescriptor",2,"int"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBStream::RedirectToFileDescriptor",3,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBStream_RedirectToFileDescriptor",1,SWIGTYPE_p_lldb__SBStream); + } + + arg2 = (int)lua_tointeger(L, 2); + arg3 = (lua_toboolean(L, 3)!=0); + (arg1)->RedirectToFileDescriptor(arg2,arg3); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStream_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStream *arg1 = (lldb::SBStream *) 0 ; + + SWIG_check_num_args("lldb::SBStream::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStream::Clear",1,"lldb::SBStream *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBStream_Clear",1,SWIGTYPE_p_lldb__SBStream); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStream_RedirectToFileHandle(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStream *arg1 = (lldb::SBStream *) 0 ; + SwigValueWrapper< std::shared_ptr< lldb_private::File > > arg2 ; + bool arg3 ; + + SWIG_check_num_args("lldb::SBStream::RedirectToFileHandle",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStream::RedirectToFileHandle",1,"lldb::SBStream *"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBStream::RedirectToFileHandle",3,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBStream_RedirectToFileHandle",1,SWIGTYPE_p_lldb__SBStream); + } + + { + luaL_Stream *p = (luaL_Stream *)luaL_checkudata(L, 2, LUA_FILEHANDLE); + lldb::FileSP file_sp; + file_sp = std::make_shared<lldb_private::NativeFile>(p->f, false); + if (!file_sp->IsValid()) + return luaL_error(L, "Invalid file"); + arg2 = file_sp; + } + arg3 = (lua_toboolean(L, 3)!=0); + lldb_SBStream_RedirectToFileHandle(arg1,SWIG_STD_MOVE(arg2),arg3); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBStream(void *obj) { +lldb::SBStream *arg1 = (lldb::SBStream *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBStream(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBStream); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBStream_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBStream_methods[]= { + { "IsValid", _wrap_SBStream_IsValid}, + { "GetData", _wrap_SBStream_GetData}, + { "GetSize", _wrap_SBStream_GetSize}, + { "Print", _wrap_SBStream_Print}, + { "RedirectToFile", _wrap_SBStream_RedirectToFile}, + { "RedirectToFileDescriptor", _wrap_SBStream_RedirectToFileDescriptor}, + { "Clear", _wrap_SBStream_Clear}, + { "RedirectToFileHandle", _wrap_SBStream_RedirectToFileHandle}, + {0,0} +}; +static swig_lua_method swig_SBStream_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBStream_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBStream_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBStream_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBStream_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBStream_Sf_SwigStatic = { + "SBStream", + swig_SBStream_Sf_SwigStatic_methods, + swig_SBStream_Sf_SwigStatic_attributes, + swig_SBStream_Sf_SwigStatic_constants, + swig_SBStream_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBStream_bases[] = {0}; +static const char *swig_SBStream_base_names[] = {0}; +static swig_lua_class _wrap_class_SBStream = { "SBStream", "SBStream", &SWIGTYPE_p_lldb__SBStream,_proxy__wrap_new_SBStream, swig_delete_SBStream, swig_SBStream_methods, swig_SBStream_attributes, &swig_SBStream_Sf_SwigStatic, swig_SBStream_meta, swig_SBStream_bases, swig_SBStream_base_names }; + +static int _wrap_new_SBStringList__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStringList *result = 0 ; + + SWIG_check_num_args("lldb::SBStringList::SBStringList",0,0) + result = (lldb::SBStringList *)new lldb::SBStringList(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBStringList,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBStringList__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStringList *arg1 = 0 ; + lldb::SBStringList *result = 0 ; + + SWIG_check_num_args("lldb::SBStringList::SBStringList",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBStringList::SBStringList",1,"lldb::SBStringList const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStringList,0))){ + SWIG_fail_ptr("new_SBStringList",1,SWIGTYPE_p_lldb__SBStringList); + } + + result = (lldb::SBStringList *)new lldb::SBStringList((lldb::SBStringList const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBStringList,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBStringList(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBStringList__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStringList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBStringList__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBStringList'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBStringList::SBStringList()\n" + " lldb::SBStringList::SBStringList(lldb::SBStringList const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBStringList_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStringList *arg1 = (lldb::SBStringList *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBStringList::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStringList::IsValid",1,"lldb::SBStringList const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStringList,0))){ + SWIG_fail_ptr("SBStringList_IsValid",1,SWIGTYPE_p_lldb__SBStringList); + } + + result = (bool)((lldb::SBStringList const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStringList_AppendString(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStringList *arg1 = (lldb::SBStringList *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBStringList::AppendString",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStringList::AppendString",1,"lldb::SBStringList *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBStringList::AppendString",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStringList,0))){ + SWIG_fail_ptr("SBStringList_AppendString",1,SWIGTYPE_p_lldb__SBStringList); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->AppendString((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStringList_AppendList__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStringList *arg1 = (lldb::SBStringList *) 0 ; + char **arg2 = (char **) 0 ; + int arg3 ; + + SWIG_check_num_args("lldb::SBStringList::AppendList",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStringList::AppendList",1,"lldb::SBStringList *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBStringList::AppendList",3,"int"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStringList,0))){ + SWIG_fail_ptr("SBStringList_AppendList",1,SWIGTYPE_p_lldb__SBStringList); + } + + { + if (lua_istable(L, 2)) { + size_t size = lua_rawlen(L, 2); + arg2 = (char **)malloc((size + 1) * sizeof(char *)); + int i = 0, j = 0; + while (i++ < size) { + lua_rawgeti(L, 2, i); + if (!lua_isstring(L, -1)) { + // if current element cannot be converted to string, raise an error + lua_pop(L, 1); + return luaL_error(L, "List should only contain strings"); + } + arg2[j++] = (char *)lua_tostring(L, -1); + lua_pop(L, 1); + } + arg2[j] = 0; + } else if (lua_isnil(L, 2)) { + // "nil" is also acceptable, equivalent as an empty table + arg2 = NULL; + } else { + return luaL_error(L, "A list of strings expected"); + } + } + arg3 = (int)lua_tointeger(L, 3); + (arg1)->AppendList((char const **)arg2,arg3); + + { + free((char *) arg2); + } + return SWIG_arg; + + fail: SWIGUNUSED; + { + free((char *) arg2); + } + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStringList_AppendList__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStringList *arg1 = (lldb::SBStringList *) 0 ; + lldb::SBStringList *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBStringList::AppendList",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStringList::AppendList",1,"lldb::SBStringList *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBStringList::AppendList",2,"lldb::SBStringList const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStringList,0))){ + SWIG_fail_ptr("SBStringList_AppendList",1,SWIGTYPE_p_lldb__SBStringList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStringList,0))){ + SWIG_fail_ptr("SBStringList_AppendList",2,SWIGTYPE_p_lldb__SBStringList); + } + + (arg1)->AppendList((lldb::SBStringList const &)*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStringList_AppendList(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStringList, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBStringList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBStringList_AppendList__SWIG_1(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStringList, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = (lua_istable(L, argv[1]) || lua_isnil(L, argv[1])); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + return _wrap_SBStringList_AppendList__SWIG_0(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBStringList_GetSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStringList *arg1 = (lldb::SBStringList *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBStringList::GetSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStringList::GetSize",1,"lldb::SBStringList const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStringList,0))){ + SWIG_fail_ptr("SBStringList_GetSize",1,SWIGTYPE_p_lldb__SBStringList); + } + + result = (uint32_t)((lldb::SBStringList const *)arg1)->GetSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStringList_GetStringAtIndex__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStringList *arg1 = (lldb::SBStringList *) 0 ; + size_t arg2 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBStringList::GetStringAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStringList::GetStringAtIndex",1,"lldb::SBStringList *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBStringList::GetStringAtIndex",2,"size_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStringList,0))){ + SWIG_fail_ptr("SBStringList_GetStringAtIndex",1,SWIGTYPE_p_lldb__SBStringList); + } + + arg2 = (size_t)lua_tointeger(L, 2); + result = (char *)(arg1)->GetStringAtIndex(arg2); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStringList_GetStringAtIndex__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStringList *arg1 = (lldb::SBStringList *) 0 ; + size_t arg2 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBStringList::GetStringAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStringList::GetStringAtIndex",1,"lldb::SBStringList const *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBStringList::GetStringAtIndex",2,"size_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStringList,0))){ + SWIG_fail_ptr("SBStringList_GetStringAtIndex",1,SWIGTYPE_p_lldb__SBStringList); + } + + arg2 = (size_t)lua_tointeger(L, 2); + result = (char *)((lldb::SBStringList const *)arg1)->GetStringAtIndex(arg2); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStringList_GetStringAtIndex(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStringList, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_SBStringList_GetStringAtIndex__SWIG_0(L); + } + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStringList, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_SBStringList_GetStringAtIndex__SWIG_1(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBStringList_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStringList *arg1 = (lldb::SBStringList *) 0 ; + + SWIG_check_num_args("lldb::SBStringList::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStringList::Clear",1,"lldb::SBStringList *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStringList,0))){ + SWIG_fail_ptr("SBStringList_Clear",1,SWIGTYPE_p_lldb__SBStringList); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBStringList(void *obj) { +lldb::SBStringList *arg1 = (lldb::SBStringList *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBStringList(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBStringList); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBStringList_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBStringList_methods[]= { + { "IsValid", _wrap_SBStringList_IsValid}, + { "AppendString", _wrap_SBStringList_AppendString}, + { "AppendList", _wrap_SBStringList_AppendList}, + { "GetSize", _wrap_SBStringList_GetSize}, + { "GetStringAtIndex", _wrap_SBStringList_GetStringAtIndex}, + { "Clear", _wrap_SBStringList_Clear}, + {0,0} +}; +static swig_lua_method swig_SBStringList_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBStringList_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBStringList_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBStringList_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBStringList_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBStringList_Sf_SwigStatic = { + "SBStringList", + swig_SBStringList_Sf_SwigStatic_methods, + swig_SBStringList_Sf_SwigStatic_attributes, + swig_SBStringList_Sf_SwigStatic_constants, + swig_SBStringList_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBStringList_bases[] = {0}; +static const char *swig_SBStringList_base_names[] = {0}; +static swig_lua_class _wrap_class_SBStringList = { "SBStringList", "SBStringList", &SWIGTYPE_p_lldb__SBStringList,_proxy__wrap_new_SBStringList, swig_delete_SBStringList, swig_SBStringList_methods, swig_SBStringList_attributes, &swig_SBStringList_Sf_SwigStatic, swig_SBStringList_meta, swig_SBStringList_bases, swig_SBStringList_base_names }; + +static int _wrap_new_SBStructuredData__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStructuredData *result = 0 ; + + SWIG_check_num_args("lldb::SBStructuredData::SBStructuredData",0,0) + result = (lldb::SBStructuredData *)new lldb::SBStructuredData(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBStructuredData,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBStructuredData__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStructuredData *arg1 = 0 ; + lldb::SBStructuredData *result = 0 ; + + SWIG_check_num_args("lldb::SBStructuredData::SBStructuredData",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBStructuredData::SBStructuredData",1,"lldb::SBStructuredData const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("new_SBStructuredData",1,SWIGTYPE_p_lldb__SBStructuredData); + } + + result = (lldb::SBStructuredData *)new lldb::SBStructuredData((lldb::SBStructuredData const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBStructuredData,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBStructuredData__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + SwigValueWrapper< lldb::SBScriptObject > arg1 ; + lldb::SBDebugger *arg2 = 0 ; + lldb::SBScriptObject *argp1 ; + lldb::SBStructuredData *result = 0 ; + + SWIG_check_num_args("lldb::SBStructuredData::SBStructuredData",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBStructuredData::SBStructuredData",1,"lldb::SBScriptObject const"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBStructuredData::SBStructuredData",2,"lldb::SBDebugger const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&argp1,SWIGTYPE_p_lldb__SBScriptObject,0))){ + SWIG_fail_ptr("new_SBStructuredData",1,SWIGTYPE_p_lldb__SBScriptObject); + } + arg1 = *argp1; + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("new_SBStructuredData",2,SWIGTYPE_p_lldb__SBDebugger); + } + + result = (lldb::SBStructuredData *)new lldb::SBStructuredData(arg1,(lldb::SBDebugger const &)*arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBStructuredData,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBStructuredData(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBStructuredData__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBStructuredData__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBScriptObject, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBDebugger, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBStructuredData__SWIG_2(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBStructuredData_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBStructuredData::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::IsValid",1,"lldb::SBStructuredData const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("SBStructuredData_IsValid",1,SWIGTYPE_p_lldb__SBStructuredData); + } + + result = (bool)((lldb::SBStructuredData const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStructuredData_SetFromJSON__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + lldb::SBStream *arg2 = 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBStructuredData::SetFromJSON",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::SetFromJSON",1,"lldb::SBStructuredData *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBStructuredData::SetFromJSON",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("SBStructuredData_SetFromJSON",1,SWIGTYPE_p_lldb__SBStructuredData); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBStructuredData_SetFromJSON",2,SWIGTYPE_p_lldb__SBStream); + } + + result = (arg1)->SetFromJSON(*arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStructuredData_SetFromJSON__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBStructuredData::SetFromJSON",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::SetFromJSON",1,"lldb::SBStructuredData *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBStructuredData::SetFromJSON",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("SBStructuredData_SetFromJSON",1,SWIGTYPE_p_lldb__SBStructuredData); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->SetFromJSON((char const *)arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStructuredData_SetFromJSON(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBStructuredData_SetFromJSON__SWIG_0(L); + } + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + return _wrap_SBStructuredData_SetFromJSON__SWIG_1(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBStructuredData_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + + SWIG_check_num_args("lldb::SBStructuredData::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::Clear",1,"lldb::SBStructuredData *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("SBStructuredData_Clear",1,SWIGTYPE_p_lldb__SBStructuredData); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStructuredData_GetAsJSON(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + lldb::SBStream *arg2 = 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBStructuredData::GetAsJSON",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::GetAsJSON",1,"lldb::SBStructuredData const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBStructuredData::GetAsJSON",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("SBStructuredData_GetAsJSON",1,SWIGTYPE_p_lldb__SBStructuredData); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBStructuredData_GetAsJSON",2,SWIGTYPE_p_lldb__SBStream); + } + + result = ((lldb::SBStructuredData const *)arg1)->GetAsJSON(*arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStructuredData_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + lldb::SBStream *arg2 = 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBStructuredData::GetDescription",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::GetDescription",1,"lldb::SBStructuredData const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBStructuredData::GetDescription",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("SBStructuredData_GetDescription",1,SWIGTYPE_p_lldb__SBStructuredData); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBStructuredData_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + result = ((lldb::SBStructuredData const *)arg1)->GetDescription(*arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStructuredData_GetType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + lldb::StructuredDataType result; + + SWIG_check_num_args("lldb::SBStructuredData::GetType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::GetType",1,"lldb::SBStructuredData const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("SBStructuredData_GetType",1,SWIGTYPE_p_lldb__SBStructuredData); + } + + result = (lldb::StructuredDataType)((lldb::SBStructuredData const *)arg1)->GetType(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStructuredData_GetSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + size_t result; + + SWIG_check_num_args("lldb::SBStructuredData::GetSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::GetSize",1,"lldb::SBStructuredData const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("SBStructuredData_GetSize",1,SWIGTYPE_p_lldb__SBStructuredData); + } + + result = ((lldb::SBStructuredData const *)arg1)->GetSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStructuredData_GetKeys(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + lldb::SBStringList *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBStructuredData::GetKeys",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::GetKeys",1,"lldb::SBStructuredData const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBStructuredData::GetKeys",2,"lldb::SBStringList &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("SBStructuredData_GetKeys",1,SWIGTYPE_p_lldb__SBStructuredData); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStringList,0))){ + SWIG_fail_ptr("SBStructuredData_GetKeys",2,SWIGTYPE_p_lldb__SBStringList); + } + + result = (bool)((lldb::SBStructuredData const *)arg1)->GetKeys(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStructuredData_GetValueForKey(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBStructuredData result; + + SWIG_check_num_args("lldb::SBStructuredData::GetValueForKey",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::GetValueForKey",1,"lldb::SBStructuredData const *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBStructuredData::GetValueForKey",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("SBStructuredData_GetValueForKey",1,SWIGTYPE_p_lldb__SBStructuredData); + } + + arg2 = (char *)lua_tostring(L, 2); + result = ((lldb::SBStructuredData const *)arg1)->GetValueForKey((char const *)arg2); + { + lldb::SBStructuredData * resultptr = new lldb::SBStructuredData(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBStructuredData,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStructuredData_GetItemAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + size_t arg2 ; + lldb::SBStructuredData result; + + SWIG_check_num_args("lldb::SBStructuredData::GetItemAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::GetItemAtIndex",1,"lldb::SBStructuredData const *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBStructuredData::GetItemAtIndex",2,"size_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("SBStructuredData_GetItemAtIndex",1,SWIGTYPE_p_lldb__SBStructuredData); + } + + arg2 = (size_t)lua_tointeger(L, 2); + result = ((lldb::SBStructuredData const *)arg1)->GetItemAtIndex(arg2); + { + lldb::SBStructuredData * resultptr = new lldb::SBStructuredData(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBStructuredData,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStructuredData_GetUnsignedIntegerValue__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + uint64_t arg2 ; + uint64_t result; + + SWIG_check_num_args("lldb::SBStructuredData::GetUnsignedIntegerValue",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::GetUnsignedIntegerValue",1,"lldb::SBStructuredData const *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBStructuredData::GetUnsignedIntegerValue",2,"uint64_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("SBStructuredData_GetUnsignedIntegerValue",1,SWIGTYPE_p_lldb__SBStructuredData); + } + + arg2 = (uint64_t)lua_tointeger(L, 2); + result = (uint64_t)((lldb::SBStructuredData const *)arg1)->GetUnsignedIntegerValue(arg2); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStructuredData_GetUnsignedIntegerValue__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + uint64_t result; + + SWIG_check_num_args("lldb::SBStructuredData::GetUnsignedIntegerValue",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::GetUnsignedIntegerValue",1,"lldb::SBStructuredData const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("SBStructuredData_GetUnsignedIntegerValue",1,SWIGTYPE_p_lldb__SBStructuredData); + } + + result = (uint64_t)((lldb::SBStructuredData const *)arg1)->GetUnsignedIntegerValue(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStructuredData_GetUnsignedIntegerValue(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBStructuredData_GetUnsignedIntegerValue__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_SBStructuredData_GetUnsignedIntegerValue__SWIG_0(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBStructuredData_GetSignedIntegerValue__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + int64_t arg2 ; + int64_t result; + + SWIG_check_num_args("lldb::SBStructuredData::GetSignedIntegerValue",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::GetSignedIntegerValue",1,"lldb::SBStructuredData const *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBStructuredData::GetSignedIntegerValue",2,"int64_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("SBStructuredData_GetSignedIntegerValue",1,SWIGTYPE_p_lldb__SBStructuredData); + } + + arg2 = (int64_t)lua_tointeger(L, 2); + result = (int64_t)((lldb::SBStructuredData const *)arg1)->GetSignedIntegerValue(arg2); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStructuredData_GetSignedIntegerValue__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + int64_t result; + + SWIG_check_num_args("lldb::SBStructuredData::GetSignedIntegerValue",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::GetSignedIntegerValue",1,"lldb::SBStructuredData const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("SBStructuredData_GetSignedIntegerValue",1,SWIGTYPE_p_lldb__SBStructuredData); + } + + result = (int64_t)((lldb::SBStructuredData const *)arg1)->GetSignedIntegerValue(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStructuredData_GetSignedIntegerValue(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBStructuredData_GetSignedIntegerValue__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_SBStructuredData_GetSignedIntegerValue__SWIG_0(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBStructuredData_GetIntegerValue__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + uint64_t arg2 ; + uint64_t result; + + SWIG_check_num_args("lldb::SBStructuredData::GetIntegerValue",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::GetIntegerValue",1,"lldb::SBStructuredData const *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBStructuredData::GetIntegerValue",2,"uint64_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("SBStructuredData_GetIntegerValue",1,SWIGTYPE_p_lldb__SBStructuredData); + } + + arg2 = (uint64_t)lua_tointeger(L, 2); + result = (uint64_t)((lldb::SBStructuredData const *)arg1)->GetIntegerValue(arg2); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStructuredData_GetIntegerValue__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + uint64_t result; + + SWIG_check_num_args("lldb::SBStructuredData::GetIntegerValue",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::GetIntegerValue",1,"lldb::SBStructuredData const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("SBStructuredData_GetIntegerValue",1,SWIGTYPE_p_lldb__SBStructuredData); + } + + result = (uint64_t)((lldb::SBStructuredData const *)arg1)->GetIntegerValue(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStructuredData_GetIntegerValue(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBStructuredData_GetIntegerValue__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_SBStructuredData_GetIntegerValue__SWIG_0(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBStructuredData_GetFloatValue__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + double arg2 ; + double result; + + SWIG_check_num_args("lldb::SBStructuredData::GetFloatValue",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::GetFloatValue",1,"lldb::SBStructuredData const *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("lldb::SBStructuredData::GetFloatValue",2,"double"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("SBStructuredData_GetFloatValue",1,SWIGTYPE_p_lldb__SBStructuredData); + } + + arg2 = (double)lua_tonumber(L, 2); + result = (double)((lldb::SBStructuredData const *)arg1)->GetFloatValue(arg2); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStructuredData_GetFloatValue__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + double result; + + SWIG_check_num_args("lldb::SBStructuredData::GetFloatValue",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::GetFloatValue",1,"lldb::SBStructuredData const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("SBStructuredData_GetFloatValue",1,SWIGTYPE_p_lldb__SBStructuredData); + } + + result = (double)((lldb::SBStructuredData const *)arg1)->GetFloatValue(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStructuredData_GetFloatValue(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBStructuredData_GetFloatValue__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_SBStructuredData_GetFloatValue__SWIG_0(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBStructuredData_GetFloatValue'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBStructuredData::GetFloatValue(double) const\n" + " lldb::SBStructuredData::GetFloatValue() const\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBStructuredData_GetBooleanValue__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + bool arg2 ; + bool result; + + SWIG_check_num_args("lldb::SBStructuredData::GetBooleanValue",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::GetBooleanValue",1,"lldb::SBStructuredData const *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBStructuredData::GetBooleanValue",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("SBStructuredData_GetBooleanValue",1,SWIGTYPE_p_lldb__SBStructuredData); + } + + arg2 = (lua_toboolean(L, 2)!=0); + result = (bool)((lldb::SBStructuredData const *)arg1)->GetBooleanValue(arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStructuredData_GetBooleanValue__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBStructuredData::GetBooleanValue",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::GetBooleanValue",1,"lldb::SBStructuredData const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("SBStructuredData_GetBooleanValue",1,SWIGTYPE_p_lldb__SBStructuredData); + } + + result = (bool)((lldb::SBStructuredData const *)arg1)->GetBooleanValue(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStructuredData_GetBooleanValue(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBStructuredData_GetBooleanValue__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[1]); + } + if (_v) { + return _wrap_SBStructuredData_GetBooleanValue__SWIG_0(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBStructuredData_GetBooleanValue'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBStructuredData::GetBooleanValue(bool) const\n" + " lldb::SBStructuredData::GetBooleanValue() const\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBStructuredData_GetStringValue(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + char *arg2 = (char *) 0 ; + size_t arg3 ; + size_t result; + + SWIG_check_num_args("lldb::SBStructuredData::GetStringValue",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::GetStringValue",1,"lldb::SBStructuredData const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("SBStructuredData_GetStringValue",1,SWIGTYPE_p_lldb__SBStructuredData); + } + + { + arg3 = luaL_checkinteger(L, 2); + if (arg3 <= 0) { + return luaL_error(L, "Positive integer expected"); + } + arg2 = (char *)malloc(arg3); + } + result = ((lldb::SBStructuredData const *)arg1)->GetStringValue(arg2,arg3); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + { + lua_pop(L, 1); // Blow away the previous result + if (result == 0) { + lua_pushliteral(L, ""); + } else { + lua_pushlstring(L, (const char *)arg2, result); + } + free(arg2); + // SWIG_arg was already incremented + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStructuredData_GetGenericValue(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + SwigValueWrapper< lldb::SBScriptObject > result; + + SWIG_check_num_args("lldb::SBStructuredData::GetGenericValue",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::GetGenericValue",1,"lldb::SBStructuredData const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("SBStructuredData_GetGenericValue",1,SWIGTYPE_p_lldb__SBStructuredData); + } + + result = ((lldb::SBStructuredData const *)arg1)->GetGenericValue(); + { + lldb::SBScriptObject * resultptr = new lldb::SBScriptObject(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBScriptObject,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBStructuredData___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBStructuredData::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBStructuredData::__repr__",1,"lldb::SBStructuredData *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("SBStructuredData___tostring",1,SWIGTYPE_p_lldb__SBStructuredData); + } + + result = lldb_SBStructuredData___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBStructuredData(void *obj) { +lldb::SBStructuredData *arg1 = (lldb::SBStructuredData *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBStructuredData(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBStructuredData); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBStructuredData_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBStructuredData_methods[]= { + { "IsValid", _wrap_SBStructuredData_IsValid}, + { "SetFromJSON", _wrap_SBStructuredData_SetFromJSON}, + { "Clear", _wrap_SBStructuredData_Clear}, + { "GetAsJSON", _wrap_SBStructuredData_GetAsJSON}, + { "GetDescription", _wrap_SBStructuredData_GetDescription}, + { "GetType", _wrap_SBStructuredData_GetType}, + { "GetSize", _wrap_SBStructuredData_GetSize}, + { "GetKeys", _wrap_SBStructuredData_GetKeys}, + { "GetValueForKey", _wrap_SBStructuredData_GetValueForKey}, + { "GetItemAtIndex", _wrap_SBStructuredData_GetItemAtIndex}, + { "GetUnsignedIntegerValue", _wrap_SBStructuredData_GetUnsignedIntegerValue}, + { "GetSignedIntegerValue", _wrap_SBStructuredData_GetSignedIntegerValue}, + { "GetIntegerValue", _wrap_SBStructuredData_GetIntegerValue}, + { "GetFloatValue", _wrap_SBStructuredData_GetFloatValue}, + { "GetBooleanValue", _wrap_SBStructuredData_GetBooleanValue}, + { "GetStringValue", _wrap_SBStructuredData_GetStringValue}, + { "GetGenericValue", _wrap_SBStructuredData_GetGenericValue}, + { "__tostring", _wrap_SBStructuredData___tostring}, + {0,0} +}; +static swig_lua_method swig_SBStructuredData_meta[] = { + { "__tostring", _wrap_SBStructuredData___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBStructuredData_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBStructuredData_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBStructuredData_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBStructuredData_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBStructuredData_Sf_SwigStatic = { + "SBStructuredData", + swig_SBStructuredData_Sf_SwigStatic_methods, + swig_SBStructuredData_Sf_SwigStatic_attributes, + swig_SBStructuredData_Sf_SwigStatic_constants, + swig_SBStructuredData_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBStructuredData_bases[] = {0}; +static const char *swig_SBStructuredData_base_names[] = {0}; +static swig_lua_class _wrap_class_SBStructuredData = { "SBStructuredData", "SBStructuredData", &SWIGTYPE_p_lldb__SBStructuredData,_proxy__wrap_new_SBStructuredData, swig_delete_SBStructuredData, swig_SBStructuredData_methods, swig_SBStructuredData_attributes, &swig_SBStructuredData_Sf_SwigStatic, swig_SBStructuredData_meta, swig_SBStructuredData_bases, swig_SBStructuredData_base_names }; + +static int _wrap_new_SBSymbol__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbol *result = 0 ; + + SWIG_check_num_args("lldb::SBSymbol::SBSymbol",0,0) + result = (lldb::SBSymbol *)new lldb::SBSymbol(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBSymbol,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBSymbol__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbol *arg1 = 0 ; + lldb::SBSymbol *result = 0 ; + + SWIG_check_num_args("lldb::SBSymbol::SBSymbol",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBSymbol::SBSymbol",1,"lldb::SBSymbol const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbol,0))){ + SWIG_fail_ptr("new_SBSymbol",1,SWIGTYPE_p_lldb__SBSymbol); + } + + result = (lldb::SBSymbol *)new lldb::SBSymbol((lldb::SBSymbol const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBSymbol,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBSymbol(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBSymbol__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBSymbol, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBSymbol__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBSymbol'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBSymbol::SBSymbol()\n" + " lldb::SBSymbol::SBSymbol(lldb::SBSymbol const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBSymbol_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBSymbol::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbol::IsValid",1,"lldb::SBSymbol const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbol,0))){ + SWIG_fail_ptr("SBSymbol_IsValid",1,SWIGTYPE_p_lldb__SBSymbol); + } + + result = (bool)((lldb::SBSymbol const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbol_GetName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBSymbol::GetName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbol::GetName",1,"lldb::SBSymbol const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbol,0))){ + SWIG_fail_ptr("SBSymbol_GetName",1,SWIGTYPE_p_lldb__SBSymbol); + } + + result = (char *)((lldb::SBSymbol const *)arg1)->GetName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbol_GetDisplayName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBSymbol::GetDisplayName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbol::GetDisplayName",1,"lldb::SBSymbol const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbol,0))){ + SWIG_fail_ptr("SBSymbol_GetDisplayName",1,SWIGTYPE_p_lldb__SBSymbol); + } + + result = (char *)((lldb::SBSymbol const *)arg1)->GetDisplayName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbol_GetMangledName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBSymbol::GetMangledName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbol::GetMangledName",1,"lldb::SBSymbol const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbol,0))){ + SWIG_fail_ptr("SBSymbol_GetMangledName",1,SWIGTYPE_p_lldb__SBSymbol); + } + + result = (char *)((lldb::SBSymbol const *)arg1)->GetMangledName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbol_GetInstructions__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + lldb::SBTarget arg2 ; + lldb::SBTarget *argp2 ; + lldb::SBInstructionList result; + + SWIG_check_num_args("lldb::SBSymbol::GetInstructions",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbol::GetInstructions",1,"lldb::SBSymbol *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSymbol::GetInstructions",2,"lldb::SBTarget"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbol,0))){ + SWIG_fail_ptr("SBSymbol_GetInstructions",1,SWIGTYPE_p_lldb__SBSymbol); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBSymbol_GetInstructions",2,SWIGTYPE_p_lldb__SBTarget); + } + arg2 = *argp2; + + result = (arg1)->GetInstructions(arg2); + { + lldb::SBInstructionList * resultptr = new lldb::SBInstructionList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBInstructionList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbol_GetInstructions__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + lldb::SBTarget arg2 ; + char *arg3 = (char *) 0 ; + lldb::SBTarget *argp2 ; + lldb::SBInstructionList result; + + SWIG_check_num_args("lldb::SBSymbol::GetInstructions",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbol::GetInstructions",1,"lldb::SBSymbol *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSymbol::GetInstructions",2,"lldb::SBTarget"); + if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBSymbol::GetInstructions",3,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbol,0))){ + SWIG_fail_ptr("SBSymbol_GetInstructions",1,SWIGTYPE_p_lldb__SBSymbol); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBSymbol_GetInstructions",2,SWIGTYPE_p_lldb__SBTarget); + } + arg2 = *argp2; + + arg3 = (char *)lua_tostring(L, 3); + result = (arg1)->GetInstructions(arg2,(char const *)arg3); + { + lldb::SBInstructionList * resultptr = new lldb::SBInstructionList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBInstructionList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbol_GetInstructions(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBSymbol, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBSymbol_GetInstructions__SWIG_0(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBSymbol, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[2]); + } + if (_v) { + return _wrap_SBSymbol_GetInstructions__SWIG_1(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBSymbol_GetStartAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + lldb::SBAddress result; + + SWIG_check_num_args("lldb::SBSymbol::GetStartAddress",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbol::GetStartAddress",1,"lldb::SBSymbol *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbol,0))){ + SWIG_fail_ptr("SBSymbol_GetStartAddress",1,SWIGTYPE_p_lldb__SBSymbol); + } + + result = (arg1)->GetStartAddress(); + { + lldb::SBAddress * resultptr = new lldb::SBAddress(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbol_GetEndAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + lldb::SBAddress result; + + SWIG_check_num_args("lldb::SBSymbol::GetEndAddress",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbol::GetEndAddress",1,"lldb::SBSymbol *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbol,0))){ + SWIG_fail_ptr("SBSymbol_GetEndAddress",1,SWIGTYPE_p_lldb__SBSymbol); + } + + result = (arg1)->GetEndAddress(); + { + lldb::SBAddress * resultptr = new lldb::SBAddress(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbol_GetValue(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + uint64_t result; + + SWIG_check_num_args("lldb::SBSymbol::GetValue",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbol::GetValue",1,"lldb::SBSymbol *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbol,0))){ + SWIG_fail_ptr("SBSymbol_GetValue",1,SWIGTYPE_p_lldb__SBSymbol); + } + + result = (uint64_t)(arg1)->GetValue(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbol_GetSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + uint64_t result; + + SWIG_check_num_args("lldb::SBSymbol::GetSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbol::GetSize",1,"lldb::SBSymbol *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbol,0))){ + SWIG_fail_ptr("SBSymbol_GetSize",1,SWIGTYPE_p_lldb__SBSymbol); + } + + result = (uint64_t)(arg1)->GetSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbol_GetPrologueByteSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBSymbol::GetPrologueByteSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbol::GetPrologueByteSize",1,"lldb::SBSymbol *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbol,0))){ + SWIG_fail_ptr("SBSymbol_GetPrologueByteSize",1,SWIGTYPE_p_lldb__SBSymbol); + } + + result = (uint32_t)(arg1)->GetPrologueByteSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbol_GetType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + lldb::SymbolType result; + + SWIG_check_num_args("lldb::SBSymbol::GetType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbol::GetType",1,"lldb::SBSymbol *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbol,0))){ + SWIG_fail_ptr("SBSymbol_GetType",1,SWIGTYPE_p_lldb__SBSymbol); + } + + result = (lldb::SymbolType)(arg1)->GetType(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbol___eq(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + lldb::SBSymbol *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBSymbol::operator ==",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbol::operator ==",1,"lldb::SBSymbol const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSymbol::operator ==",2,"lldb::SBSymbol const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbol,0))){ + SWIG_fail_ptr("SBSymbol___eq",1,SWIGTYPE_p_lldb__SBSymbol); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBSymbol,0))){ + SWIG_fail_ptr("SBSymbol___eq",2,SWIGTYPE_p_lldb__SBSymbol); + } + + result = (bool)((lldb::SBSymbol const *)arg1)->operator ==((lldb::SBSymbol const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbol_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBSymbol::GetDescription",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbol::GetDescription",1,"lldb::SBSymbol *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSymbol::GetDescription",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbol,0))){ + SWIG_fail_ptr("SBSymbol_GetDescription",1,SWIGTYPE_p_lldb__SBSymbol); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBSymbol_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)(arg1)->GetDescription(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbol_IsExternal(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBSymbol::IsExternal",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbol::IsExternal",1,"lldb::SBSymbol *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbol,0))){ + SWIG_fail_ptr("SBSymbol_IsExternal",1,SWIGTYPE_p_lldb__SBSymbol); + } + + result = (bool)(arg1)->IsExternal(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbol_IsSynthetic(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBSymbol::IsSynthetic",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbol::IsSynthetic",1,"lldb::SBSymbol *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbol,0))){ + SWIG_fail_ptr("SBSymbol_IsSynthetic",1,SWIGTYPE_p_lldb__SBSymbol); + } + + result = (bool)(arg1)->IsSynthetic(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbol___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbol *arg1 = (lldb::SBSymbol *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBSymbol::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbol::__repr__",1,"lldb::SBSymbol *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbol,0))){ + SWIG_fail_ptr("SBSymbol___tostring",1,SWIGTYPE_p_lldb__SBSymbol); + } + + result = lldb_SBSymbol___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBSymbol(void *obj) { +lldb::SBSymbol *arg1 = (lldb::SBSymbol *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBSymbol(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBSymbol); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBSymbol_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBSymbol_methods[]= { + { "IsValid", _wrap_SBSymbol_IsValid}, + { "GetName", _wrap_SBSymbol_GetName}, + { "GetDisplayName", _wrap_SBSymbol_GetDisplayName}, + { "GetMangledName", _wrap_SBSymbol_GetMangledName}, + { "GetInstructions", _wrap_SBSymbol_GetInstructions}, + { "GetStartAddress", _wrap_SBSymbol_GetStartAddress}, + { "GetEndAddress", _wrap_SBSymbol_GetEndAddress}, + { "GetValue", _wrap_SBSymbol_GetValue}, + { "GetSize", _wrap_SBSymbol_GetSize}, + { "GetPrologueByteSize", _wrap_SBSymbol_GetPrologueByteSize}, + { "GetType", _wrap_SBSymbol_GetType}, + { "__eq", _wrap_SBSymbol___eq}, + { "GetDescription", _wrap_SBSymbol_GetDescription}, + { "IsExternal", _wrap_SBSymbol_IsExternal}, + { "IsSynthetic", _wrap_SBSymbol_IsSynthetic}, + { "__tostring", _wrap_SBSymbol___tostring}, + {0,0} +}; +static swig_lua_method swig_SBSymbol_meta[] = { + { "__eq", _wrap_SBSymbol___eq}, + { "__tostring", _wrap_SBSymbol___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBSymbol_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBSymbol_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBSymbol_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBSymbol_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBSymbol_Sf_SwigStatic = { + "SBSymbol", + swig_SBSymbol_Sf_SwigStatic_methods, + swig_SBSymbol_Sf_SwigStatic_attributes, + swig_SBSymbol_Sf_SwigStatic_constants, + swig_SBSymbol_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBSymbol_bases[] = {0}; +static const char *swig_SBSymbol_base_names[] = {0}; +static swig_lua_class _wrap_class_SBSymbol = { "SBSymbol", "SBSymbol", &SWIGTYPE_p_lldb__SBSymbol,_proxy__wrap_new_SBSymbol, swig_delete_SBSymbol, swig_SBSymbol_methods, swig_SBSymbol_attributes, &swig_SBSymbol_Sf_SwigStatic, swig_SBSymbol_meta, swig_SBSymbol_bases, swig_SBSymbol_base_names }; + +static int _wrap_new_SBSymbolContext__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbolContext *result = 0 ; + + SWIG_check_num_args("lldb::SBSymbolContext::SBSymbolContext",0,0) + result = (lldb::SBSymbolContext *)new lldb::SBSymbolContext(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBSymbolContext,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBSymbolContext__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbolContext *arg1 = 0 ; + lldb::SBSymbolContext *result = 0 ; + + SWIG_check_num_args("lldb::SBSymbolContext::SBSymbolContext",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBSymbolContext::SBSymbolContext",1,"lldb::SBSymbolContext const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContext,0))){ + SWIG_fail_ptr("new_SBSymbolContext",1,SWIGTYPE_p_lldb__SBSymbolContext); + } + + result = (lldb::SBSymbolContext *)new lldb::SBSymbolContext((lldb::SBSymbolContext const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBSymbolContext,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBSymbolContext(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBSymbolContext__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBSymbolContext, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBSymbolContext__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBSymbolContext'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBSymbolContext::SBSymbolContext()\n" + " lldb::SBSymbolContext::SBSymbolContext(lldb::SBSymbolContext const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBSymbolContext_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBSymbolContext::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContext::IsValid",1,"lldb::SBSymbolContext const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContext,0))){ + SWIG_fail_ptr("SBSymbolContext_IsValid",1,SWIGTYPE_p_lldb__SBSymbolContext); + } + + result = (bool)((lldb::SBSymbolContext const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbolContext_GetModule(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ; + lldb::SBModule result; + + SWIG_check_num_args("lldb::SBSymbolContext::GetModule",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContext::GetModule",1,"lldb::SBSymbolContext *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContext,0))){ + SWIG_fail_ptr("SBSymbolContext_GetModule",1,SWIGTYPE_p_lldb__SBSymbolContext); + } + + result = (arg1)->GetModule(); + { + lldb::SBModule * resultptr = new lldb::SBModule(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBModule,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbolContext_GetCompileUnit(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ; + lldb::SBCompileUnit result; + + SWIG_check_num_args("lldb::SBSymbolContext::GetCompileUnit",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContext::GetCompileUnit",1,"lldb::SBSymbolContext *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContext,0))){ + SWIG_fail_ptr("SBSymbolContext_GetCompileUnit",1,SWIGTYPE_p_lldb__SBSymbolContext); + } + + result = (arg1)->GetCompileUnit(); + { + lldb::SBCompileUnit * resultptr = new lldb::SBCompileUnit(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBCompileUnit,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbolContext_GetFunction(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ; + lldb::SBFunction result; + + SWIG_check_num_args("lldb::SBSymbolContext::GetFunction",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContext::GetFunction",1,"lldb::SBSymbolContext *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContext,0))){ + SWIG_fail_ptr("SBSymbolContext_GetFunction",1,SWIGTYPE_p_lldb__SBSymbolContext); + } + + result = (arg1)->GetFunction(); + { + lldb::SBFunction * resultptr = new lldb::SBFunction(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFunction,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbolContext_GetBlock(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ; + lldb::SBBlock result; + + SWIG_check_num_args("lldb::SBSymbolContext::GetBlock",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContext::GetBlock",1,"lldb::SBSymbolContext *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContext,0))){ + SWIG_fail_ptr("SBSymbolContext_GetBlock",1,SWIGTYPE_p_lldb__SBSymbolContext); + } + + result = (arg1)->GetBlock(); + { + lldb::SBBlock * resultptr = new lldb::SBBlock(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBlock,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbolContext_GetLineEntry(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ; + lldb::SBLineEntry result; + + SWIG_check_num_args("lldb::SBSymbolContext::GetLineEntry",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContext::GetLineEntry",1,"lldb::SBSymbolContext *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContext,0))){ + SWIG_fail_ptr("SBSymbolContext_GetLineEntry",1,SWIGTYPE_p_lldb__SBSymbolContext); + } + + result = (arg1)->GetLineEntry(); + { + lldb::SBLineEntry * resultptr = new lldb::SBLineEntry(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBLineEntry,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbolContext_GetSymbol(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ; + lldb::SBSymbol result; + + SWIG_check_num_args("lldb::SBSymbolContext::GetSymbol",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContext::GetSymbol",1,"lldb::SBSymbolContext *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContext,0))){ + SWIG_fail_ptr("SBSymbolContext_GetSymbol",1,SWIGTYPE_p_lldb__SBSymbolContext); + } + + result = (arg1)->GetSymbol(); + { + lldb::SBSymbol * resultptr = new lldb::SBSymbol(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbol,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbolContext_SetModule(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ; + lldb::SBModule arg2 ; + lldb::SBModule *argp2 ; + + SWIG_check_num_args("lldb::SBSymbolContext::SetModule",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContext::SetModule",1,"lldb::SBSymbolContext *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSymbolContext::SetModule",2,"lldb::SBModule"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContext,0))){ + SWIG_fail_ptr("SBSymbolContext_SetModule",1,SWIGTYPE_p_lldb__SBSymbolContext); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBSymbolContext_SetModule",2,SWIGTYPE_p_lldb__SBModule); + } + arg2 = *argp2; + + (arg1)->SetModule(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbolContext_SetCompileUnit(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ; + lldb::SBCompileUnit arg2 ; + lldb::SBCompileUnit *argp2 ; + + SWIG_check_num_args("lldb::SBSymbolContext::SetCompileUnit",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContext::SetCompileUnit",1,"lldb::SBSymbolContext *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSymbolContext::SetCompileUnit",2,"lldb::SBCompileUnit"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContext,0))){ + SWIG_fail_ptr("SBSymbolContext_SetCompileUnit",1,SWIGTYPE_p_lldb__SBSymbolContext); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBCompileUnit,0))){ + SWIG_fail_ptr("SBSymbolContext_SetCompileUnit",2,SWIGTYPE_p_lldb__SBCompileUnit); + } + arg2 = *argp2; + + (arg1)->SetCompileUnit(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbolContext_SetFunction(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ; + lldb::SBFunction arg2 ; + lldb::SBFunction *argp2 ; + + SWIG_check_num_args("lldb::SBSymbolContext::SetFunction",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContext::SetFunction",1,"lldb::SBSymbolContext *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSymbolContext::SetFunction",2,"lldb::SBFunction"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContext,0))){ + SWIG_fail_ptr("SBSymbolContext_SetFunction",1,SWIGTYPE_p_lldb__SBSymbolContext); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBFunction,0))){ + SWIG_fail_ptr("SBSymbolContext_SetFunction",2,SWIGTYPE_p_lldb__SBFunction); + } + arg2 = *argp2; + + (arg1)->SetFunction(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbolContext_SetBlock(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ; + lldb::SBBlock arg2 ; + lldb::SBBlock *argp2 ; + + SWIG_check_num_args("lldb::SBSymbolContext::SetBlock",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContext::SetBlock",1,"lldb::SBSymbolContext *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSymbolContext::SetBlock",2,"lldb::SBBlock"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContext,0))){ + SWIG_fail_ptr("SBSymbolContext_SetBlock",1,SWIGTYPE_p_lldb__SBSymbolContext); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBBlock,0))){ + SWIG_fail_ptr("SBSymbolContext_SetBlock",2,SWIGTYPE_p_lldb__SBBlock); + } + arg2 = *argp2; + + (arg1)->SetBlock(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbolContext_SetLineEntry(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ; + lldb::SBLineEntry arg2 ; + lldb::SBLineEntry *argp2 ; + + SWIG_check_num_args("lldb::SBSymbolContext::SetLineEntry",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContext::SetLineEntry",1,"lldb::SBSymbolContext *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSymbolContext::SetLineEntry",2,"lldb::SBLineEntry"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContext,0))){ + SWIG_fail_ptr("SBSymbolContext_SetLineEntry",1,SWIGTYPE_p_lldb__SBSymbolContext); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBLineEntry,0))){ + SWIG_fail_ptr("SBSymbolContext_SetLineEntry",2,SWIGTYPE_p_lldb__SBLineEntry); + } + arg2 = *argp2; + + (arg1)->SetLineEntry(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbolContext_SetSymbol(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ; + lldb::SBSymbol arg2 ; + lldb::SBSymbol *argp2 ; + + SWIG_check_num_args("lldb::SBSymbolContext::SetSymbol",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContext::SetSymbol",1,"lldb::SBSymbolContext *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSymbolContext::SetSymbol",2,"lldb::SBSymbol"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContext,0))){ + SWIG_fail_ptr("SBSymbolContext_SetSymbol",1,SWIGTYPE_p_lldb__SBSymbolContext); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBSymbol,0))){ + SWIG_fail_ptr("SBSymbolContext_SetSymbol",2,SWIGTYPE_p_lldb__SBSymbol); + } + arg2 = *argp2; + + (arg1)->SetSymbol(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbolContext_GetParentOfInlinedScope(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ; + lldb::SBAddress *arg2 = 0 ; + lldb::SBAddress *arg3 = 0 ; + lldb::SBSymbolContext result; + + SWIG_check_num_args("lldb::SBSymbolContext::GetParentOfInlinedScope",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContext::GetParentOfInlinedScope",1,"lldb::SBSymbolContext const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSymbolContext::GetParentOfInlinedScope",2,"lldb::SBAddress const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBSymbolContext::GetParentOfInlinedScope",3,"lldb::SBAddress &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContext,0))){ + SWIG_fail_ptr("SBSymbolContext_GetParentOfInlinedScope",1,SWIGTYPE_p_lldb__SBSymbolContext); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBSymbolContext_GetParentOfInlinedScope",2,SWIGTYPE_p_lldb__SBAddress); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBSymbolContext_GetParentOfInlinedScope",3,SWIGTYPE_p_lldb__SBAddress); + } + + result = ((lldb::SBSymbolContext const *)arg1)->GetParentOfInlinedScope((lldb::SBAddress const &)*arg2,*arg3); + { + lldb::SBSymbolContext * resultptr = new lldb::SBSymbolContext(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbolContext,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbolContext_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBSymbolContext::GetDescription",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContext::GetDescription",1,"lldb::SBSymbolContext *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSymbolContext::GetDescription",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContext,0))){ + SWIG_fail_ptr("SBSymbolContext_GetDescription",1,SWIGTYPE_p_lldb__SBSymbolContext); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBSymbolContext_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)(arg1)->GetDescription(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbolContext___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBSymbolContext::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContext::__repr__",1,"lldb::SBSymbolContext *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContext,0))){ + SWIG_fail_ptr("SBSymbolContext___tostring",1,SWIGTYPE_p_lldb__SBSymbolContext); + } + + result = lldb_SBSymbolContext___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBSymbolContext(void *obj) { +lldb::SBSymbolContext *arg1 = (lldb::SBSymbolContext *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBSymbolContext(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBSymbolContext); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBSymbolContext_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBSymbolContext_methods[]= { + { "IsValid", _wrap_SBSymbolContext_IsValid}, + { "GetModule", _wrap_SBSymbolContext_GetModule}, + { "GetCompileUnit", _wrap_SBSymbolContext_GetCompileUnit}, + { "GetFunction", _wrap_SBSymbolContext_GetFunction}, + { "GetBlock", _wrap_SBSymbolContext_GetBlock}, + { "GetLineEntry", _wrap_SBSymbolContext_GetLineEntry}, + { "GetSymbol", _wrap_SBSymbolContext_GetSymbol}, + { "SetModule", _wrap_SBSymbolContext_SetModule}, + { "SetCompileUnit", _wrap_SBSymbolContext_SetCompileUnit}, + { "SetFunction", _wrap_SBSymbolContext_SetFunction}, + { "SetBlock", _wrap_SBSymbolContext_SetBlock}, + { "SetLineEntry", _wrap_SBSymbolContext_SetLineEntry}, + { "SetSymbol", _wrap_SBSymbolContext_SetSymbol}, + { "GetParentOfInlinedScope", _wrap_SBSymbolContext_GetParentOfInlinedScope}, + { "GetDescription", _wrap_SBSymbolContext_GetDescription}, + { "__tostring", _wrap_SBSymbolContext___tostring}, + {0,0} +}; +static swig_lua_method swig_SBSymbolContext_meta[] = { + { "__tostring", _wrap_SBSymbolContext___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBSymbolContext_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBSymbolContext_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBSymbolContext_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBSymbolContext_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBSymbolContext_Sf_SwigStatic = { + "SBSymbolContext", + swig_SBSymbolContext_Sf_SwigStatic_methods, + swig_SBSymbolContext_Sf_SwigStatic_attributes, + swig_SBSymbolContext_Sf_SwigStatic_constants, + swig_SBSymbolContext_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBSymbolContext_bases[] = {0}; +static const char *swig_SBSymbolContext_base_names[] = {0}; +static swig_lua_class _wrap_class_SBSymbolContext = { "SBSymbolContext", "SBSymbolContext", &SWIGTYPE_p_lldb__SBSymbolContext,_proxy__wrap_new_SBSymbolContext, swig_delete_SBSymbolContext, swig_SBSymbolContext_methods, swig_SBSymbolContext_attributes, &swig_SBSymbolContext_Sf_SwigStatic, swig_SBSymbolContext_meta, swig_SBSymbolContext_bases, swig_SBSymbolContext_base_names }; + +static int _wrap_new_SBSymbolContextList__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbolContextList *result = 0 ; + + SWIG_check_num_args("lldb::SBSymbolContextList::SBSymbolContextList",0,0) + result = (lldb::SBSymbolContextList *)new lldb::SBSymbolContextList(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBSymbolContextList,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBSymbolContextList__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbolContextList *arg1 = 0 ; + lldb::SBSymbolContextList *result = 0 ; + + SWIG_check_num_args("lldb::SBSymbolContextList::SBSymbolContextList",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBSymbolContextList::SBSymbolContextList",1,"lldb::SBSymbolContextList const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContextList,0))){ + SWIG_fail_ptr("new_SBSymbolContextList",1,SWIGTYPE_p_lldb__SBSymbolContextList); + } + + result = (lldb::SBSymbolContextList *)new lldb::SBSymbolContextList((lldb::SBSymbolContextList const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBSymbolContextList,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBSymbolContextList(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBSymbolContextList__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBSymbolContextList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBSymbolContextList__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBSymbolContextList'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBSymbolContextList::SBSymbolContextList()\n" + " lldb::SBSymbolContextList::SBSymbolContextList(lldb::SBSymbolContextList const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBSymbolContextList_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbolContextList *arg1 = (lldb::SBSymbolContextList *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBSymbolContextList::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContextList::IsValid",1,"lldb::SBSymbolContextList const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContextList,0))){ + SWIG_fail_ptr("SBSymbolContextList_IsValid",1,SWIGTYPE_p_lldb__SBSymbolContextList); + } + + result = (bool)((lldb::SBSymbolContextList const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbolContextList_GetSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbolContextList *arg1 = (lldb::SBSymbolContextList *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBSymbolContextList::GetSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContextList::GetSize",1,"lldb::SBSymbolContextList const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContextList,0))){ + SWIG_fail_ptr("SBSymbolContextList_GetSize",1,SWIGTYPE_p_lldb__SBSymbolContextList); + } + + result = (uint32_t)((lldb::SBSymbolContextList const *)arg1)->GetSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbolContextList_GetContextAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbolContextList *arg1 = (lldb::SBSymbolContextList *) 0 ; + uint32_t arg2 ; + lldb::SBSymbolContext result; + + SWIG_check_num_args("lldb::SBSymbolContextList::GetContextAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContextList::GetContextAtIndex",1,"lldb::SBSymbolContextList *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBSymbolContextList::GetContextAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContextList,0))){ + SWIG_fail_ptr("SBSymbolContextList_GetContextAtIndex",1,SWIGTYPE_p_lldb__SBSymbolContextList); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetContextAtIndex(arg2); + { + lldb::SBSymbolContext * resultptr = new lldb::SBSymbolContext(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbolContext,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbolContextList_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbolContextList *arg1 = (lldb::SBSymbolContextList *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBSymbolContextList::GetDescription",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContextList::GetDescription",1,"lldb::SBSymbolContextList *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSymbolContextList::GetDescription",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContextList,0))){ + SWIG_fail_ptr("SBSymbolContextList_GetDescription",1,SWIGTYPE_p_lldb__SBSymbolContextList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBSymbolContextList_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)(arg1)->GetDescription(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbolContextList_Append__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbolContextList *arg1 = (lldb::SBSymbolContextList *) 0 ; + lldb::SBSymbolContext *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBSymbolContextList::Append",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContextList::Append",1,"lldb::SBSymbolContextList *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSymbolContextList::Append",2,"lldb::SBSymbolContext &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContextList,0))){ + SWIG_fail_ptr("SBSymbolContextList_Append",1,SWIGTYPE_p_lldb__SBSymbolContextList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBSymbolContext,0))){ + SWIG_fail_ptr("SBSymbolContextList_Append",2,SWIGTYPE_p_lldb__SBSymbolContext); + } + + (arg1)->Append(*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbolContextList_Append__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbolContextList *arg1 = (lldb::SBSymbolContextList *) 0 ; + lldb::SBSymbolContextList *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBSymbolContextList::Append",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContextList::Append",1,"lldb::SBSymbolContextList *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBSymbolContextList::Append",2,"lldb::SBSymbolContextList &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContextList,0))){ + SWIG_fail_ptr("SBSymbolContextList_Append",1,SWIGTYPE_p_lldb__SBSymbolContextList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBSymbolContextList,0))){ + SWIG_fail_ptr("SBSymbolContextList_Append",2,SWIGTYPE_p_lldb__SBSymbolContextList); + } + + (arg1)->Append(*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbolContextList_Append(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBSymbolContextList, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBSymbolContext, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBSymbolContextList_Append__SWIG_0(L); + } + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBSymbolContextList, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBSymbolContextList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBSymbolContextList_Append__SWIG_1(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBSymbolContextList_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbolContextList *arg1 = (lldb::SBSymbolContextList *) 0 ; + + SWIG_check_num_args("lldb::SBSymbolContextList::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContextList::Clear",1,"lldb::SBSymbolContextList *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContextList,0))){ + SWIG_fail_ptr("SBSymbolContextList_Clear",1,SWIGTYPE_p_lldb__SBSymbolContextList); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBSymbolContextList___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBSymbolContextList *arg1 = (lldb::SBSymbolContextList *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBSymbolContextList::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBSymbolContextList::__repr__",1,"lldb::SBSymbolContextList *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBSymbolContextList,0))){ + SWIG_fail_ptr("SBSymbolContextList___tostring",1,SWIGTYPE_p_lldb__SBSymbolContextList); + } + + result = lldb_SBSymbolContextList___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBSymbolContextList(void *obj) { +lldb::SBSymbolContextList *arg1 = (lldb::SBSymbolContextList *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBSymbolContextList(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBSymbolContextList); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBSymbolContextList_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBSymbolContextList_methods[]= { + { "IsValid", _wrap_SBSymbolContextList_IsValid}, + { "GetSize", _wrap_SBSymbolContextList_GetSize}, + { "GetContextAtIndex", _wrap_SBSymbolContextList_GetContextAtIndex}, + { "GetDescription", _wrap_SBSymbolContextList_GetDescription}, + { "Append", _wrap_SBSymbolContextList_Append}, + { "Clear", _wrap_SBSymbolContextList_Clear}, + { "__tostring", _wrap_SBSymbolContextList___tostring}, + {0,0} +}; +static swig_lua_method swig_SBSymbolContextList_meta[] = { + { "__tostring", _wrap_SBSymbolContextList___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBSymbolContextList_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBSymbolContextList_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBSymbolContextList_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBSymbolContextList_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBSymbolContextList_Sf_SwigStatic = { + "SBSymbolContextList", + swig_SBSymbolContextList_Sf_SwigStatic_methods, + swig_SBSymbolContextList_Sf_SwigStatic_attributes, + swig_SBSymbolContextList_Sf_SwigStatic_constants, + swig_SBSymbolContextList_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBSymbolContextList_bases[] = {0}; +static const char *swig_SBSymbolContextList_base_names[] = {0}; +static swig_lua_class _wrap_class_SBSymbolContextList = { "SBSymbolContextList", "SBSymbolContextList", &SWIGTYPE_p_lldb__SBSymbolContextList,_proxy__wrap_new_SBSymbolContextList, swig_delete_SBSymbolContextList, swig_SBSymbolContextList_methods, swig_SBSymbolContextList_attributes, &swig_SBSymbolContextList_Sf_SwigStatic, swig_SBSymbolContextList_meta, swig_SBSymbolContextList_bases, swig_SBSymbolContextList_base_names }; + +static int _wrap_new_SBTarget__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *result = 0 ; + + SWIG_check_num_args("lldb::SBTarget::SBTarget",0,0) + result = (lldb::SBTarget *)new lldb::SBTarget(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTarget,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBTarget__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = 0 ; + lldb::SBTarget *result = 0 ; + + SWIG_check_num_args("lldb::SBTarget::SBTarget",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBTarget::SBTarget",1,"lldb::SBTarget const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("new_SBTarget",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = (lldb::SBTarget *)new lldb::SBTarget((lldb::SBTarget const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTarget,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBTarget(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBTarget__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBTarget__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBTarget'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBTarget::SBTarget()\n" + " lldb::SBTarget::SBTarget(lldb::SBTarget const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBTarget_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTarget::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::IsValid",1,"lldb::SBTarget const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_IsValid",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = (bool)((lldb::SBTarget const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_EventIsTargetEvent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTarget::EventIsTargetEvent",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBTarget::EventIsTargetEvent",1,"lldb::SBEvent const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBTarget_EventIsTargetEvent",1,SWIGTYPE_p_lldb__SBEvent); + } + + result = (bool)lldb::SBTarget::EventIsTargetEvent((lldb::SBEvent const &)*arg1); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_GetTargetFromEvent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = 0 ; + lldb::SBTarget result; + + SWIG_check_num_args("lldb::SBTarget::GetTargetFromEvent",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBTarget::GetTargetFromEvent",1,"lldb::SBEvent const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBTarget_GetTargetFromEvent",1,SWIGTYPE_p_lldb__SBEvent); + } + + result = lldb::SBTarget::GetTargetFromEvent((lldb::SBEvent const &)*arg1); + { + lldb::SBTarget * resultptr = new lldb::SBTarget(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTarget,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_GetNumModulesFromEvent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBTarget::GetNumModulesFromEvent",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBTarget::GetNumModulesFromEvent",1,"lldb::SBEvent const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBTarget_GetNumModulesFromEvent",1,SWIGTYPE_p_lldb__SBEvent); + } + + result = (uint32_t)lldb::SBTarget::GetNumModulesFromEvent((lldb::SBEvent const &)*arg1); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_GetModuleAtIndexFromEvent(lua_State* L) { + { + int SWIG_arg = 0; + uint32_t arg1 ; + lldb::SBEvent *arg2 = 0 ; + lldb::SBModule result; + + SWIG_check_num_args("lldb::SBTarget::GetModuleAtIndexFromEvent",2,2) + if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBTarget::GetModuleAtIndexFromEvent",1,"uint32_t const"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::GetModuleAtIndexFromEvent",2,"lldb::SBEvent const &"); + arg1 = (uint32_t const)lua_tointeger(L, 1); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBTarget_GetModuleAtIndexFromEvent",2,SWIGTYPE_p_lldb__SBEvent); + } + + result = lldb::SBTarget::GetModuleAtIndexFromEvent(arg1,(lldb::SBEvent const &)*arg2); + { + lldb::SBModule * resultptr = new lldb::SBModule(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBModule,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_GetBroadcasterClassName(lua_State* L) { + { + int SWIG_arg = 0; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBTarget::GetBroadcasterClassName",0,0) + result = (char *)lldb::SBTarget::GetBroadcasterClassName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_GetProcess(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBProcess result; + + SWIG_check_num_args("lldb::SBTarget::GetProcess",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetProcess",1,"lldb::SBTarget *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_GetProcess",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = (arg1)->GetProcess(); + { + lldb::SBProcess * resultptr = new lldb::SBProcess(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_SetCollectingStats(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBTarget::SetCollectingStats",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::SetCollectingStats",1,"lldb::SBTarget *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBTarget::SetCollectingStats",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_SetCollectingStats",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetCollectingStats(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_GetCollectingStats(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTarget::GetCollectingStats",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetCollectingStats",1,"lldb::SBTarget *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_GetCollectingStats",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = (bool)(arg1)->GetCollectingStats(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_GetStatistics__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBStructuredData result; + + SWIG_check_num_args("lldb::SBTarget::GetStatistics",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetStatistics",1,"lldb::SBTarget *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_GetStatistics",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = (arg1)->GetStatistics(); + { + lldb::SBStructuredData * resultptr = new lldb::SBStructuredData(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBStructuredData,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_GetStatistics__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBStatisticsOptions arg2 ; + lldb::SBStatisticsOptions *argp2 ; + lldb::SBStructuredData result; + + SWIG_check_num_args("lldb::SBTarget::GetStatistics",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetStatistics",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::GetStatistics",2,"lldb::SBStatisticsOptions"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_GetStatistics",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBStatisticsOptions,0))){ + SWIG_fail_ptr("SBTarget_GetStatistics",2,SWIGTYPE_p_lldb__SBStatisticsOptions); + } + arg2 = *argp2; + + result = (arg1)->GetStatistics(arg2); + { + lldb::SBStructuredData * resultptr = new lldb::SBStructuredData(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBStructuredData,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_GetStatistics(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBTarget_GetStatistics__SWIG_0(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBStatisticsOptions, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBTarget_GetStatistics__SWIG_1(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBTarget_GetStatistics'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBTarget::GetStatistics()\n" + " lldb::SBTarget::GetStatistics(lldb::SBStatisticsOptions)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBTarget_GetPlatform(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBPlatform result; + + SWIG_check_num_args("lldb::SBTarget::GetPlatform",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetPlatform",1,"lldb::SBTarget *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_GetPlatform",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = (arg1)->GetPlatform(); + { + lldb::SBPlatform * resultptr = new lldb::SBPlatform(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBPlatform,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_GetEnvironment(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBEnvironment result; + + SWIG_check_num_args("lldb::SBTarget::GetEnvironment",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetEnvironment",1,"lldb::SBTarget *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_GetEnvironment",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = (arg1)->GetEnvironment(); + { + lldb::SBEnvironment * resultptr = new lldb::SBEnvironment(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBEnvironment,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_Install(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBTarget::Install",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::Install",1,"lldb::SBTarget *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_Install",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = (arg1)->Install(); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_Launch__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBListener *arg2 = 0 ; + char **arg3 = (char **) 0 ; + char **arg4 = (char **) 0 ; + char *arg5 = (char *) 0 ; + char *arg6 = (char *) 0 ; + char *arg7 = (char *) 0 ; + char *arg8 = (char *) 0 ; + uint32_t arg9 ; + bool arg10 ; + lldb::SBError *arg11 = 0 ; + lldb::SBProcess result; + + SWIG_check_num_args("lldb::SBTarget::Launch",11,11) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::Launch",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::Launch",2,"lldb::SBListener &"); + if(!SWIG_lua_isnilstring(L,5)) SWIG_fail_arg("lldb::SBTarget::Launch",5,"char const *"); + if(!SWIG_lua_isnilstring(L,6)) SWIG_fail_arg("lldb::SBTarget::Launch",6,"char const *"); + if(!SWIG_lua_isnilstring(L,7)) SWIG_fail_arg("lldb::SBTarget::Launch",7,"char const *"); + if(!SWIG_lua_isnilstring(L,8)) SWIG_fail_arg("lldb::SBTarget::Launch",8,"char const *"); + if(!lua_isinteger(L,9)) SWIG_fail_arg("lldb::SBTarget::Launch",9,"uint32_t"); + if(!lua_isboolean(L,10)) SWIG_fail_arg("lldb::SBTarget::Launch",10,"bool"); + if(!lua_isuserdata(L,11)) SWIG_fail_arg("lldb::SBTarget::Launch",11,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_Launch",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBListener,0))){ + SWIG_fail_ptr("SBTarget_Launch",2,SWIGTYPE_p_lldb__SBListener); + } + + { + if (lua_istable(L, 3)) { + size_t size = lua_rawlen(L, 3); + arg3 = (char **)malloc((size + 1) * sizeof(char *)); + int i = 0, j = 0; + while (i++ < size) { + lua_rawgeti(L, 3, i); + if (!lua_isstring(L, -1)) { + // if current element cannot be converted to string, raise an error + lua_pop(L, 1); + return luaL_error(L, "List should only contain strings"); + } + arg3[j++] = (char *)lua_tostring(L, -1); + lua_pop(L, 1); + } + arg3[j] = 0; + } else if (lua_isnil(L, 3)) { + // "nil" is also acceptable, equivalent as an empty table + arg3 = NULL; + } else { + return luaL_error(L, "A list of strings expected"); + } + } + { + if (lua_istable(L, 4)) { + size_t size = lua_rawlen(L, 4); + arg4 = (char **)malloc((size + 1) * sizeof(char *)); + int i = 0, j = 0; + while (i++ < size) { + lua_rawgeti(L, 4, i); + if (!lua_isstring(L, -1)) { + // if current element cannot be converted to string, raise an error + lua_pop(L, 1); + return luaL_error(L, "List should only contain strings"); + } + arg4[j++] = (char *)lua_tostring(L, -1); + lua_pop(L, 1); + } + arg4[j] = 0; + } else if (lua_isnil(L, 4)) { + // "nil" is also acceptable, equivalent as an empty table + arg4 = NULL; + } else { + return luaL_error(L, "A list of strings expected"); + } + } + arg5 = (char *)lua_tostring(L, 5); + arg6 = (char *)lua_tostring(L, 6); + arg7 = (char *)lua_tostring(L, 7); + arg8 = (char *)lua_tostring(L, 8); + arg9 = (uint32_t)lua_tointeger(L, 9); + arg10 = (lua_toboolean(L, 10)!=0); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,11,(void**)&arg11,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBTarget_Launch",11,SWIGTYPE_p_lldb__SBError); + } + + 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); + { + lldb::SBProcess * resultptr = new lldb::SBProcess(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++; + } + { + free((char *) arg3); + } + { + free((char *) arg4); + } + return SWIG_arg; + + fail: SWIGUNUSED; + { + free((char *) arg3); + } + { + free((char *) arg4); + } + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_LoadCore__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBProcess result; + + SWIG_check_num_args("lldb::SBTarget::LoadCore",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::LoadCore",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::LoadCore",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_LoadCore",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->LoadCore((char const *)arg2); + { + lldb::SBProcess * resultptr = new lldb::SBProcess(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_LoadCore__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBError *arg3 = 0 ; + lldb::SBProcess result; + + SWIG_check_num_args("lldb::SBTarget::LoadCore",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::LoadCore",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::LoadCore",2,"char const *"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::LoadCore",3,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_LoadCore",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBTarget_LoadCore",3,SWIGTYPE_p_lldb__SBError); + } + + result = (arg1)->LoadCore((char const *)arg2,*arg3); + { + lldb::SBProcess * resultptr = new lldb::SBProcess(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_LoadCore(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + return _wrap_SBTarget_LoadCore__SWIG_0(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBTarget_LoadCore__SWIG_1(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBTarget_LaunchSimple(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char **arg2 = (char **) 0 ; + char **arg3 = (char **) 0 ; + char *arg4 = (char *) 0 ; + lldb::SBProcess result; + + SWIG_check_num_args("lldb::SBTarget::LaunchSimple",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::LaunchSimple",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,4)) SWIG_fail_arg("lldb::SBTarget::LaunchSimple",4,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_LaunchSimple",1,SWIGTYPE_p_lldb__SBTarget); + } + + { + if (lua_istable(L, 2)) { + size_t size = lua_rawlen(L, 2); + arg2 = (char **)malloc((size + 1) * sizeof(char *)); + int i = 0, j = 0; + while (i++ < size) { + lua_rawgeti(L, 2, i); + if (!lua_isstring(L, -1)) { + // if current element cannot be converted to string, raise an error + lua_pop(L, 1); + return luaL_error(L, "List should only contain strings"); + } + arg2[j++] = (char *)lua_tostring(L, -1); + lua_pop(L, 1); + } + arg2[j] = 0; + } else if (lua_isnil(L, 2)) { + // "nil" is also acceptable, equivalent as an empty table + arg2 = NULL; + } else { + return luaL_error(L, "A list of strings expected"); + } + } + { + if (lua_istable(L, 3)) { + size_t size = lua_rawlen(L, 3); + arg3 = (char **)malloc((size + 1) * sizeof(char *)); + int i = 0, j = 0; + while (i++ < size) { + lua_rawgeti(L, 3, i); + if (!lua_isstring(L, -1)) { + // if current element cannot be converted to string, raise an error + lua_pop(L, 1); + return luaL_error(L, "List should only contain strings"); + } + arg3[j++] = (char *)lua_tostring(L, -1); + lua_pop(L, 1); + } + arg3[j] = 0; + } else if (lua_isnil(L, 3)) { + // "nil" is also acceptable, equivalent as an empty table + arg3 = NULL; + } else { + return luaL_error(L, "A list of strings expected"); + } + } + arg4 = (char *)lua_tostring(L, 4); + result = (arg1)->LaunchSimple((char const **)arg2,(char const **)arg3,(char const *)arg4); + { + lldb::SBProcess * resultptr = new lldb::SBProcess(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++; + } + { + free((char *) arg2); + } + { + free((char *) arg3); + } + return SWIG_arg; + + fail: SWIGUNUSED; + { + free((char *) arg2); + } + { + free((char *) arg3); + } + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_Launch__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBLaunchInfo *arg2 = 0 ; + lldb::SBError *arg3 = 0 ; + lldb::SBProcess result; + + SWIG_check_num_args("lldb::SBTarget::Launch",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::Launch",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::Launch",2,"lldb::SBLaunchInfo &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::Launch",3,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_Launch",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBTarget_Launch",2,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBTarget_Launch",3,SWIGTYPE_p_lldb__SBError); + } + + result = (arg1)->Launch(*arg2,*arg3); + { + lldb::SBProcess * resultptr = new lldb::SBProcess(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_Launch(lua_State* L) { + int argc; + int argv[12]={ + 1,2,3,4,5,6,7,8,9,10,11,12 + }; + + argc = lua_gettop(L); + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBLaunchInfo, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBTarget_Launch__SWIG_1(L); + } + } + } + } + if (argc == 11) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBListener, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = (lua_istable(L, argv[2]) || lua_isnil(L, argv[2])); + } + if (_v) { + { + _v = (lua_istable(L, argv[3]) || lua_isnil(L, argv[3])); + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[4]); + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[5]); + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[6]); + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[7]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[8]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[9]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[10])==0 || SWIG_ConvertPtr(L,argv[10], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBTarget_Launch__SWIG_0(L); + } + } + } + } + } + } + } + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBTarget_Attach(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBAttachInfo *arg2 = 0 ; + lldb::SBError *arg3 = 0 ; + lldb::SBProcess result; + + SWIG_check_num_args("lldb::SBTarget::Attach",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::Attach",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::Attach",2,"lldb::SBAttachInfo &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::Attach",3,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_Attach",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBAttachInfo,0))){ + SWIG_fail_ptr("SBTarget_Attach",2,SWIGTYPE_p_lldb__SBAttachInfo); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBTarget_Attach",3,SWIGTYPE_p_lldb__SBError); + } + + result = (arg1)->Attach(*arg2,*arg3); + { + lldb::SBProcess * resultptr = new lldb::SBProcess(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_AttachToProcessWithID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBListener *arg2 = 0 ; + lldb::pid_t arg3 ; + lldb::SBError *arg4 = 0 ; + lldb::SBProcess result; + + SWIG_check_num_args("lldb::SBTarget::AttachToProcessWithID",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::AttachToProcessWithID",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::AttachToProcessWithID",2,"lldb::SBListener &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::AttachToProcessWithID",3,"lldb::pid_t"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBTarget::AttachToProcessWithID",4,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_AttachToProcessWithID",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBListener,0))){ + SWIG_fail_ptr("SBTarget_AttachToProcessWithID",2,SWIGTYPE_p_lldb__SBListener); + } + + arg3 = (lldb::pid_t)lua_tointeger(L, 3); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBTarget_AttachToProcessWithID",4,SWIGTYPE_p_lldb__SBError); + } + + result = (arg1)->AttachToProcessWithID(*arg2,arg3,*arg4); + { + lldb::SBProcess * resultptr = new lldb::SBProcess(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_AttachToProcessWithName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBListener *arg2 = 0 ; + char *arg3 = (char *) 0 ; + bool arg4 ; + lldb::SBError *arg5 = 0 ; + lldb::SBProcess result; + + SWIG_check_num_args("lldb::SBTarget::AttachToProcessWithName",5,5) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::AttachToProcessWithName",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::AttachToProcessWithName",2,"lldb::SBListener &"); + if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBTarget::AttachToProcessWithName",3,"char const *"); + if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBTarget::AttachToProcessWithName",4,"bool"); + if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBTarget::AttachToProcessWithName",5,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_AttachToProcessWithName",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBListener,0))){ + SWIG_fail_ptr("SBTarget_AttachToProcessWithName",2,SWIGTYPE_p_lldb__SBListener); + } + + arg3 = (char *)lua_tostring(L, 3); + arg4 = (lua_toboolean(L, 4)!=0); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBTarget_AttachToProcessWithName",5,SWIGTYPE_p_lldb__SBError); + } + + result = (arg1)->AttachToProcessWithName(*arg2,(char const *)arg3,arg4,*arg5); + { + lldb::SBProcess * resultptr = new lldb::SBProcess(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_ConnectRemote(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBListener *arg2 = 0 ; + char *arg3 = (char *) 0 ; + char *arg4 = (char *) 0 ; + lldb::SBError *arg5 = 0 ; + lldb::SBProcess result; + + SWIG_check_num_args("lldb::SBTarget::ConnectRemote",5,5) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::ConnectRemote",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::ConnectRemote",2,"lldb::SBListener &"); + if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBTarget::ConnectRemote",3,"char const *"); + if(!SWIG_lua_isnilstring(L,4)) SWIG_fail_arg("lldb::SBTarget::ConnectRemote",4,"char const *"); + if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBTarget::ConnectRemote",5,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_ConnectRemote",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBListener,0))){ + SWIG_fail_ptr("SBTarget_ConnectRemote",2,SWIGTYPE_p_lldb__SBListener); + } + + arg3 = (char *)lua_tostring(L, 3); + arg4 = (char *)lua_tostring(L, 4); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBTarget_ConnectRemote",5,SWIGTYPE_p_lldb__SBError); + } + + result = (arg1)->ConnectRemote(*arg2,(char const *)arg3,(char const *)arg4,*arg5); + { + lldb::SBProcess * resultptr = new lldb::SBProcess(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_GetExecutable(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBFileSpec result; + + SWIG_check_num_args("lldb::SBTarget::GetExecutable",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetExecutable",1,"lldb::SBTarget *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_GetExecutable",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = (arg1)->GetExecutable(); + { + lldb::SBFileSpec * resultptr = new lldb::SBFileSpec(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_AppendImageSearchPath(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + lldb::SBError *arg4 = 0 ; + + SWIG_check_num_args("lldb::SBTarget::AppendImageSearchPath",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::AppendImageSearchPath",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::AppendImageSearchPath",2,"char const *"); + if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBTarget::AppendImageSearchPath",3,"char const *"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBTarget::AppendImageSearchPath",4,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_AppendImageSearchPath",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (char *)lua_tostring(L, 3); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBTarget_AppendImageSearchPath",4,SWIGTYPE_p_lldb__SBError); + } + + (arg1)->AppendImageSearchPath((char const *)arg2,(char const *)arg3,*arg4); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_AddModule__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBModule *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTarget::AddModule",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::AddModule",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::AddModule",2,"lldb::SBModule &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_AddModule",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBTarget_AddModule",2,SWIGTYPE_p_lldb__SBModule); + } + + result = (bool)(arg1)->AddModule(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_AddModule__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + char *arg4 = (char *) 0 ; + lldb::SBModule result; + + SWIG_check_num_args("lldb::SBTarget::AddModule",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::AddModule",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::AddModule",2,"char const *"); + if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBTarget::AddModule",3,"char const *"); + if(!SWIG_lua_isnilstring(L,4)) SWIG_fail_arg("lldb::SBTarget::AddModule",4,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_AddModule",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (char *)lua_tostring(L, 3); + arg4 = (char *)lua_tostring(L, 4); + result = (arg1)->AddModule((char const *)arg2,(char const *)arg3,(char const *)arg4); + { + lldb::SBModule * resultptr = new lldb::SBModule(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBModule,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_AddModule__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + char *arg4 = (char *) 0 ; + char *arg5 = (char *) 0 ; + lldb::SBModule result; + + SWIG_check_num_args("lldb::SBTarget::AddModule",5,5) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::AddModule",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::AddModule",2,"char const *"); + if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBTarget::AddModule",3,"char const *"); + if(!SWIG_lua_isnilstring(L,4)) SWIG_fail_arg("lldb::SBTarget::AddModule",4,"char const *"); + if(!SWIG_lua_isnilstring(L,5)) SWIG_fail_arg("lldb::SBTarget::AddModule",5,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_AddModule",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (char *)lua_tostring(L, 3); + arg4 = (char *)lua_tostring(L, 4); + arg5 = (char *)lua_tostring(L, 5); + result = (arg1)->AddModule((char const *)arg2,(char const *)arg3,(char const *)arg4,(char const *)arg5); + { + lldb::SBModule * resultptr = new lldb::SBModule(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBModule,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_AddModule__SWIG_3(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBModuleSpec *arg2 = 0 ; + lldb::SBModule result; + + SWIG_check_num_args("lldb::SBTarget::AddModule",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::AddModule",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::AddModule",2,"lldb::SBModuleSpec const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_AddModule",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBModuleSpec,0))){ + SWIG_fail_ptr("SBTarget_AddModule",2,SWIGTYPE_p_lldb__SBModuleSpec); + } + + result = (arg1)->AddModule((lldb::SBModuleSpec const &)*arg2); + { + lldb::SBModule * resultptr = new lldb::SBModule(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBModule,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_AddModule(lua_State* L) { + int argc; + int argv[6]={ + 1,2,3,4,5,6 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBModule, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBTarget_AddModule__SWIG_0(L); + } + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBModuleSpec, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBTarget_AddModule__SWIG_3(L); + } + } + } + if (argc == 4) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[2]); + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[3]); + } + if (_v) { + return _wrap_SBTarget_AddModule__SWIG_1(L); + } + } + } + } + } + if (argc == 5) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[2]); + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[3]); + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[4]); + } + if (_v) { + return _wrap_SBTarget_AddModule__SWIG_2(L); + } + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBTarget_GetNumModules(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBTarget::GetNumModules",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetNumModules",1,"lldb::SBTarget const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_GetNumModules",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = (uint32_t)((lldb::SBTarget const *)arg1)->GetNumModules(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_GetModuleAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + uint32_t arg2 ; + lldb::SBModule result; + + SWIG_check_num_args("lldb::SBTarget::GetModuleAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetModuleAtIndex",1,"lldb::SBTarget *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTarget::GetModuleAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_GetModuleAtIndex",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetModuleAtIndex(arg2); + { + lldb::SBModule * resultptr = new lldb::SBModule(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBModule,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_RemoveModule(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBModule arg2 ; + lldb::SBModule *argp2 ; + bool result; + + SWIG_check_num_args("lldb::SBTarget::RemoveModule",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::RemoveModule",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::RemoveModule",2,"lldb::SBModule"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_RemoveModule",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBTarget_RemoveModule",2,SWIGTYPE_p_lldb__SBModule); + } + arg2 = *argp2; + + result = (bool)(arg1)->RemoveModule(arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_GetDebugger(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBDebugger result; + + SWIG_check_num_args("lldb::SBTarget::GetDebugger",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetDebugger",1,"lldb::SBTarget const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_GetDebugger",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = ((lldb::SBTarget const *)arg1)->GetDebugger(); + { + lldb::SBDebugger * resultptr = new lldb::SBDebugger(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBDebugger,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_FindModule(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBFileSpec *arg2 = 0 ; + lldb::SBModule result; + + SWIG_check_num_args("lldb::SBTarget::FindModule",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::FindModule",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::FindModule",2,"lldb::SBFileSpec const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_FindModule",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBTarget_FindModule",2,SWIGTYPE_p_lldb__SBFileSpec); + } + + result = (arg1)->FindModule((lldb::SBFileSpec const &)*arg2); + { + lldb::SBModule * resultptr = new lldb::SBModule(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBModule,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_FindCompileUnits(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBFileSpec *arg2 = 0 ; + lldb::SBSymbolContextList result; + + SWIG_check_num_args("lldb::SBTarget::FindCompileUnits",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::FindCompileUnits",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::FindCompileUnits",2,"lldb::SBFileSpec const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_FindCompileUnits",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBTarget_FindCompileUnits",2,SWIGTYPE_p_lldb__SBFileSpec); + } + + result = (arg1)->FindCompileUnits((lldb::SBFileSpec const &)*arg2); + { + lldb::SBSymbolContextList * resultptr = new lldb::SBSymbolContextList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbolContextList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_GetByteOrder(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::ByteOrder result; + + SWIG_check_num_args("lldb::SBTarget::GetByteOrder",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetByteOrder",1,"lldb::SBTarget *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_GetByteOrder",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = (lldb::ByteOrder)(arg1)->GetByteOrder(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_GetAddressByteSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBTarget::GetAddressByteSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetAddressByteSize",1,"lldb::SBTarget *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_GetAddressByteSize",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = (uint32_t)(arg1)->GetAddressByteSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_GetTriple(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBTarget::GetTriple",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetTriple",1,"lldb::SBTarget *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_GetTriple",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = (char *)(arg1)->GetTriple(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_GetABIName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBTarget::GetABIName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetABIName",1,"lldb::SBTarget *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_GetABIName",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = (char *)(arg1)->GetABIName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_GetLabel(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBTarget::GetLabel",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetLabel",1,"lldb::SBTarget const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_GetLabel",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = (char *)((lldb::SBTarget const *)arg1)->GetLabel(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_SetLabel(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBTarget::SetLabel",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::SetLabel",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::SetLabel",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_SetLabel",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->SetLabel((char const *)arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_GetDataByteSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBTarget::GetDataByteSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetDataByteSize",1,"lldb::SBTarget *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_GetDataByteSize",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = (uint32_t)(arg1)->GetDataByteSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_GetCodeByteSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBTarget::GetCodeByteSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetCodeByteSize",1,"lldb::SBTarget *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_GetCodeByteSize",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = (uint32_t)(arg1)->GetCodeByteSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_GetMaximumNumberOfChildrenToDisplay(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBTarget::GetMaximumNumberOfChildrenToDisplay",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetMaximumNumberOfChildrenToDisplay",1,"lldb::SBTarget const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_GetMaximumNumberOfChildrenToDisplay",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = (uint32_t)((lldb::SBTarget const *)arg1)->GetMaximumNumberOfChildrenToDisplay(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_SetSectionLoadAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBSection arg2 ; + lldb::addr_t arg3 ; + lldb::SBSection *argp2 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBTarget::SetSectionLoadAddress",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::SetSectionLoadAddress",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::SetSectionLoadAddress",2,"lldb::SBSection"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::SetSectionLoadAddress",3,"lldb::addr_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_SetSectionLoadAddress",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBSection,0))){ + SWIG_fail_ptr("SBTarget_SetSectionLoadAddress",2,SWIGTYPE_p_lldb__SBSection); + } + arg2 = *argp2; + + arg3 = (lldb::addr_t)lua_tointeger(L, 3); + result = (arg1)->SetSectionLoadAddress(arg2,arg3); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_ClearSectionLoadAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBSection arg2 ; + lldb::SBSection *argp2 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBTarget::ClearSectionLoadAddress",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::ClearSectionLoadAddress",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::ClearSectionLoadAddress",2,"lldb::SBSection"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_ClearSectionLoadAddress",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBSection,0))){ + SWIG_fail_ptr("SBTarget_ClearSectionLoadAddress",2,SWIGTYPE_p_lldb__SBSection); + } + arg2 = *argp2; + + result = (arg1)->ClearSectionLoadAddress(arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_SetModuleLoadAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBModule arg2 ; + uint64_t arg3 ; + lldb::SBModule *argp2 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBTarget::SetModuleLoadAddress",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::SetModuleLoadAddress",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::SetModuleLoadAddress",2,"lldb::SBModule"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::SetModuleLoadAddress",3,"uint64_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_SetModuleLoadAddress",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBTarget_SetModuleLoadAddress",2,SWIGTYPE_p_lldb__SBModule); + } + arg2 = *argp2; + + arg3 = (uint64_t)lua_tointeger(L, 3); + result = (arg1)->SetModuleLoadAddress(arg2,arg3); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_ClearModuleLoadAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBModule arg2 ; + lldb::SBModule *argp2 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBTarget::ClearModuleLoadAddress",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::ClearModuleLoadAddress",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::ClearModuleLoadAddress",2,"lldb::SBModule"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_ClearModuleLoadAddress",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBTarget_ClearModuleLoadAddress",2,SWIGTYPE_p_lldb__SBModule); + } + arg2 = *argp2; + + result = (arg1)->ClearModuleLoadAddress(arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_FindFunctions__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + uint32_t arg3 ; + lldb::SBSymbolContextList result; + + SWIG_check_num_args("lldb::SBTarget::FindFunctions",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::FindFunctions",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::FindFunctions",2,"char const *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::FindFunctions",3,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_FindFunctions",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (uint32_t)lua_tointeger(L, 3); + result = (arg1)->FindFunctions((char const *)arg2,arg3); + { + lldb::SBSymbolContextList * resultptr = new lldb::SBSymbolContextList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbolContextList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_FindFunctions__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBSymbolContextList result; + + SWIG_check_num_args("lldb::SBTarget::FindFunctions",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::FindFunctions",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::FindFunctions",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_FindFunctions",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->FindFunctions((char const *)arg2); + { + lldb::SBSymbolContextList * resultptr = new lldb::SBSymbolContextList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbolContextList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_FindFunctions(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + return _wrap_SBTarget_FindFunctions__SWIG_1(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + return _wrap_SBTarget_FindFunctions__SWIG_0(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBTarget_FindGlobalVariables__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + uint32_t arg3 ; + lldb::SBValueList result; + + SWIG_check_num_args("lldb::SBTarget::FindGlobalVariables",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::FindGlobalVariables",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::FindGlobalVariables",2,"char const *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::FindGlobalVariables",3,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_FindGlobalVariables",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (uint32_t)lua_tointeger(L, 3); + result = (arg1)->FindGlobalVariables((char const *)arg2,arg3); + { + lldb::SBValueList * resultptr = new lldb::SBValueList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValueList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_FindFirstGlobalVariable(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBTarget::FindFirstGlobalVariable",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::FindFirstGlobalVariable",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::FindFirstGlobalVariable",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_FindFirstGlobalVariable",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->FindFirstGlobalVariable((char const *)arg2); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_FindGlobalVariables__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + uint32_t arg3 ; + lldb::MatchType arg4 ; + lldb::SBValueList result; + + SWIG_check_num_args("lldb::SBTarget::FindGlobalVariables",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::FindGlobalVariables",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::FindGlobalVariables",2,"char const *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::FindGlobalVariables",3,"uint32_t"); + if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBTarget::FindGlobalVariables",4,"lldb::MatchType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_FindGlobalVariables",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (uint32_t)lua_tointeger(L, 3); + arg4 = (lldb::MatchType)lua_tointeger(L, 4); + result = (arg1)->FindGlobalVariables((char const *)arg2,arg3,arg4); + { + lldb::SBValueList * resultptr = new lldb::SBValueList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValueList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_FindGlobalVariables(lua_State* L) { + int argc; + int argv[5]={ + 1,2,3,4,5 + }; + + argc = lua_gettop(L); + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + return _wrap_SBTarget_FindGlobalVariables__SWIG_0(L); + } + } + } + } + if (argc == 4) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[3]); + } + if (_v) { + return _wrap_SBTarget_FindGlobalVariables__SWIG_1(L); + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBTarget_FindGlobalFunctions(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + uint32_t arg3 ; + lldb::MatchType arg4 ; + lldb::SBSymbolContextList result; + + SWIG_check_num_args("lldb::SBTarget::FindGlobalFunctions",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::FindGlobalFunctions",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::FindGlobalFunctions",2,"char const *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::FindGlobalFunctions",3,"uint32_t"); + if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBTarget::FindGlobalFunctions",4,"lldb::MatchType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_FindGlobalFunctions",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (uint32_t)lua_tointeger(L, 3); + arg4 = (lldb::MatchType)lua_tointeger(L, 4); + result = (arg1)->FindGlobalFunctions((char const *)arg2,arg3,arg4); + { + lldb::SBSymbolContextList * resultptr = new lldb::SBSymbolContextList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbolContextList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + + SWIG_check_num_args("lldb::SBTarget::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::Clear",1,"lldb::SBTarget *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_Clear",1,SWIGTYPE_p_lldb__SBTarget); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_ResolveFileAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::addr_t arg2 ; + lldb::SBAddress result; + + SWIG_check_num_args("lldb::SBTarget::ResolveFileAddress",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::ResolveFileAddress",1,"lldb::SBTarget *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTarget::ResolveFileAddress",2,"lldb::addr_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_ResolveFileAddress",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (lldb::addr_t)lua_tointeger(L, 2); + result = (arg1)->ResolveFileAddress(arg2); + { + lldb::SBAddress * resultptr = new lldb::SBAddress(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_ResolveLoadAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::addr_t arg2 ; + lldb::SBAddress result; + + SWIG_check_num_args("lldb::SBTarget::ResolveLoadAddress",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::ResolveLoadAddress",1,"lldb::SBTarget *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTarget::ResolveLoadAddress",2,"lldb::addr_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_ResolveLoadAddress",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (lldb::addr_t)lua_tointeger(L, 2); + result = (arg1)->ResolveLoadAddress(arg2); + { + lldb::SBAddress * resultptr = new lldb::SBAddress(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_ResolvePastLoadAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + uint32_t arg2 ; + lldb::addr_t arg3 ; + lldb::SBAddress result; + + SWIG_check_num_args("lldb::SBTarget::ResolvePastLoadAddress",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::ResolvePastLoadAddress",1,"lldb::SBTarget *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTarget::ResolvePastLoadAddress",2,"uint32_t"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::ResolvePastLoadAddress",3,"lldb::addr_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_ResolvePastLoadAddress",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + arg3 = (lldb::addr_t)lua_tointeger(L, 3); + result = (arg1)->ResolvePastLoadAddress(arg2,arg3); + { + lldb::SBAddress * resultptr = new lldb::SBAddress(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_ResolveSymbolContextForAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBAddress *arg2 = 0 ; + uint32_t arg3 ; + lldb::SBSymbolContext result; + + SWIG_check_num_args("lldb::SBTarget::ResolveSymbolContextForAddress",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::ResolveSymbolContextForAddress",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::ResolveSymbolContextForAddress",2,"lldb::SBAddress const &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::ResolveSymbolContextForAddress",3,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_ResolveSymbolContextForAddress",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBTarget_ResolveSymbolContextForAddress",2,SWIGTYPE_p_lldb__SBAddress); + } + + arg3 = (uint32_t)lua_tointeger(L, 3); + result = (arg1)->ResolveSymbolContextForAddress((lldb::SBAddress const &)*arg2,arg3); + { + lldb::SBSymbolContext * resultptr = new lldb::SBSymbolContext(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbolContext,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_ReadMemory(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBAddress arg2 ; + void *arg3 = (void *) 0 ; + size_t arg4 ; + lldb::SBError *arg5 = 0 ; + lldb::SBAddress *argp2 ; + size_t result; + + SWIG_check_num_args("lldb::SBTarget::ReadMemory",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::ReadMemory",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::ReadMemory",2,"lldb::SBAddress const"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBTarget::ReadMemory",4,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_ReadMemory",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBTarget_ReadMemory",2,SWIGTYPE_p_lldb__SBAddress); + } + arg2 = *argp2; + + { + arg4 = luaL_checkinteger(L, 3); + if (arg4 <= 0) { + return luaL_error(L, "Positive integer expected"); + } + arg3 = (char *)malloc(arg4); + } + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg5,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBTarget_ReadMemory",5,SWIGTYPE_p_lldb__SBError); + } + + result = (arg1)->ReadMemory(arg2,arg3,arg4,*arg5); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + { + lua_pop(L, 1); // Blow away the previous result + if (result == 0) { + lua_pushliteral(L, ""); + } else { + lua_pushlstring(L, (const char *)arg3, result); + } + free(arg3); + // SWIG_arg was already incremented + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_BreakpointCreateByLocation__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + uint32_t arg3 ; + lldb::SBBreakpoint result; + + SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByLocation",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",2,"char const *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",3,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByLocation",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (uint32_t)lua_tointeger(L, 3); + result = (arg1)->BreakpointCreateByLocation((char const *)arg2,arg3); + { + lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_BreakpointCreateByLocation__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBFileSpec *arg2 = 0 ; + uint32_t arg3 ; + lldb::SBBreakpoint result; + + SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByLocation",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",2,"lldb::SBFileSpec const &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",3,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByLocation",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByLocation",2,SWIGTYPE_p_lldb__SBFileSpec); + } + + arg3 = (uint32_t)lua_tointeger(L, 3); + result = (arg1)->BreakpointCreateByLocation((lldb::SBFileSpec const &)*arg2,arg3); + { + lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_BreakpointCreateByLocation__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBFileSpec *arg2 = 0 ; + uint32_t arg3 ; + lldb::addr_t arg4 ; + lldb::SBBreakpoint result; + + SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByLocation",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",2,"lldb::SBFileSpec const &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",3,"uint32_t"); + if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",4,"lldb::addr_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByLocation",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByLocation",2,SWIGTYPE_p_lldb__SBFileSpec); + } + + arg3 = (uint32_t)lua_tointeger(L, 3); + arg4 = (lldb::addr_t)lua_tointeger(L, 4); + result = (arg1)->BreakpointCreateByLocation((lldb::SBFileSpec const &)*arg2,arg3,arg4); + { + lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_BreakpointCreateByLocation__SWIG_3(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBFileSpec *arg2 = 0 ; + uint32_t arg3 ; + lldb::addr_t arg4 ; + lldb::SBFileSpecList *arg5 = 0 ; + lldb::SBBreakpoint result; + + SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByLocation",5,5) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",2,"lldb::SBFileSpec const &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",3,"uint32_t"); + if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",4,"lldb::addr_t"); + if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",5,"lldb::SBFileSpecList &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByLocation",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByLocation",2,SWIGTYPE_p_lldb__SBFileSpec); + } + + arg3 = (uint32_t)lua_tointeger(L, 3); + arg4 = (lldb::addr_t)lua_tointeger(L, 4); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByLocation",5,SWIGTYPE_p_lldb__SBFileSpecList); + } + + result = (arg1)->BreakpointCreateByLocation((lldb::SBFileSpec const &)*arg2,arg3,arg4,*arg5); + { + lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_BreakpointCreateByLocation__SWIG_4(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBFileSpec *arg2 = 0 ; + uint32_t arg3 ; + uint32_t arg4 ; + lldb::addr_t arg5 ; + lldb::SBFileSpecList *arg6 = 0 ; + lldb::SBBreakpoint result; + + SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByLocation",6,6) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",2,"lldb::SBFileSpec const &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",3,"uint32_t"); + if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",4,"uint32_t"); + if(!lua_isinteger(L,5)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",5,"lldb::addr_t"); + if(!lua_isuserdata(L,6)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",6,"lldb::SBFileSpecList &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByLocation",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByLocation",2,SWIGTYPE_p_lldb__SBFileSpec); + } + + arg3 = (uint32_t)lua_tointeger(L, 3); + arg4 = (uint32_t)lua_tointeger(L, 4); + arg5 = (lldb::addr_t)lua_tointeger(L, 5); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByLocation",6,SWIGTYPE_p_lldb__SBFileSpecList); + } + + result = (arg1)->BreakpointCreateByLocation((lldb::SBFileSpec const &)*arg2,arg3,arg4,arg5,*arg6); + { + lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_BreakpointCreateByLocation__SWIG_5(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBFileSpec *arg2 = 0 ; + uint32_t arg3 ; + uint32_t arg4 ; + lldb::addr_t arg5 ; + lldb::SBFileSpecList *arg6 = 0 ; + bool arg7 ; + lldb::SBBreakpoint result; + + SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByLocation",7,7) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",2,"lldb::SBFileSpec const &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",3,"uint32_t"); + if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",4,"uint32_t"); + if(!lua_isinteger(L,5)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",5,"lldb::addr_t"); + if(!lua_isuserdata(L,6)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",6,"lldb::SBFileSpecList &"); + if(!lua_isboolean(L,7)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByLocation",7,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByLocation",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByLocation",2,SWIGTYPE_p_lldb__SBFileSpec); + } + + arg3 = (uint32_t)lua_tointeger(L, 3); + arg4 = (uint32_t)lua_tointeger(L, 4); + arg5 = (lldb::addr_t)lua_tointeger(L, 5); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByLocation",6,SWIGTYPE_p_lldb__SBFileSpecList); + } + + arg7 = (lua_toboolean(L, 7)!=0); + result = (arg1)->BreakpointCreateByLocation((lldb::SBFileSpec const &)*arg2,arg3,arg4,arg5,*arg6,arg7); + { + lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_BreakpointCreateByLocation(lua_State* L) { + int argc; + int argv[8]={ + 1,2,3,4,5,6,7,8 + }; + + argc = lua_gettop(L); + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + return _wrap_SBTarget_BreakpointCreateByLocation__SWIG_1(L); + } + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + return _wrap_SBTarget_BreakpointCreateByLocation__SWIG_0(L); + } + } + } + } + if (argc == 4) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[3]); + } + if (_v) { + return _wrap_SBTarget_BreakpointCreateByLocation__SWIG_2(L); + } + } + } + } + } + if (argc == 5) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[3]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBTarget_BreakpointCreateByLocation__SWIG_3(L); + } + } + } + } + } + } + if (argc == 6) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[3]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[4]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[5])==0 || SWIG_ConvertPtr(L,argv[5], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBTarget_BreakpointCreateByLocation__SWIG_4(L); + } + } + } + } + } + } + } + if (argc == 7) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[3]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[4]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[5])==0 || SWIG_ConvertPtr(L,argv[5], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[6]); + } + if (_v) { + return _wrap_SBTarget_BreakpointCreateByLocation__SWIG_5(L); + } + } + } + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBTarget_BreakpointCreateByName__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + lldb::SBBreakpoint result; + + SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByName",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",2,"char const *"); + if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",3,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByName",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (char *)lua_tostring(L, 3); + result = (arg1)->BreakpointCreateByName((char const *)arg2,(char const *)arg3); + { + lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_BreakpointCreateByName__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBBreakpoint result; + + SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByName",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByName",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->BreakpointCreateByName((char const *)arg2); + { + lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_BreakpointCreateByName__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBFileSpecList *arg3 = 0 ; + lldb::SBFileSpecList *arg4 = 0 ; + lldb::SBBreakpoint result; + + SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByName",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",2,"char const *"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",3,"lldb::SBFileSpecList const &"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",4,"lldb::SBFileSpecList const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByName",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByName",3,SWIGTYPE_p_lldb__SBFileSpecList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByName",4,SWIGTYPE_p_lldb__SBFileSpecList); + } + + result = (arg1)->BreakpointCreateByName((char const *)arg2,(lldb::SBFileSpecList const &)*arg3,(lldb::SBFileSpecList const &)*arg4); + { + lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_BreakpointCreateByName__SWIG_3(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + uint32_t arg3 ; + lldb::SBFileSpecList *arg4 = 0 ; + lldb::SBFileSpecList *arg5 = 0 ; + lldb::SBBreakpoint result; + + SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByName",5,5) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",2,"char const *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",3,"uint32_t"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",4,"lldb::SBFileSpecList const &"); + if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",5,"lldb::SBFileSpecList const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByName",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (uint32_t)lua_tointeger(L, 3); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByName",4,SWIGTYPE_p_lldb__SBFileSpecList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByName",5,SWIGTYPE_p_lldb__SBFileSpecList); + } + + result = (arg1)->BreakpointCreateByName((char const *)arg2,arg3,(lldb::SBFileSpecList const &)*arg4,(lldb::SBFileSpecList const &)*arg5); + { + lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_BreakpointCreateByName__SWIG_4(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + uint32_t arg3 ; + lldb::LanguageType arg4 ; + lldb::SBFileSpecList *arg5 = 0 ; + lldb::SBFileSpecList *arg6 = 0 ; + lldb::SBBreakpoint result; + + SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByName",6,6) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",2,"char const *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",3,"uint32_t"); + if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",4,"lldb::LanguageType"); + if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",5,"lldb::SBFileSpecList const &"); + if(!lua_isuserdata(L,6)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByName",6,"lldb::SBFileSpecList const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByName",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (uint32_t)lua_tointeger(L, 3); + arg4 = (lldb::LanguageType)lua_tointeger(L, 4); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByName",5,SWIGTYPE_p_lldb__SBFileSpecList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByName",6,SWIGTYPE_p_lldb__SBFileSpecList); + } + + result = (arg1)->BreakpointCreateByName((char const *)arg2,arg3,arg4,(lldb::SBFileSpecList const &)*arg5,(lldb::SBFileSpecList const &)*arg6); + { + lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_BreakpointCreateByName(lua_State* L) { + int argc; + int argv[7]={ + 1,2,3,4,5,6,7 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + return _wrap_SBTarget_BreakpointCreateByName__SWIG_1(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[2]); + } + if (_v) { + return _wrap_SBTarget_BreakpointCreateByName__SWIG_0(L); + } + } + } + } + if (argc == 4) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBTarget_BreakpointCreateByName__SWIG_2(L); + } + } + } + } + } + if (argc == 5) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBTarget_BreakpointCreateByName__SWIG_3(L); + } + } + } + } + } + } + if (argc == 6) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[3]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[5])==0 || SWIG_ConvertPtr(L,argv[5], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBTarget_BreakpointCreateByName__SWIG_4(L); + } + } + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBTarget_BreakpointCreateByNames__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char **arg2 = (char **) 0 ; + uint32_t arg3 ; + uint32_t arg4 ; + lldb::SBFileSpecList *arg5 = 0 ; + lldb::SBFileSpecList *arg6 = 0 ; + lldb::SBBreakpoint result; + + SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByNames",6,6) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",1,"lldb::SBTarget *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",3,"uint32_t"); + if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",4,"uint32_t"); + if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",5,"lldb::SBFileSpecList const &"); + if(!lua_isuserdata(L,6)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",6,"lldb::SBFileSpecList const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByNames",1,SWIGTYPE_p_lldb__SBTarget); + } + + { + if (lua_istable(L, 2)) { + size_t size = lua_rawlen(L, 2); + arg2 = (char **)malloc((size + 1) * sizeof(char *)); + int i = 0, j = 0; + while (i++ < size) { + lua_rawgeti(L, 2, i); + if (!lua_isstring(L, -1)) { + // if current element cannot be converted to string, raise an error + lua_pop(L, 1); + return luaL_error(L, "List should only contain strings"); + } + arg2[j++] = (char *)lua_tostring(L, -1); + lua_pop(L, 1); + } + arg2[j] = 0; + } else if (lua_isnil(L, 2)) { + // "nil" is also acceptable, equivalent as an empty table + arg2 = NULL; + } else { + return luaL_error(L, "A list of strings expected"); + } + } + arg3 = (uint32_t)lua_tointeger(L, 3); + arg4 = (uint32_t)lua_tointeger(L, 4); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByNames",5,SWIGTYPE_p_lldb__SBFileSpecList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByNames",6,SWIGTYPE_p_lldb__SBFileSpecList); + } + + result = (arg1)->BreakpointCreateByNames((char const **)arg2,arg3,arg4,(lldb::SBFileSpecList const &)*arg5,(lldb::SBFileSpecList const &)*arg6); + { + lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++; + } + { + free((char *) arg2); + } + return SWIG_arg; + + fail: SWIGUNUSED; + { + free((char *) arg2); + } + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_BreakpointCreateByNames__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char **arg2 = (char **) 0 ; + uint32_t arg3 ; + uint32_t arg4 ; + lldb::LanguageType arg5 ; + lldb::SBFileSpecList *arg6 = 0 ; + lldb::SBFileSpecList *arg7 = 0 ; + lldb::SBBreakpoint result; + + SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByNames",7,7) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",1,"lldb::SBTarget *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",3,"uint32_t"); + if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",4,"uint32_t"); + if(!lua_isinteger(L,5)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",5,"lldb::LanguageType"); + if(!lua_isuserdata(L,6)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",6,"lldb::SBFileSpecList const &"); + if(!lua_isuserdata(L,7)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",7,"lldb::SBFileSpecList const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByNames",1,SWIGTYPE_p_lldb__SBTarget); + } + + { + if (lua_istable(L, 2)) { + size_t size = lua_rawlen(L, 2); + arg2 = (char **)malloc((size + 1) * sizeof(char *)); + int i = 0, j = 0; + while (i++ < size) { + lua_rawgeti(L, 2, i); + if (!lua_isstring(L, -1)) { + // if current element cannot be converted to string, raise an error + lua_pop(L, 1); + return luaL_error(L, "List should only contain strings"); + } + arg2[j++] = (char *)lua_tostring(L, -1); + lua_pop(L, 1); + } + arg2[j] = 0; + } else if (lua_isnil(L, 2)) { + // "nil" is also acceptable, equivalent as an empty table + arg2 = NULL; + } else { + return luaL_error(L, "A list of strings expected"); + } + } + arg3 = (uint32_t)lua_tointeger(L, 3); + arg4 = (uint32_t)lua_tointeger(L, 4); + arg5 = (lldb::LanguageType)lua_tointeger(L, 5); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByNames",6,SWIGTYPE_p_lldb__SBFileSpecList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,7,(void**)&arg7,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByNames",7,SWIGTYPE_p_lldb__SBFileSpecList); + } + + result = (arg1)->BreakpointCreateByNames((char const **)arg2,arg3,arg4,arg5,(lldb::SBFileSpecList const &)*arg6,(lldb::SBFileSpecList const &)*arg7); + { + lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++; + } + { + free((char *) arg2); + } + return SWIG_arg; + + fail: SWIGUNUSED; + { + free((char *) arg2); + } + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_BreakpointCreateByNames__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char **arg2 = (char **) 0 ; + uint32_t arg3 ; + uint32_t arg4 ; + lldb::LanguageType arg5 ; + lldb::addr_t arg6 ; + lldb::SBFileSpecList *arg7 = 0 ; + lldb::SBFileSpecList *arg8 = 0 ; + lldb::SBBreakpoint result; + + SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByNames",8,8) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",1,"lldb::SBTarget *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",3,"uint32_t"); + if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",4,"uint32_t"); + if(!lua_isinteger(L,5)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",5,"lldb::LanguageType"); + if(!lua_isinteger(L,6)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",6,"lldb::addr_t"); + if(!lua_isuserdata(L,7)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",7,"lldb::SBFileSpecList const &"); + if(!lua_isuserdata(L,8)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByNames",8,"lldb::SBFileSpecList const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByNames",1,SWIGTYPE_p_lldb__SBTarget); + } + + { + if (lua_istable(L, 2)) { + size_t size = lua_rawlen(L, 2); + arg2 = (char **)malloc((size + 1) * sizeof(char *)); + int i = 0, j = 0; + while (i++ < size) { + lua_rawgeti(L, 2, i); + if (!lua_isstring(L, -1)) { + // if current element cannot be converted to string, raise an error + lua_pop(L, 1); + return luaL_error(L, "List should only contain strings"); + } + arg2[j++] = (char *)lua_tostring(L, -1); + lua_pop(L, 1); + } + arg2[j] = 0; + } else if (lua_isnil(L, 2)) { + // "nil" is also acceptable, equivalent as an empty table + arg2 = NULL; + } else { + return luaL_error(L, "A list of strings expected"); + } + } + arg3 = (uint32_t)lua_tointeger(L, 3); + arg4 = (uint32_t)lua_tointeger(L, 4); + arg5 = (lldb::LanguageType)lua_tointeger(L, 5); + arg6 = (lldb::addr_t)lua_tointeger(L, 6); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,7,(void**)&arg7,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByNames",7,SWIGTYPE_p_lldb__SBFileSpecList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,8,(void**)&arg8,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByNames",8,SWIGTYPE_p_lldb__SBFileSpecList); + } + + result = (arg1)->BreakpointCreateByNames((char const **)arg2,arg3,arg4,arg5,arg6,(lldb::SBFileSpecList const &)*arg7,(lldb::SBFileSpecList const &)*arg8); + { + lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++; + } + { + free((char *) arg2); + } + return SWIG_arg; + + fail: SWIGUNUSED; + { + free((char *) arg2); + } + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_BreakpointCreateByNames(lua_State* L) { + int argc; + int argv[9]={ + 1,2,3,4,5,6,7,8,9 + }; + + argc = lua_gettop(L); + if (argc == 6) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = (lua_istable(L, argv[1]) || lua_isnil(L, argv[1])); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[3]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[5])==0 || SWIG_ConvertPtr(L,argv[5], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBTarget_BreakpointCreateByNames__SWIG_0(L); + } + } + } + } + } + } + } + if (argc == 7) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = (lua_istable(L, argv[1]) || lua_isnil(L, argv[1])); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[3]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[4]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[5])==0 || SWIG_ConvertPtr(L,argv[5], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[6])==0 || SWIG_ConvertPtr(L,argv[6], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBTarget_BreakpointCreateByNames__SWIG_1(L); + } + } + } + } + } + } + } + } + if (argc == 8) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = (lua_istable(L, argv[1]) || lua_isnil(L, argv[1])); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[3]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[4]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[5]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[6])==0 || SWIG_ConvertPtr(L,argv[6], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[7])==0 || SWIG_ConvertPtr(L,argv[7], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBTarget_BreakpointCreateByNames__SWIG_2(L); + } + } + } + } + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBTarget_BreakpointCreateByRegex__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + lldb::SBBreakpoint result; + + SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByRegex",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByRegex",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByRegex",2,"char const *"); + if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByRegex",3,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByRegex",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (char *)lua_tostring(L, 3); + result = (arg1)->BreakpointCreateByRegex((char const *)arg2,(char const *)arg3); + { + lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_BreakpointCreateByRegex__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBBreakpoint result; + + SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByRegex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByRegex",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByRegex",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByRegex",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->BreakpointCreateByRegex((char const *)arg2); + { + lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_BreakpointCreateByRegex__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBFileSpecList *arg3 = 0 ; + lldb::SBFileSpecList *arg4 = 0 ; + lldb::SBBreakpoint result; + + SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByRegex",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByRegex",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByRegex",2,"char const *"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByRegex",3,"lldb::SBFileSpecList const &"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByRegex",4,"lldb::SBFileSpecList const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByRegex",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByRegex",3,SWIGTYPE_p_lldb__SBFileSpecList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByRegex",4,SWIGTYPE_p_lldb__SBFileSpecList); + } + + result = (arg1)->BreakpointCreateByRegex((char const *)arg2,(lldb::SBFileSpecList const &)*arg3,(lldb::SBFileSpecList const &)*arg4); + { + lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_BreakpointCreateByRegex__SWIG_3(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + lldb::LanguageType arg3 ; + lldb::SBFileSpecList *arg4 = 0 ; + lldb::SBFileSpecList *arg5 = 0 ; + lldb::SBBreakpoint result; + + SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByRegex",5,5) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByRegex",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByRegex",2,"char const *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByRegex",3,"lldb::LanguageType"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByRegex",4,"lldb::SBFileSpecList const &"); + if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByRegex",5,"lldb::SBFileSpecList const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByRegex",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (lldb::LanguageType)lua_tointeger(L, 3); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByRegex",4,SWIGTYPE_p_lldb__SBFileSpecList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByRegex",5,SWIGTYPE_p_lldb__SBFileSpecList); + } + + result = (arg1)->BreakpointCreateByRegex((char const *)arg2,arg3,(lldb::SBFileSpecList const &)*arg4,(lldb::SBFileSpecList const &)*arg5); + { + lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_BreakpointCreateByRegex(lua_State* L) { + int argc; + int argv[6]={ + 1,2,3,4,5,6 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + return _wrap_SBTarget_BreakpointCreateByRegex__SWIG_1(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[2]); + } + if (_v) { + return _wrap_SBTarget_BreakpointCreateByRegex__SWIG_0(L); + } + } + } + } + if (argc == 4) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBTarget_BreakpointCreateByRegex__SWIG_2(L); + } + } + } + } + } + if (argc == 5) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBTarget_BreakpointCreateByRegex__SWIG_3(L); + } + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBTarget_BreakpointCreateBySourceRegex__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBFileSpec *arg3 = 0 ; + char *arg4 = (char *) 0 ; + lldb::SBBreakpoint result; + + SWIG_check_num_args("lldb::SBTarget::BreakpointCreateBySourceRegex",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySourceRegex",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySourceRegex",2,"char const *"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySourceRegex",3,"lldb::SBFileSpec const &"); + if(!SWIG_lua_isnilstring(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySourceRegex",4,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateBySourceRegex",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateBySourceRegex",3,SWIGTYPE_p_lldb__SBFileSpec); + } + + arg4 = (char *)lua_tostring(L, 4); + result = (arg1)->BreakpointCreateBySourceRegex((char const *)arg2,(lldb::SBFileSpec const &)*arg3,(char const *)arg4); + { + lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_BreakpointCreateBySourceRegex__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBFileSpec *arg3 = 0 ; + lldb::SBBreakpoint result; + + SWIG_check_num_args("lldb::SBTarget::BreakpointCreateBySourceRegex",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySourceRegex",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySourceRegex",2,"char const *"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySourceRegex",3,"lldb::SBFileSpec const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateBySourceRegex",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateBySourceRegex",3,SWIGTYPE_p_lldb__SBFileSpec); + } + + result = (arg1)->BreakpointCreateBySourceRegex((char const *)arg2,(lldb::SBFileSpec const &)*arg3); + { + lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_BreakpointCreateBySourceRegex__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBFileSpecList *arg3 = 0 ; + lldb::SBFileSpecList *arg4 = 0 ; + lldb::SBBreakpoint result; + + SWIG_check_num_args("lldb::SBTarget::BreakpointCreateBySourceRegex",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySourceRegex",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySourceRegex",2,"char const *"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySourceRegex",3,"lldb::SBFileSpecList const &"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySourceRegex",4,"lldb::SBFileSpecList const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateBySourceRegex",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateBySourceRegex",3,SWIGTYPE_p_lldb__SBFileSpecList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateBySourceRegex",4,SWIGTYPE_p_lldb__SBFileSpecList); + } + + result = (arg1)->BreakpointCreateBySourceRegex((char const *)arg2,(lldb::SBFileSpecList const &)*arg3,(lldb::SBFileSpecList const &)*arg4); + { + lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_BreakpointCreateBySourceRegex__SWIG_3(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBFileSpecList *arg3 = 0 ; + lldb::SBFileSpecList *arg4 = 0 ; + lldb::SBStringList *arg5 = 0 ; + lldb::SBBreakpoint result; + + SWIG_check_num_args("lldb::SBTarget::BreakpointCreateBySourceRegex",5,5) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySourceRegex",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySourceRegex",2,"char const *"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySourceRegex",3,"lldb::SBFileSpecList const &"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySourceRegex",4,"lldb::SBFileSpecList const &"); + if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySourceRegex",5,"lldb::SBStringList const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateBySourceRegex",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateBySourceRegex",3,SWIGTYPE_p_lldb__SBFileSpecList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateBySourceRegex",4,SWIGTYPE_p_lldb__SBFileSpecList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_lldb__SBStringList,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateBySourceRegex",5,SWIGTYPE_p_lldb__SBStringList); + } + + result = (arg1)->BreakpointCreateBySourceRegex((char const *)arg2,(lldb::SBFileSpecList const &)*arg3,(lldb::SBFileSpecList const &)*arg4,(lldb::SBStringList const &)*arg5); + { + lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_BreakpointCreateBySourceRegex(lua_State* L) { + int argc; + int argv[6]={ + 1,2,3,4,5,6 + }; + + argc = lua_gettop(L); + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBTarget_BreakpointCreateBySourceRegex__SWIG_1(L); + } + } + } + } + if (argc == 4) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[3]); + } + if (_v) { + return _wrap_SBTarget_BreakpointCreateBySourceRegex__SWIG_0(L); + } + } + } + } + } + if (argc == 4) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBTarget_BreakpointCreateBySourceRegex__SWIG_2(L); + } + } + } + } + } + if (argc == 5) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_lldb__SBStringList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBTarget_BreakpointCreateBySourceRegex__SWIG_3(L); + } + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBTarget_BreakpointCreateForException(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::LanguageType arg2 ; + bool arg3 ; + bool arg4 ; + lldb::SBBreakpoint result; + + SWIG_check_num_args("lldb::SBTarget::BreakpointCreateForException",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateForException",1,"lldb::SBTarget *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateForException",2,"lldb::LanguageType"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateForException",3,"bool"); + if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateForException",4,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateForException",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (lldb::LanguageType)lua_tointeger(L, 2); + arg3 = (lua_toboolean(L, 3)!=0); + arg4 = (lua_toboolean(L, 4)!=0); + result = (arg1)->BreakpointCreateForException(arg2,arg3,arg4); + { + lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_BreakpointCreateByAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::addr_t arg2 ; + lldb::SBBreakpoint result; + + SWIG_check_num_args("lldb::SBTarget::BreakpointCreateByAddress",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByAddress",1,"lldb::SBTarget *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateByAddress",2,"lldb::addr_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateByAddress",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (lldb::addr_t)lua_tointeger(L, 2); + result = (arg1)->BreakpointCreateByAddress(arg2); + { + lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_BreakpointCreateBySBAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBAddress *arg2 = 0 ; + lldb::SBBreakpoint result; + + SWIG_check_num_args("lldb::SBTarget::BreakpointCreateBySBAddress",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySBAddress",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateBySBAddress",2,"lldb::SBAddress &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateBySBAddress",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateBySBAddress",2,SWIGTYPE_p_lldb__SBAddress); + } + + result = (arg1)->BreakpointCreateBySBAddress(*arg2); + { + lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_BreakpointCreateFromScript__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBStructuredData *arg3 = 0 ; + lldb::SBFileSpecList *arg4 = 0 ; + lldb::SBFileSpecList *arg5 = 0 ; + bool arg6 ; + lldb::SBBreakpoint result; + + SWIG_check_num_args("lldb::SBTarget::BreakpointCreateFromScript",6,6) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateFromScript",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateFromScript",2,"char const *"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateFromScript",3,"lldb::SBStructuredData &"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateFromScript",4,"lldb::SBFileSpecList const &"); + if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateFromScript",5,"lldb::SBFileSpecList const &"); + if(!lua_isboolean(L,6)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateFromScript",6,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateFromScript",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateFromScript",3,SWIGTYPE_p_lldb__SBStructuredData); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateFromScript",4,SWIGTYPE_p_lldb__SBFileSpecList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateFromScript",5,SWIGTYPE_p_lldb__SBFileSpecList); + } + + arg6 = (lua_toboolean(L, 6)!=0); + result = (arg1)->BreakpointCreateFromScript((char const *)arg2,*arg3,(lldb::SBFileSpecList const &)*arg4,(lldb::SBFileSpecList const &)*arg5,arg6); + { + lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_BreakpointCreateFromScript__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBStructuredData *arg3 = 0 ; + lldb::SBFileSpecList *arg4 = 0 ; + lldb::SBFileSpecList *arg5 = 0 ; + lldb::SBBreakpoint result; + + SWIG_check_num_args("lldb::SBTarget::BreakpointCreateFromScript",5,5) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateFromScript",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateFromScript",2,"char const *"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateFromScript",3,"lldb::SBStructuredData &"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateFromScript",4,"lldb::SBFileSpecList const &"); + if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBTarget::BreakpointCreateFromScript",5,"lldb::SBFileSpecList const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateFromScript",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateFromScript",3,SWIGTYPE_p_lldb__SBStructuredData); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateFromScript",4,SWIGTYPE_p_lldb__SBFileSpecList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_lldb__SBFileSpecList,0))){ + SWIG_fail_ptr("SBTarget_BreakpointCreateFromScript",5,SWIGTYPE_p_lldb__SBFileSpecList); + } + + result = (arg1)->BreakpointCreateFromScript((char const *)arg2,*arg3,(lldb::SBFileSpecList const &)*arg4,(lldb::SBFileSpecList const &)*arg5); + { + lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_BreakpointCreateFromScript(lua_State* L) { + int argc; + int argv[7]={ + 1,2,3,4,5,6,7 + }; + + argc = lua_gettop(L); + if (argc == 5) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBTarget_BreakpointCreateFromScript__SWIG_1(L); + } + } + } + } + } + } + if (argc == 6) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpecList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[5]); + } + if (_v) { + return _wrap_SBTarget_BreakpointCreateFromScript__SWIG_0(L); + } + } + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBTarget_BreakpointsCreateFromFile__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBFileSpec *arg2 = 0 ; + lldb::SBBreakpointList *arg3 = 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBTarget::BreakpointsCreateFromFile",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointsCreateFromFile",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointsCreateFromFile",2,"lldb::SBFileSpec &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointsCreateFromFile",3,"lldb::SBBreakpointList &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_BreakpointsCreateFromFile",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBTarget_BreakpointsCreateFromFile",2,SWIGTYPE_p_lldb__SBFileSpec); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBBreakpointList,0))){ + SWIG_fail_ptr("SBTarget_BreakpointsCreateFromFile",3,SWIGTYPE_p_lldb__SBBreakpointList); + } + + result = (arg1)->BreakpointsCreateFromFile(*arg2,*arg3); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_BreakpointsCreateFromFile__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBFileSpec *arg2 = 0 ; + lldb::SBStringList *arg3 = 0 ; + lldb::SBBreakpointList *arg4 = 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBTarget::BreakpointsCreateFromFile",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointsCreateFromFile",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointsCreateFromFile",2,"lldb::SBFileSpec &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointsCreateFromFile",3,"lldb::SBStringList &"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointsCreateFromFile",4,"lldb::SBBreakpointList &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_BreakpointsCreateFromFile",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBTarget_BreakpointsCreateFromFile",2,SWIGTYPE_p_lldb__SBFileSpec); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBStringList,0))){ + SWIG_fail_ptr("SBTarget_BreakpointsCreateFromFile",3,SWIGTYPE_p_lldb__SBStringList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBBreakpointList,0))){ + SWIG_fail_ptr("SBTarget_BreakpointsCreateFromFile",4,SWIGTYPE_p_lldb__SBBreakpointList); + } + + result = (arg1)->BreakpointsCreateFromFile(*arg2,*arg3,*arg4); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_BreakpointsCreateFromFile(lua_State* L) { + int argc; + int argv[5]={ + 1,2,3,4,5 + }; + + argc = lua_gettop(L); + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBBreakpointList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBTarget_BreakpointsCreateFromFile__SWIG_0(L); + } + } + } + } + if (argc == 4) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBStringList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBBreakpointList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBTarget_BreakpointsCreateFromFile__SWIG_1(L); + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBTarget_BreakpointsWriteToFile__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBFileSpec *arg2 = 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBTarget::BreakpointsWriteToFile",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointsWriteToFile",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointsWriteToFile",2,"lldb::SBFileSpec &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_BreakpointsWriteToFile",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBTarget_BreakpointsWriteToFile",2,SWIGTYPE_p_lldb__SBFileSpec); + } + + result = (arg1)->BreakpointsWriteToFile(*arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_BreakpointsWriteToFile__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBFileSpec *arg2 = 0 ; + lldb::SBBreakpointList *arg3 = 0 ; + bool arg4 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBTarget::BreakpointsWriteToFile",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointsWriteToFile",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointsWriteToFile",2,"lldb::SBFileSpec &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointsWriteToFile",3,"lldb::SBBreakpointList &"); + if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBTarget::BreakpointsWriteToFile",4,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_BreakpointsWriteToFile",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBTarget_BreakpointsWriteToFile",2,SWIGTYPE_p_lldb__SBFileSpec); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBBreakpointList,0))){ + SWIG_fail_ptr("SBTarget_BreakpointsWriteToFile",3,SWIGTYPE_p_lldb__SBBreakpointList); + } + + arg4 = (lua_toboolean(L, 4)!=0); + result = (arg1)->BreakpointsWriteToFile(*arg2,*arg3,arg4); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_BreakpointsWriteToFile__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBFileSpec *arg2 = 0 ; + lldb::SBBreakpointList *arg3 = 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBTarget::BreakpointsWriteToFile",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointsWriteToFile",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointsWriteToFile",2,"lldb::SBFileSpec &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::BreakpointsWriteToFile",3,"lldb::SBBreakpointList &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_BreakpointsWriteToFile",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBTarget_BreakpointsWriteToFile",2,SWIGTYPE_p_lldb__SBFileSpec); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBBreakpointList,0))){ + SWIG_fail_ptr("SBTarget_BreakpointsWriteToFile",3,SWIGTYPE_p_lldb__SBBreakpointList); + } + + result = (arg1)->BreakpointsWriteToFile(*arg2,*arg3); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_BreakpointsWriteToFile(lua_State* L) { + int argc; + int argv[5]={ + 1,2,3,4,5 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBTarget_BreakpointsWriteToFile__SWIG_0(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBBreakpointList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBTarget_BreakpointsWriteToFile__SWIG_2(L); + } + } + } + } + if (argc == 4) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBBreakpointList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[3]); + } + if (_v) { + return _wrap_SBTarget_BreakpointsWriteToFile__SWIG_1(L); + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBTarget_GetNumBreakpoints(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBTarget::GetNumBreakpoints",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetNumBreakpoints",1,"lldb::SBTarget const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_GetNumBreakpoints",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = (uint32_t)((lldb::SBTarget const *)arg1)->GetNumBreakpoints(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_GetBreakpointAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + uint32_t arg2 ; + lldb::SBBreakpoint result; + + SWIG_check_num_args("lldb::SBTarget::GetBreakpointAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetBreakpointAtIndex",1,"lldb::SBTarget const *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTarget::GetBreakpointAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_GetBreakpointAtIndex",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = ((lldb::SBTarget const *)arg1)->GetBreakpointAtIndex(arg2); + { + lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_BreakpointDelete(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::break_id_t arg2 ; + bool result; + + SWIG_check_num_args("lldb::SBTarget::BreakpointDelete",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::BreakpointDelete",1,"lldb::SBTarget *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTarget::BreakpointDelete",2,"lldb::break_id_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_BreakpointDelete",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (lldb::break_id_t)lua_tointeger(L, 2); + result = (bool)(arg1)->BreakpointDelete(arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_FindBreakpointByID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::break_id_t arg2 ; + lldb::SBBreakpoint result; + + SWIG_check_num_args("lldb::SBTarget::FindBreakpointByID",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::FindBreakpointByID",1,"lldb::SBTarget *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTarget::FindBreakpointByID",2,"lldb::break_id_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_FindBreakpointByID",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (lldb::break_id_t)lua_tointeger(L, 2); + result = (arg1)->FindBreakpointByID(arg2); + { + lldb::SBBreakpoint * resultptr = new lldb::SBBreakpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBreakpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_FindBreakpointsByName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBBreakpointList *arg3 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTarget::FindBreakpointsByName",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::FindBreakpointsByName",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::FindBreakpointsByName",2,"char const *"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::FindBreakpointsByName",3,"lldb::SBBreakpointList &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_FindBreakpointsByName",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBBreakpointList,0))){ + SWIG_fail_ptr("SBTarget_FindBreakpointsByName",3,SWIGTYPE_p_lldb__SBBreakpointList); + } + + result = (bool)(arg1)->FindBreakpointsByName((char const *)arg2,*arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_GetBreakpointNames(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBStringList *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBTarget::GetBreakpointNames",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetBreakpointNames",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::GetBreakpointNames",2,"lldb::SBStringList &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_GetBreakpointNames",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStringList,0))){ + SWIG_fail_ptr("SBTarget_GetBreakpointNames",2,SWIGTYPE_p_lldb__SBStringList); + } + + (arg1)->GetBreakpointNames(*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_DeleteBreakpointName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBTarget::DeleteBreakpointName",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::DeleteBreakpointName",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::DeleteBreakpointName",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_DeleteBreakpointName",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->DeleteBreakpointName((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_EnableAllBreakpoints(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTarget::EnableAllBreakpoints",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::EnableAllBreakpoints",1,"lldb::SBTarget *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_EnableAllBreakpoints",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = (bool)(arg1)->EnableAllBreakpoints(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_DisableAllBreakpoints(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTarget::DisableAllBreakpoints",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::DisableAllBreakpoints",1,"lldb::SBTarget *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_DisableAllBreakpoints",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = (bool)(arg1)->DisableAllBreakpoints(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_DeleteAllBreakpoints(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTarget::DeleteAllBreakpoints",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::DeleteAllBreakpoints",1,"lldb::SBTarget *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_DeleteAllBreakpoints",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = (bool)(arg1)->DeleteAllBreakpoints(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_GetNumWatchpoints(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBTarget::GetNumWatchpoints",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetNumWatchpoints",1,"lldb::SBTarget const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_GetNumWatchpoints",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = (uint32_t)((lldb::SBTarget const *)arg1)->GetNumWatchpoints(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_GetWatchpointAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + uint32_t arg2 ; + lldb::SBWatchpoint result; + + SWIG_check_num_args("lldb::SBTarget::GetWatchpointAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetWatchpointAtIndex",1,"lldb::SBTarget const *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTarget::GetWatchpointAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_GetWatchpointAtIndex",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = ((lldb::SBTarget const *)arg1)->GetWatchpointAtIndex(arg2); + { + lldb::SBWatchpoint * resultptr = new lldb::SBWatchpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBWatchpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_DeleteWatchpoint(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::watch_id_t arg2 ; + bool result; + + SWIG_check_num_args("lldb::SBTarget::DeleteWatchpoint",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::DeleteWatchpoint",1,"lldb::SBTarget *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTarget::DeleteWatchpoint",2,"lldb::watch_id_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_DeleteWatchpoint",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (lldb::watch_id_t)lua_tointeger(L, 2); + result = (bool)(arg1)->DeleteWatchpoint(arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_FindWatchpointByID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::watch_id_t arg2 ; + lldb::SBWatchpoint result; + + SWIG_check_num_args("lldb::SBTarget::FindWatchpointByID",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::FindWatchpointByID",1,"lldb::SBTarget *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTarget::FindWatchpointByID",2,"lldb::watch_id_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_FindWatchpointByID",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (lldb::watch_id_t)lua_tointeger(L, 2); + result = (arg1)->FindWatchpointByID(arg2); + { + lldb::SBWatchpoint * resultptr = new lldb::SBWatchpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBWatchpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_WatchAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::addr_t arg2 ; + size_t arg3 ; + bool arg4 ; + bool arg5 ; + lldb::SBError *arg6 = 0 ; + lldb::SBWatchpoint result; + + SWIG_check_num_args("lldb::SBTarget::WatchAddress",6,6) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::WatchAddress",1,"lldb::SBTarget *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTarget::WatchAddress",2,"lldb::addr_t"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::WatchAddress",3,"size_t"); + if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBTarget::WatchAddress",4,"bool"); + if(!lua_isboolean(L,5)) SWIG_fail_arg("lldb::SBTarget::WatchAddress",5,"bool"); + if(!lua_isuserdata(L,6)) SWIG_fail_arg("lldb::SBTarget::WatchAddress",6,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_WatchAddress",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (lldb::addr_t)lua_tointeger(L, 2); + arg3 = (size_t)lua_tointeger(L, 3); + arg4 = (lua_toboolean(L, 4)!=0); + arg5 = (lua_toboolean(L, 5)!=0); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBTarget_WatchAddress",6,SWIGTYPE_p_lldb__SBError); + } + + result = (arg1)->WatchAddress(arg2,arg3,arg4,arg5,*arg6); + { + lldb::SBWatchpoint * resultptr = new lldb::SBWatchpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBWatchpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_WatchpointCreateByAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::addr_t arg2 ; + size_t arg3 ; + lldb::SBWatchpointOptions arg4 ; + lldb::SBError *arg5 = 0 ; + lldb::SBWatchpointOptions *argp4 ; + lldb::SBWatchpoint result; + + SWIG_check_num_args("lldb::SBTarget::WatchpointCreateByAddress",5,5) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::WatchpointCreateByAddress",1,"lldb::SBTarget *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTarget::WatchpointCreateByAddress",2,"lldb::addr_t"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::WatchpointCreateByAddress",3,"size_t"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBTarget::WatchpointCreateByAddress",4,"lldb::SBWatchpointOptions"); + if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBTarget::WatchpointCreateByAddress",5,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_WatchpointCreateByAddress",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (lldb::addr_t)lua_tointeger(L, 2); + arg3 = (size_t)lua_tointeger(L, 3); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_lldb__SBWatchpointOptions,0))){ + SWIG_fail_ptr("SBTarget_WatchpointCreateByAddress",4,SWIGTYPE_p_lldb__SBWatchpointOptions); + } + arg4 = *argp4; + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBTarget_WatchpointCreateByAddress",5,SWIGTYPE_p_lldb__SBError); + } + + result = (arg1)->WatchpointCreateByAddress(arg2,arg3,arg4,*arg5); + { + lldb::SBWatchpoint * resultptr = new lldb::SBWatchpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBWatchpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_EnableAllWatchpoints(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTarget::EnableAllWatchpoints",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::EnableAllWatchpoints",1,"lldb::SBTarget *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_EnableAllWatchpoints",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = (bool)(arg1)->EnableAllWatchpoints(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_DisableAllWatchpoints(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTarget::DisableAllWatchpoints",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::DisableAllWatchpoints",1,"lldb::SBTarget *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_DisableAllWatchpoints",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = (bool)(arg1)->DisableAllWatchpoints(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_DeleteAllWatchpoints(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTarget::DeleteAllWatchpoints",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::DeleteAllWatchpoints",1,"lldb::SBTarget *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_DeleteAllWatchpoints",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = (bool)(arg1)->DeleteAllWatchpoints(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_GetBroadcaster(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBBroadcaster result; + + SWIG_check_num_args("lldb::SBTarget::GetBroadcaster",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetBroadcaster",1,"lldb::SBTarget const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_GetBroadcaster",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = ((lldb::SBTarget const *)arg1)->GetBroadcaster(); + { + lldb::SBBroadcaster * resultptr = new lldb::SBBroadcaster(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBBroadcaster,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_FindFirstType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBType result; + + SWIG_check_num_args("lldb::SBTarget::FindFirstType",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::FindFirstType",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::FindFirstType",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_FindFirstType",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->FindFirstType((char const *)arg2); + { + lldb::SBType * resultptr = new lldb::SBType(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_FindTypes(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBTypeList result; + + SWIG_check_num_args("lldb::SBTarget::FindTypes",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::FindTypes",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::FindTypes",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_FindTypes",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->FindTypes((char const *)arg2); + { + lldb::SBTypeList * resultptr = new lldb::SBTypeList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_GetBasicType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::BasicType arg2 ; + lldb::SBType result; + + SWIG_check_num_args("lldb::SBTarget::GetBasicType",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetBasicType",1,"lldb::SBTarget *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTarget::GetBasicType",2,"lldb::BasicType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_GetBasicType",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (lldb::BasicType)lua_tointeger(L, 2); + result = (arg1)->GetBasicType(arg2); + { + lldb::SBType * resultptr = new lldb::SBType(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_CreateValueFromAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBAddress arg3 ; + lldb::SBType arg4 ; + lldb::SBAddress *argp3 ; + lldb::SBType *argp4 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBTarget::CreateValueFromAddress",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::CreateValueFromAddress",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::CreateValueFromAddress",2,"char const *"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::CreateValueFromAddress",3,"lldb::SBAddress"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBTarget::CreateValueFromAddress",4,"lldb::SBType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_CreateValueFromAddress",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBTarget_CreateValueFromAddress",3,SWIGTYPE_p_lldb__SBAddress); + } + arg3 = *argp3; + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBTarget_CreateValueFromAddress",4,SWIGTYPE_p_lldb__SBType); + } + arg4 = *argp4; + + result = (arg1)->CreateValueFromAddress((char const *)arg2,arg3,arg4); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_CreateValueFromData(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBData arg3 ; + lldb::SBType arg4 ; + lldb::SBData *argp3 ; + lldb::SBType *argp4 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBTarget::CreateValueFromData",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::CreateValueFromData",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::CreateValueFromData",2,"char const *"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::CreateValueFromData",3,"lldb::SBData"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBTarget::CreateValueFromData",4,"lldb::SBType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_CreateValueFromData",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBTarget_CreateValueFromData",3,SWIGTYPE_p_lldb__SBData); + } + arg3 = *argp3; + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBTarget_CreateValueFromData",4,SWIGTYPE_p_lldb__SBType); + } + arg4 = *argp4; + + result = (arg1)->CreateValueFromData((char const *)arg2,arg3,arg4); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_CreateValueFromExpression(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBTarget::CreateValueFromExpression",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::CreateValueFromExpression",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::CreateValueFromExpression",2,"char const *"); + if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBTarget::CreateValueFromExpression",3,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_CreateValueFromExpression",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (char *)lua_tostring(L, 3); + result = (arg1)->CreateValueFromExpression((char const *)arg2,(char const *)arg3); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_GetSourceManager(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + SwigValueWrapper< lldb::SBSourceManager > result; + + SWIG_check_num_args("lldb::SBTarget::GetSourceManager",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetSourceManager",1,"lldb::SBTarget *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_GetSourceManager",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = (arg1)->GetSourceManager(); + { + lldb::SBSourceManager * resultptr = new lldb::SBSourceManager(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSourceManager,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_ReadInstructions__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBAddress arg2 ; + uint32_t arg3 ; + lldb::SBAddress *argp2 ; + lldb::SBInstructionList result; + + SWIG_check_num_args("lldb::SBTarget::ReadInstructions",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::ReadInstructions",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::ReadInstructions",2,"lldb::SBAddress"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::ReadInstructions",3,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_ReadInstructions",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBTarget_ReadInstructions",2,SWIGTYPE_p_lldb__SBAddress); + } + arg2 = *argp2; + + arg3 = (uint32_t)lua_tointeger(L, 3); + result = (arg1)->ReadInstructions(arg2,arg3); + { + lldb::SBInstructionList * resultptr = new lldb::SBInstructionList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBInstructionList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_ReadInstructions__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBAddress arg2 ; + uint32_t arg3 ; + char *arg4 = (char *) 0 ; + lldb::SBAddress *argp2 ; + lldb::SBInstructionList result; + + SWIG_check_num_args("lldb::SBTarget::ReadInstructions",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::ReadInstructions",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::ReadInstructions",2,"lldb::SBAddress"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::ReadInstructions",3,"uint32_t"); + if(!SWIG_lua_isnilstring(L,4)) SWIG_fail_arg("lldb::SBTarget::ReadInstructions",4,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_ReadInstructions",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBTarget_ReadInstructions",2,SWIGTYPE_p_lldb__SBAddress); + } + arg2 = *argp2; + + arg3 = (uint32_t)lua_tointeger(L, 3); + arg4 = (char *)lua_tostring(L, 4); + result = (arg1)->ReadInstructions(arg2,arg3,(char const *)arg4); + { + lldb::SBInstructionList * resultptr = new lldb::SBInstructionList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBInstructionList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_ReadInstructions__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBAddress arg2 ; + lldb::SBAddress arg3 ; + char *arg4 = (char *) 0 ; + lldb::SBAddress *argp2 ; + lldb::SBAddress *argp3 ; + lldb::SBInstructionList result; + + SWIG_check_num_args("lldb::SBTarget::ReadInstructions",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::ReadInstructions",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::ReadInstructions",2,"lldb::SBAddress"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::ReadInstructions",3,"lldb::SBAddress"); + if(!SWIG_lua_isnilstring(L,4)) SWIG_fail_arg("lldb::SBTarget::ReadInstructions",4,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_ReadInstructions",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBTarget_ReadInstructions",2,SWIGTYPE_p_lldb__SBAddress); + } + arg2 = *argp2; + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBTarget_ReadInstructions",3,SWIGTYPE_p_lldb__SBAddress); + } + arg3 = *argp3; + + arg4 = (char *)lua_tostring(L, 4); + result = (arg1)->ReadInstructions(arg2,arg3,(char const *)arg4); + { + lldb::SBInstructionList * resultptr = new lldb::SBInstructionList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBInstructionList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_ReadInstructions(lua_State* L) { + int argc; + int argv[5]={ + 1,2,3,4,5 + }; + + argc = lua_gettop(L); + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + return _wrap_SBTarget_ReadInstructions__SWIG_0(L); + } + } + } + } + if (argc == 4) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[3]); + } + if (_v) { + return _wrap_SBTarget_ReadInstructions__SWIG_2(L); + } + } + } + } + } + if (argc == 4) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[3]); + } + if (_v) { + return _wrap_SBTarget_ReadInstructions__SWIG_1(L); + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBTarget_GetInstructions(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBAddress arg2 ; + void *arg3 = (void *) 0 ; + size_t arg4 ; + lldb::SBAddress *argp2 ; + lldb::SBInstructionList result; + + SWIG_check_num_args("lldb::SBTarget::GetInstructions",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetInstructions",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::GetInstructions",2,"lldb::SBAddress"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_GetInstructions",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBTarget_GetInstructions",2,SWIGTYPE_p_lldb__SBAddress); + } + arg2 = *argp2; + + { + arg3 = (void *)luaL_checklstring(L, 3, &arg4); + } + result = (arg1)->GetInstructions(arg2,(void const *)arg3,arg4); + { + lldb::SBInstructionList * resultptr = new lldb::SBInstructionList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBInstructionList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_GetInstructionsWithFlavor(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBAddress arg2 ; + char *arg3 = (char *) 0 ; + void *arg4 = (void *) 0 ; + size_t arg5 ; + lldb::SBAddress *argp2 ; + lldb::SBInstructionList result; + + SWIG_check_num_args("lldb::SBTarget::GetInstructionsWithFlavor",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetInstructionsWithFlavor",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::GetInstructionsWithFlavor",2,"lldb::SBAddress"); + if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBTarget::GetInstructionsWithFlavor",3,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_GetInstructionsWithFlavor",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBTarget_GetInstructionsWithFlavor",2,SWIGTYPE_p_lldb__SBAddress); + } + arg2 = *argp2; + + arg3 = (char *)lua_tostring(L, 3); + { + arg4 = (void *)luaL_checklstring(L, 4, &arg5); + } + result = (arg1)->GetInstructionsWithFlavor(arg2,(char const *)arg3,(void const *)arg4,arg5); + { + lldb::SBInstructionList * resultptr = new lldb::SBInstructionList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBInstructionList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_FindSymbols__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SymbolType arg3 ; + lldb::SBSymbolContextList result; + + SWIG_check_num_args("lldb::SBTarget::FindSymbols",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::FindSymbols",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::FindSymbols",2,"char const *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::FindSymbols",3,"lldb::SymbolType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_FindSymbols",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (lldb::SymbolType)lua_tointeger(L, 3); + result = (arg1)->FindSymbols((char const *)arg2,arg3); + { + lldb::SBSymbolContextList * resultptr = new lldb::SBSymbolContextList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbolContextList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_FindSymbols__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBSymbolContextList result; + + SWIG_check_num_args("lldb::SBTarget::FindSymbols",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::FindSymbols",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::FindSymbols",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_FindSymbols",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->FindSymbols((char const *)arg2); + { + lldb::SBSymbolContextList * resultptr = new lldb::SBSymbolContextList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBSymbolContextList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_FindSymbols(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + return _wrap_SBTarget_FindSymbols__SWIG_1(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + return _wrap_SBTarget_FindSymbols__SWIG_0(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBTarget___eq(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTarget *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTarget::operator ==",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::operator ==",1,"lldb::SBTarget const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::operator ==",2,"lldb::SBTarget const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget___eq",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget___eq",2,SWIGTYPE_p_lldb__SBTarget); + } + + result = (bool)((lldb::SBTarget const *)arg1)->operator ==((lldb::SBTarget const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBStream *arg2 = 0 ; + lldb::DescriptionLevel arg3 ; + bool result; + + SWIG_check_num_args("lldb::SBTarget::GetDescription",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetDescription",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::GetDescription",2,"lldb::SBStream &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTarget::GetDescription",3,"lldb::DescriptionLevel"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_GetDescription",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBTarget_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + arg3 = (lldb::DescriptionLevel)lua_tointeger(L, 3); + result = (bool)(arg1)->GetDescription(*arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_EvaluateExpression__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBTarget::EvaluateExpression",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::EvaluateExpression",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::EvaluateExpression",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_EvaluateExpression",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->EvaluateExpression((char const *)arg2); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_EvaluateExpression__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBExpressionOptions *arg3 = 0 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBTarget::EvaluateExpression",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::EvaluateExpression",1,"lldb::SBTarget *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTarget::EvaluateExpression",2,"char const *"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTarget::EvaluateExpression",3,"lldb::SBExpressionOptions const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_EvaluateExpression",1,SWIGTYPE_p_lldb__SBTarget); + } + + arg2 = (char *)lua_tostring(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBTarget_EvaluateExpression",3,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + result = (arg1)->EvaluateExpression((char const *)arg2,(lldb::SBExpressionOptions const &)*arg3); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_EvaluateExpression(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + return _wrap_SBTarget_EvaluateExpression__SWIG_0(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTarget, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBTarget_EvaluateExpression__SWIG_1(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBTarget_GetStackRedZoneSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::addr_t result; + + SWIG_check_num_args("lldb::SBTarget::GetStackRedZoneSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetStackRedZoneSize",1,"lldb::SBTarget *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_GetStackRedZoneSize",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = (lldb::addr_t)(arg1)->GetStackRedZoneSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_IsLoaded(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBModule *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTarget::IsLoaded",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::IsLoaded",1,"lldb::SBTarget const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::IsLoaded",2,"lldb::SBModule const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_IsLoaded",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBModule,0))){ + SWIG_fail_ptr("SBTarget_IsLoaded",2,SWIGTYPE_p_lldb__SBModule); + } + + result = (bool)((lldb::SBTarget const *)arg1)->IsLoaded((lldb::SBModule const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_GetLaunchInfo(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + SwigValueWrapper< lldb::SBLaunchInfo > result; + + SWIG_check_num_args("lldb::SBTarget::GetLaunchInfo",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetLaunchInfo",1,"lldb::SBTarget const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_GetLaunchInfo",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = ((lldb::SBTarget const *)arg1)->GetLaunchInfo(); + { + lldb::SBLaunchInfo * resultptr = new lldb::SBLaunchInfo(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBLaunchInfo,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_SetLaunchInfo(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBLaunchInfo *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBTarget::SetLaunchInfo",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::SetLaunchInfo",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::SetLaunchInfo",2,"lldb::SBLaunchInfo const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_SetLaunchInfo",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBLaunchInfo,0))){ + SWIG_fail_ptr("SBTarget_SetLaunchInfo",2,SWIGTYPE_p_lldb__SBLaunchInfo); + } + + (arg1)->SetLaunchInfo((lldb::SBLaunchInfo const &)*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_GetTrace(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBTrace result; + + SWIG_check_num_args("lldb::SBTarget::GetTrace",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::GetTrace",1,"lldb::SBTarget *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_GetTrace",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = (arg1)->GetTrace(); + { + lldb::SBTrace * resultptr = new lldb::SBTrace(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTrace,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget_CreateTrace(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + lldb::SBError *arg2 = 0 ; + lldb::SBTrace result; + + SWIG_check_num_args("lldb::SBTarget::CreateTrace",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::CreateTrace",1,"lldb::SBTarget *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTarget::CreateTrace",2,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget_CreateTrace",1,SWIGTYPE_p_lldb__SBTarget); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBTarget_CreateTrace",2,SWIGTYPE_p_lldb__SBError); + } + + result = (arg1)->CreateTrace(*arg2); + { + lldb::SBTrace * resultptr = new lldb::SBTrace(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTrace,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTarget___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTarget *arg1 = (lldb::SBTarget *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBTarget::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTarget::__repr__",1,"lldb::SBTarget *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTarget___tostring",1,SWIGTYPE_p_lldb__SBTarget); + } + + result = lldb_SBTarget___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBTarget(void *obj) { +lldb::SBTarget *arg1 = (lldb::SBTarget *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBTarget(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBTarget); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBTarget_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBTarget_methods[]= { + { "IsValid", _wrap_SBTarget_IsValid}, + { "GetProcess", _wrap_SBTarget_GetProcess}, + { "SetCollectingStats", _wrap_SBTarget_SetCollectingStats}, + { "GetCollectingStats", _wrap_SBTarget_GetCollectingStats}, + { "GetStatistics", _wrap_SBTarget_GetStatistics}, + { "GetPlatform", _wrap_SBTarget_GetPlatform}, + { "GetEnvironment", _wrap_SBTarget_GetEnvironment}, + { "Install", _wrap_SBTarget_Install}, + { "LoadCore", _wrap_SBTarget_LoadCore}, + { "LaunchSimple", _wrap_SBTarget_LaunchSimple}, + { "Launch", _wrap_SBTarget_Launch}, + { "Attach", _wrap_SBTarget_Attach}, + { "AttachToProcessWithID", _wrap_SBTarget_AttachToProcessWithID}, + { "AttachToProcessWithName", _wrap_SBTarget_AttachToProcessWithName}, + { "ConnectRemote", _wrap_SBTarget_ConnectRemote}, + { "GetExecutable", _wrap_SBTarget_GetExecutable}, + { "AppendImageSearchPath", _wrap_SBTarget_AppendImageSearchPath}, + { "AddModule", _wrap_SBTarget_AddModule}, + { "GetNumModules", _wrap_SBTarget_GetNumModules}, + { "GetModuleAtIndex", _wrap_SBTarget_GetModuleAtIndex}, + { "RemoveModule", _wrap_SBTarget_RemoveModule}, + { "GetDebugger", _wrap_SBTarget_GetDebugger}, + { "FindModule", _wrap_SBTarget_FindModule}, + { "FindCompileUnits", _wrap_SBTarget_FindCompileUnits}, + { "GetByteOrder", _wrap_SBTarget_GetByteOrder}, + { "GetAddressByteSize", _wrap_SBTarget_GetAddressByteSize}, + { "GetTriple", _wrap_SBTarget_GetTriple}, + { "GetABIName", _wrap_SBTarget_GetABIName}, + { "GetLabel", _wrap_SBTarget_GetLabel}, + { "SetLabel", _wrap_SBTarget_SetLabel}, + { "GetDataByteSize", _wrap_SBTarget_GetDataByteSize}, + { "GetCodeByteSize", _wrap_SBTarget_GetCodeByteSize}, + { "GetMaximumNumberOfChildrenToDisplay", _wrap_SBTarget_GetMaximumNumberOfChildrenToDisplay}, + { "SetSectionLoadAddress", _wrap_SBTarget_SetSectionLoadAddress}, + { "ClearSectionLoadAddress", _wrap_SBTarget_ClearSectionLoadAddress}, + { "SetModuleLoadAddress", _wrap_SBTarget_SetModuleLoadAddress}, + { "ClearModuleLoadAddress", _wrap_SBTarget_ClearModuleLoadAddress}, + { "FindFunctions", _wrap_SBTarget_FindFunctions}, + { "FindFirstGlobalVariable", _wrap_SBTarget_FindFirstGlobalVariable}, + { "FindGlobalVariables", _wrap_SBTarget_FindGlobalVariables}, + { "FindGlobalFunctions", _wrap_SBTarget_FindGlobalFunctions}, + { "Clear", _wrap_SBTarget_Clear}, + { "ResolveFileAddress", _wrap_SBTarget_ResolveFileAddress}, + { "ResolveLoadAddress", _wrap_SBTarget_ResolveLoadAddress}, + { "ResolvePastLoadAddress", _wrap_SBTarget_ResolvePastLoadAddress}, + { "ResolveSymbolContextForAddress", _wrap_SBTarget_ResolveSymbolContextForAddress}, + { "ReadMemory", _wrap_SBTarget_ReadMemory}, + { "BreakpointCreateByLocation", _wrap_SBTarget_BreakpointCreateByLocation}, + { "BreakpointCreateByName", _wrap_SBTarget_BreakpointCreateByName}, + { "BreakpointCreateByNames", _wrap_SBTarget_BreakpointCreateByNames}, + { "BreakpointCreateByRegex", _wrap_SBTarget_BreakpointCreateByRegex}, + { "BreakpointCreateBySourceRegex", _wrap_SBTarget_BreakpointCreateBySourceRegex}, + { "BreakpointCreateForException", _wrap_SBTarget_BreakpointCreateForException}, + { "BreakpointCreateByAddress", _wrap_SBTarget_BreakpointCreateByAddress}, + { "BreakpointCreateBySBAddress", _wrap_SBTarget_BreakpointCreateBySBAddress}, + { "BreakpointCreateFromScript", _wrap_SBTarget_BreakpointCreateFromScript}, + { "BreakpointsCreateFromFile", _wrap_SBTarget_BreakpointsCreateFromFile}, + { "BreakpointsWriteToFile", _wrap_SBTarget_BreakpointsWriteToFile}, + { "GetNumBreakpoints", _wrap_SBTarget_GetNumBreakpoints}, + { "GetBreakpointAtIndex", _wrap_SBTarget_GetBreakpointAtIndex}, + { "BreakpointDelete", _wrap_SBTarget_BreakpointDelete}, + { "FindBreakpointByID", _wrap_SBTarget_FindBreakpointByID}, + { "FindBreakpointsByName", _wrap_SBTarget_FindBreakpointsByName}, + { "GetBreakpointNames", _wrap_SBTarget_GetBreakpointNames}, + { "DeleteBreakpointName", _wrap_SBTarget_DeleteBreakpointName}, + { "EnableAllBreakpoints", _wrap_SBTarget_EnableAllBreakpoints}, + { "DisableAllBreakpoints", _wrap_SBTarget_DisableAllBreakpoints}, + { "DeleteAllBreakpoints", _wrap_SBTarget_DeleteAllBreakpoints}, + { "GetNumWatchpoints", _wrap_SBTarget_GetNumWatchpoints}, + { "GetWatchpointAtIndex", _wrap_SBTarget_GetWatchpointAtIndex}, + { "DeleteWatchpoint", _wrap_SBTarget_DeleteWatchpoint}, + { "FindWatchpointByID", _wrap_SBTarget_FindWatchpointByID}, + { "WatchAddress", _wrap_SBTarget_WatchAddress}, + { "WatchpointCreateByAddress", _wrap_SBTarget_WatchpointCreateByAddress}, + { "EnableAllWatchpoints", _wrap_SBTarget_EnableAllWatchpoints}, + { "DisableAllWatchpoints", _wrap_SBTarget_DisableAllWatchpoints}, + { "DeleteAllWatchpoints", _wrap_SBTarget_DeleteAllWatchpoints}, + { "GetBroadcaster", _wrap_SBTarget_GetBroadcaster}, + { "FindFirstType", _wrap_SBTarget_FindFirstType}, + { "FindTypes", _wrap_SBTarget_FindTypes}, + { "GetBasicType", _wrap_SBTarget_GetBasicType}, + { "CreateValueFromAddress", _wrap_SBTarget_CreateValueFromAddress}, + { "CreateValueFromData", _wrap_SBTarget_CreateValueFromData}, + { "CreateValueFromExpression", _wrap_SBTarget_CreateValueFromExpression}, + { "GetSourceManager", _wrap_SBTarget_GetSourceManager}, + { "ReadInstructions", _wrap_SBTarget_ReadInstructions}, + { "GetInstructions", _wrap_SBTarget_GetInstructions}, + { "GetInstructionsWithFlavor", _wrap_SBTarget_GetInstructionsWithFlavor}, + { "FindSymbols", _wrap_SBTarget_FindSymbols}, + { "__eq", _wrap_SBTarget___eq}, + { "GetDescription", _wrap_SBTarget_GetDescription}, + { "EvaluateExpression", _wrap_SBTarget_EvaluateExpression}, + { "GetStackRedZoneSize", _wrap_SBTarget_GetStackRedZoneSize}, + { "IsLoaded", _wrap_SBTarget_IsLoaded}, + { "GetLaunchInfo", _wrap_SBTarget_GetLaunchInfo}, + { "SetLaunchInfo", _wrap_SBTarget_SetLaunchInfo}, + { "GetTrace", _wrap_SBTarget_GetTrace}, + { "CreateTrace", _wrap_SBTarget_CreateTrace}, + { "__tostring", _wrap_SBTarget___tostring}, + {0,0} +}; +static swig_lua_method swig_SBTarget_meta[] = { + { "__eq", _wrap_SBTarget___eq}, + { "__tostring", _wrap_SBTarget___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBTarget_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBTarget_Sf_SwigStatic_constants[]= { + {SWIG_LUA_CONSTTAB_INT("eBroadcastBitBreakpointChanged", (lldb::SBTarget::eBroadcastBitBreakpointChanged))}, + {SWIG_LUA_CONSTTAB_INT("eBroadcastBitModulesLoaded", (lldb::SBTarget::eBroadcastBitModulesLoaded))}, + {SWIG_LUA_CONSTTAB_INT("eBroadcastBitModulesUnloaded", (lldb::SBTarget::eBroadcastBitModulesUnloaded))}, + {SWIG_LUA_CONSTTAB_INT("eBroadcastBitWatchpointChanged", (lldb::SBTarget::eBroadcastBitWatchpointChanged))}, + {SWIG_LUA_CONSTTAB_INT("eBroadcastBitSymbolsLoaded", (lldb::SBTarget::eBroadcastBitSymbolsLoaded))}, + {SWIG_LUA_CONSTTAB_INT("eBroadcastBitSymbolsChanged", (lldb::SBTarget::eBroadcastBitSymbolsChanged))}, + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBTarget_Sf_SwigStatic_methods[]= { + { "EventIsTargetEvent", _wrap_SBTarget_EventIsTargetEvent}, + { "GetTargetFromEvent", _wrap_SBTarget_GetTargetFromEvent}, + { "GetNumModulesFromEvent", _wrap_SBTarget_GetNumModulesFromEvent}, + { "GetModuleAtIndexFromEvent", _wrap_SBTarget_GetModuleAtIndexFromEvent}, + { "GetBroadcasterClassName", _wrap_SBTarget_GetBroadcasterClassName}, + {0,0} +}; +static swig_lua_class* swig_SBTarget_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBTarget_Sf_SwigStatic = { + "SBTarget", + swig_SBTarget_Sf_SwigStatic_methods, + swig_SBTarget_Sf_SwigStatic_attributes, + swig_SBTarget_Sf_SwigStatic_constants, + swig_SBTarget_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBTarget_bases[] = {0}; +static const char *swig_SBTarget_base_names[] = {0}; +static swig_lua_class _wrap_class_SBTarget = { "SBTarget", "SBTarget", &SWIGTYPE_p_lldb__SBTarget,_proxy__wrap_new_SBTarget, swig_delete_SBTarget, swig_SBTarget_methods, swig_SBTarget_attributes, &swig_SBTarget_Sf_SwigStatic, swig_SBTarget_meta, swig_SBTarget_bases, swig_SBTarget_base_names }; + +static int _wrap_SBThread_GetBroadcasterClassName(lua_State* L) { + { + int SWIG_arg = 0; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBThread::GetBroadcasterClassName",0,0) + result = (char *)lldb::SBThread::GetBroadcasterClassName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBThread__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *result = 0 ; + + SWIG_check_num_args("lldb::SBThread::SBThread",0,0) + result = (lldb::SBThread *)new lldb::SBThread(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBThread,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBThread__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = 0 ; + lldb::SBThread *result = 0 ; + + SWIG_check_num_args("lldb::SBThread::SBThread",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBThread::SBThread",1,"lldb::SBThread const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("new_SBThread",1,SWIGTYPE_p_lldb__SBThread); + } + + result = (lldb::SBThread *)new lldb::SBThread((lldb::SBThread const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBThread,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBThread(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBThread__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBThread__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBThread'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBThread::SBThread()\n" + " lldb::SBThread::SBThread(lldb::SBThread const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBThread_GetQueue(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBQueue result; + + SWIG_check_num_args("lldb::SBThread::GetQueue",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetQueue",1,"lldb::SBThread const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_GetQueue",1,SWIGTYPE_p_lldb__SBThread); + } + + result = ((lldb::SBThread const *)arg1)->GetQueue(); + { + lldb::SBQueue * resultptr = new lldb::SBQueue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBQueue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBThread::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::IsValid",1,"lldb::SBThread const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_IsValid",1,SWIGTYPE_p_lldb__SBThread); + } + + result = (bool)((lldb::SBThread const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + + SWIG_check_num_args("lldb::SBThread::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::Clear",1,"lldb::SBThread *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_Clear",1,SWIGTYPE_p_lldb__SBThread); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_GetStopReason(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::StopReason result; + + SWIG_check_num_args("lldb::SBThread::GetStopReason",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetStopReason",1,"lldb::SBThread *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_GetStopReason",1,SWIGTYPE_p_lldb__SBThread); + } + + result = (lldb::StopReason)(arg1)->GetStopReason(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_GetStopReasonDataCount(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + size_t result; + + SWIG_check_num_args("lldb::SBThread::GetStopReasonDataCount",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetStopReasonDataCount",1,"lldb::SBThread *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_GetStopReasonDataCount",1,SWIGTYPE_p_lldb__SBThread); + } + + result = (arg1)->GetStopReasonDataCount(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_GetStopReasonDataAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + uint32_t arg2 ; + uint64_t result; + + SWIG_check_num_args("lldb::SBThread::GetStopReasonDataAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetStopReasonDataAtIndex",1,"lldb::SBThread *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBThread::GetStopReasonDataAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_GetStopReasonDataAtIndex",1,SWIGTYPE_p_lldb__SBThread); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (uint64_t)(arg1)->GetStopReasonDataAtIndex(arg2); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_GetStopReasonExtendedInfoAsJSON(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBThread::GetStopReasonExtendedInfoAsJSON",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetStopReasonExtendedInfoAsJSON",1,"lldb::SBThread *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThread::GetStopReasonExtendedInfoAsJSON",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_GetStopReasonExtendedInfoAsJSON",1,SWIGTYPE_p_lldb__SBThread); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBThread_GetStopReasonExtendedInfoAsJSON",2,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)(arg1)->GetStopReasonExtendedInfoAsJSON(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_GetStopReasonExtendedBacktraces(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::InstrumentationRuntimeType arg2 ; + lldb::SBThreadCollection result; + + SWIG_check_num_args("lldb::SBThread::GetStopReasonExtendedBacktraces",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetStopReasonExtendedBacktraces",1,"lldb::SBThread *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBThread::GetStopReasonExtendedBacktraces",2,"lldb::InstrumentationRuntimeType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_GetStopReasonExtendedBacktraces",1,SWIGTYPE_p_lldb__SBThread); + } + + arg2 = (lldb::InstrumentationRuntimeType)lua_tointeger(L, 2); + result = (arg1)->GetStopReasonExtendedBacktraces(arg2); + { + lldb::SBThreadCollection * resultptr = new lldb::SBThreadCollection(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThreadCollection,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_GetStopDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + char *arg2 = (char *) 0 ; + size_t arg3 ; + size_t result; + + SWIG_check_num_args("lldb::SBThread::GetStopDescription",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetStopDescription",1,"lldb::SBThread *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_GetStopDescription",1,SWIGTYPE_p_lldb__SBThread); + } + + { + arg3 = luaL_checkinteger(L, 2); + if (arg3 <= 0) { + return luaL_error(L, "Positive integer expected"); + } + arg2 = (char *)malloc(arg3); + } + result = (arg1)->GetStopDescription(arg2,arg3); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + { + lua_pop(L, 1); // Blow away the previous result + lua_pushlstring(L, (const char *)arg2, result); + free(arg2); + // SWIG_arg was already incremented + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_GetStopReturnValue(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBThread::GetStopReturnValue",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetStopReturnValue",1,"lldb::SBThread *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_GetStopReturnValue",1,SWIGTYPE_p_lldb__SBThread); + } + + result = (arg1)->GetStopReturnValue(); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_GetThreadID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::tid_t result; + + SWIG_check_num_args("lldb::SBThread::GetThreadID",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetThreadID",1,"lldb::SBThread const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_GetThreadID",1,SWIGTYPE_p_lldb__SBThread); + } + + result = (lldb::tid_t)((lldb::SBThread const *)arg1)->GetThreadID(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_GetIndexID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBThread::GetIndexID",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetIndexID",1,"lldb::SBThread const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_GetIndexID",1,SWIGTYPE_p_lldb__SBThread); + } + + result = (uint32_t)((lldb::SBThread const *)arg1)->GetIndexID(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_GetName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBThread::GetName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetName",1,"lldb::SBThread const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_GetName",1,SWIGTYPE_p_lldb__SBThread); + } + + result = (char *)((lldb::SBThread const *)arg1)->GetName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_GetQueueName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBThread::GetQueueName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetQueueName",1,"lldb::SBThread const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_GetQueueName",1,SWIGTYPE_p_lldb__SBThread); + } + + result = (char *)((lldb::SBThread const *)arg1)->GetQueueName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_GetQueueID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::queue_id_t result; + + SWIG_check_num_args("lldb::SBThread::GetQueueID",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetQueueID",1,"lldb::SBThread const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_GetQueueID",1,SWIGTYPE_p_lldb__SBThread); + } + + result = (lldb::queue_id_t)((lldb::SBThread const *)arg1)->GetQueueID(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_GetInfoItemByPathAsString(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBStream *arg3 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBThread::GetInfoItemByPathAsString",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetInfoItemByPathAsString",1,"lldb::SBThread *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBThread::GetInfoItemByPathAsString",2,"char const *"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBThread::GetInfoItemByPathAsString",3,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_GetInfoItemByPathAsString",1,SWIGTYPE_p_lldb__SBThread); + } + + arg2 = (char *)lua_tostring(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBThread_GetInfoItemByPathAsString",3,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)(arg1)->GetInfoItemByPathAsString((char const *)arg2,*arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_StepOver__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::RunMode arg2 ; + + SWIG_check_num_args("lldb::SBThread::StepOver",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepOver",1,"lldb::SBThread *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBThread::StepOver",2,"lldb::RunMode"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_StepOver",1,SWIGTYPE_p_lldb__SBThread); + } + + arg2 = (lldb::RunMode)lua_tointeger(L, 2); + (arg1)->StepOver(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_StepOver__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + + SWIG_check_num_args("lldb::SBThread::StepOver",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepOver",1,"lldb::SBThread *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_StepOver",1,SWIGTYPE_p_lldb__SBThread); + } + + (arg1)->StepOver(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_StepOver__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::RunMode arg2 ; + lldb::SBError *arg3 = 0 ; + + SWIG_check_num_args("lldb::SBThread::StepOver",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepOver",1,"lldb::SBThread *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBThread::StepOver",2,"lldb::RunMode"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBThread::StepOver",3,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_StepOver",1,SWIGTYPE_p_lldb__SBThread); + } + + arg2 = (lldb::RunMode)lua_tointeger(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBThread_StepOver",3,SWIGTYPE_p_lldb__SBError); + } + + (arg1)->StepOver(arg2,*arg3); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_StepOver(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBThread_StepOver__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_SBThread_StepOver__SWIG_0(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBThread_StepOver__SWIG_2(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBThread_StepInto__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::RunMode arg2 ; + + SWIG_check_num_args("lldb::SBThread::StepInto",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepInto",1,"lldb::SBThread *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBThread::StepInto",2,"lldb::RunMode"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_StepInto",1,SWIGTYPE_p_lldb__SBThread); + } + + arg2 = (lldb::RunMode)lua_tointeger(L, 2); + (arg1)->StepInto(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_StepInto__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + + SWIG_check_num_args("lldb::SBThread::StepInto",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepInto",1,"lldb::SBThread *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_StepInto",1,SWIGTYPE_p_lldb__SBThread); + } + + (arg1)->StepInto(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_StepInto__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + char *arg2 = (char *) 0 ; + lldb::RunMode arg3 ; + + SWIG_check_num_args("lldb::SBThread::StepInto",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepInto",1,"lldb::SBThread *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBThread::StepInto",2,"char const *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBThread::StepInto",3,"lldb::RunMode"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_StepInto",1,SWIGTYPE_p_lldb__SBThread); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (lldb::RunMode)lua_tointeger(L, 3); + (arg1)->StepInto((char const *)arg2,arg3); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_StepInto__SWIG_3(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBThread::StepInto",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepInto",1,"lldb::SBThread *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBThread::StepInto",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_StepInto",1,SWIGTYPE_p_lldb__SBThread); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->StepInto((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_StepInto__SWIG_4(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + char *arg2 = (char *) 0 ; + uint32_t arg3 ; + lldb::SBError *arg4 = 0 ; + lldb::RunMode arg5 ; + + SWIG_check_num_args("lldb::SBThread::StepInto",5,5) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepInto",1,"lldb::SBThread *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBThread::StepInto",2,"char const *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBThread::StepInto",3,"uint32_t"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBThread::StepInto",4,"lldb::SBError &"); + if(!lua_isinteger(L,5)) SWIG_fail_arg("lldb::SBThread::StepInto",5,"lldb::RunMode"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_StepInto",1,SWIGTYPE_p_lldb__SBThread); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (uint32_t)lua_tointeger(L, 3); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBThread_StepInto",4,SWIGTYPE_p_lldb__SBError); + } + + arg5 = (lldb::RunMode)lua_tointeger(L, 5); + (arg1)->StepInto((char const *)arg2,arg3,*arg4,arg5); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_StepInto__SWIG_5(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + char *arg2 = (char *) 0 ; + uint32_t arg3 ; + lldb::SBError *arg4 = 0 ; + + SWIG_check_num_args("lldb::SBThread::StepInto",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepInto",1,"lldb::SBThread *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBThread::StepInto",2,"char const *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBThread::StepInto",3,"uint32_t"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBThread::StepInto",4,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_StepInto",1,SWIGTYPE_p_lldb__SBThread); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (uint32_t)lua_tointeger(L, 3); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBThread_StepInto",4,SWIGTYPE_p_lldb__SBError); + } + + (arg1)->StepInto((char const *)arg2,arg3,*arg4); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_StepInto(lua_State* L) { + int argc; + int argv[6]={ + 1,2,3,4,5,6 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBThread_StepInto__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_SBThread_StepInto__SWIG_0(L); + } + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + return _wrap_SBThread_StepInto__SWIG_3(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + return _wrap_SBThread_StepInto__SWIG_2(L); + } + } + } + } + if (argc == 4) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBThread_StepInto__SWIG_5(L); + } + } + } + } + } + if (argc == 5) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[4]); + } + if (_v) { + return _wrap_SBThread_StepInto__SWIG_4(L); + } + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBThread_StepOut__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + + SWIG_check_num_args("lldb::SBThread::StepOut",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepOut",1,"lldb::SBThread *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_StepOut",1,SWIGTYPE_p_lldb__SBThread); + } + + (arg1)->StepOut(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_StepOut__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBError *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBThread::StepOut",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepOut",1,"lldb::SBThread *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThread::StepOut",2,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_StepOut",1,SWIGTYPE_p_lldb__SBThread); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBThread_StepOut",2,SWIGTYPE_p_lldb__SBError); + } + + (arg1)->StepOut(*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_StepOut(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBThread_StepOut__SWIG_0(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBThread_StepOut__SWIG_1(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBThread_StepOut'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBThread::StepOut()\n" + " lldb::SBThread::StepOut(lldb::SBError &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBThread_StepOutOfFrame__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBFrame *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBThread::StepOutOfFrame",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepOutOfFrame",1,"lldb::SBThread *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThread::StepOutOfFrame",2,"lldb::SBFrame &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_StepOutOfFrame",1,SWIGTYPE_p_lldb__SBThread); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBThread_StepOutOfFrame",2,SWIGTYPE_p_lldb__SBFrame); + } + + (arg1)->StepOutOfFrame(*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_StepOutOfFrame__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBFrame *arg2 = 0 ; + lldb::SBError *arg3 = 0 ; + + SWIG_check_num_args("lldb::SBThread::StepOutOfFrame",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepOutOfFrame",1,"lldb::SBThread *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThread::StepOutOfFrame",2,"lldb::SBFrame &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBThread::StepOutOfFrame",3,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_StepOutOfFrame",1,SWIGTYPE_p_lldb__SBThread); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBThread_StepOutOfFrame",2,SWIGTYPE_p_lldb__SBFrame); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBThread_StepOutOfFrame",3,SWIGTYPE_p_lldb__SBError); + } + + (arg1)->StepOutOfFrame(*arg2,*arg3); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_StepOutOfFrame(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBThread_StepOutOfFrame__SWIG_0(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBFrame, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBThread_StepOutOfFrame__SWIG_1(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBThread_StepInstruction__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBThread::StepInstruction",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepInstruction",1,"lldb::SBThread *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBThread::StepInstruction",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_StepInstruction",1,SWIGTYPE_p_lldb__SBThread); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->StepInstruction(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_StepInstruction__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + bool arg2 ; + lldb::SBError *arg3 = 0 ; + + SWIG_check_num_args("lldb::SBThread::StepInstruction",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepInstruction",1,"lldb::SBThread *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBThread::StepInstruction",2,"bool"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBThread::StepInstruction",3,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_StepInstruction",1,SWIGTYPE_p_lldb__SBThread); + } + + arg2 = (lua_toboolean(L, 2)!=0); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBThread_StepInstruction",3,SWIGTYPE_p_lldb__SBError); + } + + (arg1)->StepInstruction(arg2,*arg3); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_StepInstruction(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[1]); + } + if (_v) { + return _wrap_SBThread_StepInstruction__SWIG_0(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[1]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBThread_StepInstruction__SWIG_1(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBThread_StepOverUntil(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBFrame *arg2 = 0 ; + lldb::SBFileSpec *arg3 = 0 ; + uint32_t arg4 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBThread::StepOverUntil",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepOverUntil",1,"lldb::SBThread *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThread::StepOverUntil",2,"lldb::SBFrame &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBThread::StepOverUntil",3,"lldb::SBFileSpec &"); + if(!lua_isinteger(L,4)) SWIG_fail_arg("lldb::SBThread::StepOverUntil",4,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_StepOverUntil",1,SWIGTYPE_p_lldb__SBThread); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBThread_StepOverUntil",2,SWIGTYPE_p_lldb__SBFrame); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBThread_StepOverUntil",3,SWIGTYPE_p_lldb__SBFileSpec); + } + + arg4 = (uint32_t)lua_tointeger(L, 4); + result = (arg1)->StepOverUntil(*arg2,*arg3,arg4); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_StepUsingScriptedThreadPlan__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBThread::StepUsingScriptedThreadPlan",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepUsingScriptedThreadPlan",1,"lldb::SBThread *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBThread::StepUsingScriptedThreadPlan",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_StepUsingScriptedThreadPlan",1,SWIGTYPE_p_lldb__SBThread); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->StepUsingScriptedThreadPlan((char const *)arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_StepUsingScriptedThreadPlan__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + char *arg2 = (char *) 0 ; + bool arg3 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBThread::StepUsingScriptedThreadPlan",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepUsingScriptedThreadPlan",1,"lldb::SBThread *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBThread::StepUsingScriptedThreadPlan",2,"char const *"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBThread::StepUsingScriptedThreadPlan",3,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_StepUsingScriptedThreadPlan",1,SWIGTYPE_p_lldb__SBThread); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (lua_toboolean(L, 3)!=0); + result = (arg1)->StepUsingScriptedThreadPlan((char const *)arg2,arg3); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_StepUsingScriptedThreadPlan__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBStructuredData *arg3 = 0 ; + bool arg4 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBThread::StepUsingScriptedThreadPlan",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::StepUsingScriptedThreadPlan",1,"lldb::SBThread *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBThread::StepUsingScriptedThreadPlan",2,"char const *"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBThread::StepUsingScriptedThreadPlan",3,"lldb::SBStructuredData &"); + if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBThread::StepUsingScriptedThreadPlan",4,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_StepUsingScriptedThreadPlan",1,SWIGTYPE_p_lldb__SBThread); + } + + arg2 = (char *)lua_tostring(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("SBThread_StepUsingScriptedThreadPlan",3,SWIGTYPE_p_lldb__SBStructuredData); + } + + arg4 = (lua_toboolean(L, 4)!=0); + result = (arg1)->StepUsingScriptedThreadPlan((char const *)arg2,*arg3,arg4); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_StepUsingScriptedThreadPlan(lua_State* L) { + int argc; + int argv[5]={ + 1,2,3,4,5 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + return _wrap_SBThread_StepUsingScriptedThreadPlan__SWIG_0(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[2]); + } + if (_v) { + return _wrap_SBThread_StepUsingScriptedThreadPlan__SWIG_1(L); + } + } + } + } + if (argc == 4) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[3]); + } + if (_v) { + return _wrap_SBThread_StepUsingScriptedThreadPlan__SWIG_2(L); + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBThread_JumpToLine(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBFileSpec *arg2 = 0 ; + uint32_t arg3 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBThread::JumpToLine",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::JumpToLine",1,"lldb::SBThread *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThread::JumpToLine",2,"lldb::SBFileSpec &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBThread::JumpToLine",3,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_JumpToLine",1,SWIGTYPE_p_lldb__SBThread); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBThread_JumpToLine",2,SWIGTYPE_p_lldb__SBFileSpec); + } + + arg3 = (uint32_t)lua_tointeger(L, 3); + result = (arg1)->JumpToLine(*arg2,arg3); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_RunToAddress__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::addr_t arg2 ; + + SWIG_check_num_args("lldb::SBThread::RunToAddress",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::RunToAddress",1,"lldb::SBThread *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBThread::RunToAddress",2,"lldb::addr_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_RunToAddress",1,SWIGTYPE_p_lldb__SBThread); + } + + arg2 = (lldb::addr_t)lua_tointeger(L, 2); + (arg1)->RunToAddress(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_RunToAddress__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::addr_t arg2 ; + lldb::SBError *arg3 = 0 ; + + SWIG_check_num_args("lldb::SBThread::RunToAddress",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::RunToAddress",1,"lldb::SBThread *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBThread::RunToAddress",2,"lldb::addr_t"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBThread::RunToAddress",3,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_RunToAddress",1,SWIGTYPE_p_lldb__SBThread); + } + + arg2 = (lldb::addr_t)lua_tointeger(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBThread_RunToAddress",3,SWIGTYPE_p_lldb__SBError); + } + + (arg1)->RunToAddress(arg2,*arg3); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_RunToAddress(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_SBThread_RunToAddress__SWIG_0(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBThread_RunToAddress__SWIG_1(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBThread_ReturnFromFrame(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBFrame *arg2 = 0 ; + lldb::SBValue *arg3 = 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBThread::ReturnFromFrame",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::ReturnFromFrame",1,"lldb::SBThread *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThread::ReturnFromFrame",2,"lldb::SBFrame &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBThread::ReturnFromFrame",3,"lldb::SBValue &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_ReturnFromFrame",1,SWIGTYPE_p_lldb__SBThread); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFrame,0))){ + SWIG_fail_ptr("SBThread_ReturnFromFrame",2,SWIGTYPE_p_lldb__SBFrame); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBThread_ReturnFromFrame",3,SWIGTYPE_p_lldb__SBValue); + } + + result = (arg1)->ReturnFromFrame(*arg2,*arg3); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_UnwindInnermostExpression(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBThread::UnwindInnermostExpression",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::UnwindInnermostExpression",1,"lldb::SBThread *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_UnwindInnermostExpression",1,SWIGTYPE_p_lldb__SBThread); + } + + result = (arg1)->UnwindInnermostExpression(); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_Suspend__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBThread::Suspend",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::Suspend",1,"lldb::SBThread *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_Suspend",1,SWIGTYPE_p_lldb__SBThread); + } + + result = (bool)(arg1)->Suspend(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_Suspend__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBError *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBThread::Suspend",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::Suspend",1,"lldb::SBThread *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThread::Suspend",2,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_Suspend",1,SWIGTYPE_p_lldb__SBThread); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBThread_Suspend",2,SWIGTYPE_p_lldb__SBError); + } + + result = (bool)(arg1)->Suspend(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_Suspend(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBThread_Suspend__SWIG_0(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBThread_Suspend__SWIG_1(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBThread_Suspend'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBThread::Suspend()\n" + " lldb::SBThread::Suspend(lldb::SBError &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBThread_Resume__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBThread::Resume",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::Resume",1,"lldb::SBThread *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_Resume",1,SWIGTYPE_p_lldb__SBThread); + } + + result = (bool)(arg1)->Resume(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_Resume__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBError *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBThread::Resume",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::Resume",1,"lldb::SBThread *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThread::Resume",2,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_Resume",1,SWIGTYPE_p_lldb__SBThread); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBThread_Resume",2,SWIGTYPE_p_lldb__SBError); + } + + result = (bool)(arg1)->Resume(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_Resume(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBThread_Resume__SWIG_0(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBThread_Resume__SWIG_1(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBThread_Resume'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBThread::Resume()\n" + " lldb::SBThread::Resume(lldb::SBError &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBThread_IsSuspended(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBThread::IsSuspended",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::IsSuspended",1,"lldb::SBThread *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_IsSuspended",1,SWIGTYPE_p_lldb__SBThread); + } + + result = (bool)(arg1)->IsSuspended(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_IsStopped(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBThread::IsStopped",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::IsStopped",1,"lldb::SBThread *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_IsStopped",1,SWIGTYPE_p_lldb__SBThread); + } + + result = (bool)(arg1)->IsStopped(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_GetNumFrames(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBThread::GetNumFrames",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetNumFrames",1,"lldb::SBThread *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_GetNumFrames",1,SWIGTYPE_p_lldb__SBThread); + } + + result = (uint32_t)(arg1)->GetNumFrames(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_GetFrameAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + uint32_t arg2 ; + lldb::SBFrame result; + + SWIG_check_num_args("lldb::SBThread::GetFrameAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetFrameAtIndex",1,"lldb::SBThread *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBThread::GetFrameAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_GetFrameAtIndex",1,SWIGTYPE_p_lldb__SBThread); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetFrameAtIndex(arg2); + { + lldb::SBFrame * resultptr = new lldb::SBFrame(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFrame,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_GetSelectedFrame(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBFrame result; + + SWIG_check_num_args("lldb::SBThread::GetSelectedFrame",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetSelectedFrame",1,"lldb::SBThread *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_GetSelectedFrame",1,SWIGTYPE_p_lldb__SBThread); + } + + result = (arg1)->GetSelectedFrame(); + { + lldb::SBFrame * resultptr = new lldb::SBFrame(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFrame,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_SetSelectedFrame(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + uint32_t arg2 ; + lldb::SBFrame result; + + SWIG_check_num_args("lldb::SBThread::SetSelectedFrame",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::SetSelectedFrame",1,"lldb::SBThread *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBThread::SetSelectedFrame",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_SetSelectedFrame",1,SWIGTYPE_p_lldb__SBThread); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->SetSelectedFrame(arg2); + { + lldb::SBFrame * resultptr = new lldb::SBFrame(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFrame,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_EventIsThreadEvent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBThread::EventIsThreadEvent",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBThread::EventIsThreadEvent",1,"lldb::SBEvent const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBThread_EventIsThreadEvent",1,SWIGTYPE_p_lldb__SBEvent); + } + + result = (bool)lldb::SBThread::EventIsThreadEvent((lldb::SBEvent const &)*arg1); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_GetStackFrameFromEvent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = 0 ; + lldb::SBFrame result; + + SWIG_check_num_args("lldb::SBThread::GetStackFrameFromEvent",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBThread::GetStackFrameFromEvent",1,"lldb::SBEvent const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBThread_GetStackFrameFromEvent",1,SWIGTYPE_p_lldb__SBEvent); + } + + result = lldb::SBThread::GetStackFrameFromEvent((lldb::SBEvent const &)*arg1); + { + lldb::SBFrame * resultptr = new lldb::SBFrame(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFrame,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_GetThreadFromEvent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = 0 ; + lldb::SBThread result; + + SWIG_check_num_args("lldb::SBThread::GetThreadFromEvent",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBThread::GetThreadFromEvent",1,"lldb::SBEvent const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBThread_GetThreadFromEvent",1,SWIGTYPE_p_lldb__SBEvent); + } + + result = lldb::SBThread::GetThreadFromEvent((lldb::SBEvent const &)*arg1); + { + lldb::SBThread * resultptr = new lldb::SBThread(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThread,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_GetProcess(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBProcess result; + + SWIG_check_num_args("lldb::SBThread::GetProcess",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetProcess",1,"lldb::SBThread *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_GetProcess",1,SWIGTYPE_p_lldb__SBThread); + } + + result = (arg1)->GetProcess(); + { + lldb::SBProcess * resultptr = new lldb::SBProcess(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread___eq(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBThread::operator ==",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::operator ==",1,"lldb::SBThread const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThread::operator ==",2,"lldb::SBThread const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread___eq",1,SWIGTYPE_p_lldb__SBThread); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread___eq",2,SWIGTYPE_p_lldb__SBThread); + } + + result = (bool)((lldb::SBThread const *)arg1)->operator ==((lldb::SBThread const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_GetDescription__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBThread::GetDescription",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetDescription",1,"lldb::SBThread const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThread::GetDescription",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_GetDescription",1,SWIGTYPE_p_lldb__SBThread); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBThread_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)((lldb::SBThread const *)arg1)->GetDescription(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_GetDescription__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool arg3 ; + bool result; + + SWIG_check_num_args("lldb::SBThread::GetDescription",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetDescription",1,"lldb::SBThread const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThread::GetDescription",2,"lldb::SBStream &"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBThread::GetDescription",3,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_GetDescription",1,SWIGTYPE_p_lldb__SBThread); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBThread_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + arg3 = (lua_toboolean(L, 3)!=0); + result = (bool)((lldb::SBThread const *)arg1)->GetDescription(*arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_GetDescription(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBThread_GetDescription__SWIG_0(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[2]); + } + if (_v) { + return _wrap_SBThread_GetDescription__SWIG_1(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBThread_GetDescriptionWithFormat(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBFormat *arg2 = 0 ; + lldb::SBStream *arg3 = 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBThread::GetDescriptionWithFormat",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetDescriptionWithFormat",1,"lldb::SBThread *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThread::GetDescriptionWithFormat",2,"lldb::SBFormat const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBThread::GetDescriptionWithFormat",3,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_GetDescriptionWithFormat",1,SWIGTYPE_p_lldb__SBThread); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBFormat,0))){ + SWIG_fail_ptr("SBThread_GetDescriptionWithFormat",2,SWIGTYPE_p_lldb__SBFormat); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBThread_GetDescriptionWithFormat",3,SWIGTYPE_p_lldb__SBStream); + } + + result = (arg1)->GetDescriptionWithFormat((lldb::SBFormat const &)*arg2,*arg3); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_GetStatus(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBThread::GetStatus",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetStatus",1,"lldb::SBThread const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThread::GetStatus",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_GetStatus",1,SWIGTYPE_p_lldb__SBThread); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBThread_GetStatus",2,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)((lldb::SBThread const *)arg1)->GetStatus(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_GetExtendedBacktraceThread(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBThread result; + + SWIG_check_num_args("lldb::SBThread::GetExtendedBacktraceThread",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetExtendedBacktraceThread",1,"lldb::SBThread *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBThread::GetExtendedBacktraceThread",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_GetExtendedBacktraceThread",1,SWIGTYPE_p_lldb__SBThread); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->GetExtendedBacktraceThread((char const *)arg2); + { + lldb::SBThread * resultptr = new lldb::SBThread(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThread,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_GetExtendedBacktraceOriginatingIndexID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBThread::GetExtendedBacktraceOriginatingIndexID",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetExtendedBacktraceOriginatingIndexID",1,"lldb::SBThread *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_GetExtendedBacktraceOriginatingIndexID",1,SWIGTYPE_p_lldb__SBThread); + } + + result = (uint32_t)(arg1)->GetExtendedBacktraceOriginatingIndexID(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_GetCurrentException(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBThread::GetCurrentException",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetCurrentException",1,"lldb::SBThread *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_GetCurrentException",1,SWIGTYPE_p_lldb__SBThread); + } + + result = (arg1)->GetCurrentException(); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_GetCurrentExceptionBacktrace(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBThread result; + + SWIG_check_num_args("lldb::SBThread::GetCurrentExceptionBacktrace",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetCurrentExceptionBacktrace",1,"lldb::SBThread *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_GetCurrentExceptionBacktrace",1,SWIGTYPE_p_lldb__SBThread); + } + + result = (arg1)->GetCurrentExceptionBacktrace(); + { + lldb::SBThread * resultptr = new lldb::SBThread(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThread,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_SafeToCallFunctions(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBThread::SafeToCallFunctions",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::SafeToCallFunctions",1,"lldb::SBThread *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_SafeToCallFunctions",1,SWIGTYPE_p_lldb__SBThread); + } + + result = (bool)(arg1)->SafeToCallFunctions(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread_GetSiginfo(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBThread::GetSiginfo",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::GetSiginfo",1,"lldb::SBThread *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread_GetSiginfo",1,SWIGTYPE_p_lldb__SBThread); + } + + result = (arg1)->GetSiginfo(); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThread___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = (lldb::SBThread *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBThread::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThread::__repr__",1,"lldb::SBThread *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBThread___tostring",1,SWIGTYPE_p_lldb__SBThread); + } + + result = lldb_SBThread___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBThread(void *obj) { +lldb::SBThread *arg1 = (lldb::SBThread *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBThread(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBThread); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBThread_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBThread_methods[]= { + { "GetQueue", _wrap_SBThread_GetQueue}, + { "IsValid", _wrap_SBThread_IsValid}, + { "Clear", _wrap_SBThread_Clear}, + { "GetStopReason", _wrap_SBThread_GetStopReason}, + { "GetStopReasonDataCount", _wrap_SBThread_GetStopReasonDataCount}, + { "GetStopReasonDataAtIndex", _wrap_SBThread_GetStopReasonDataAtIndex}, + { "GetStopReasonExtendedInfoAsJSON", _wrap_SBThread_GetStopReasonExtendedInfoAsJSON}, + { "GetStopReasonExtendedBacktraces", _wrap_SBThread_GetStopReasonExtendedBacktraces}, + { "GetStopDescription", _wrap_SBThread_GetStopDescription}, + { "GetStopReturnValue", _wrap_SBThread_GetStopReturnValue}, + { "GetThreadID", _wrap_SBThread_GetThreadID}, + { "GetIndexID", _wrap_SBThread_GetIndexID}, + { "GetName", _wrap_SBThread_GetName}, + { "GetQueueName", _wrap_SBThread_GetQueueName}, + { "GetQueueID", _wrap_SBThread_GetQueueID}, + { "GetInfoItemByPathAsString", _wrap_SBThread_GetInfoItemByPathAsString}, + { "StepOver", _wrap_SBThread_StepOver}, + { "StepInto", _wrap_SBThread_StepInto}, + { "StepOut", _wrap_SBThread_StepOut}, + { "StepOutOfFrame", _wrap_SBThread_StepOutOfFrame}, + { "StepInstruction", _wrap_SBThread_StepInstruction}, + { "StepOverUntil", _wrap_SBThread_StepOverUntil}, + { "StepUsingScriptedThreadPlan", _wrap_SBThread_StepUsingScriptedThreadPlan}, + { "JumpToLine", _wrap_SBThread_JumpToLine}, + { "RunToAddress", _wrap_SBThread_RunToAddress}, + { "ReturnFromFrame", _wrap_SBThread_ReturnFromFrame}, + { "UnwindInnermostExpression", _wrap_SBThread_UnwindInnermostExpression}, + { "Suspend", _wrap_SBThread_Suspend}, + { "Resume", _wrap_SBThread_Resume}, + { "IsSuspended", _wrap_SBThread_IsSuspended}, + { "IsStopped", _wrap_SBThread_IsStopped}, + { "GetNumFrames", _wrap_SBThread_GetNumFrames}, + { "GetFrameAtIndex", _wrap_SBThread_GetFrameAtIndex}, + { "GetSelectedFrame", _wrap_SBThread_GetSelectedFrame}, + { "SetSelectedFrame", _wrap_SBThread_SetSelectedFrame}, + { "GetProcess", _wrap_SBThread_GetProcess}, + { "__eq", _wrap_SBThread___eq}, + { "GetDescription", _wrap_SBThread_GetDescription}, + { "GetDescriptionWithFormat", _wrap_SBThread_GetDescriptionWithFormat}, + { "GetStatus", _wrap_SBThread_GetStatus}, + { "GetExtendedBacktraceThread", _wrap_SBThread_GetExtendedBacktraceThread}, + { "GetExtendedBacktraceOriginatingIndexID", _wrap_SBThread_GetExtendedBacktraceOriginatingIndexID}, + { "GetCurrentException", _wrap_SBThread_GetCurrentException}, + { "GetCurrentExceptionBacktrace", _wrap_SBThread_GetCurrentExceptionBacktrace}, + { "SafeToCallFunctions", _wrap_SBThread_SafeToCallFunctions}, + { "GetSiginfo", _wrap_SBThread_GetSiginfo}, + { "__tostring", _wrap_SBThread___tostring}, + {0,0} +}; +static swig_lua_method swig_SBThread_meta[] = { + { "__eq", _wrap_SBThread___eq}, + { "__tostring", _wrap_SBThread___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBThread_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBThread_Sf_SwigStatic_constants[]= { + {SWIG_LUA_CONSTTAB_INT("eBroadcastBitStackChanged", (lldb::SBThread::eBroadcastBitStackChanged))}, + {SWIG_LUA_CONSTTAB_INT("eBroadcastBitThreadSuspended", (lldb::SBThread::eBroadcastBitThreadSuspended))}, + {SWIG_LUA_CONSTTAB_INT("eBroadcastBitThreadResumed", (lldb::SBThread::eBroadcastBitThreadResumed))}, + {SWIG_LUA_CONSTTAB_INT("eBroadcastBitSelectedFrameChanged", (lldb::SBThread::eBroadcastBitSelectedFrameChanged))}, + {SWIG_LUA_CONSTTAB_INT("eBroadcastBitThreadSelected", (lldb::SBThread::eBroadcastBitThreadSelected))}, + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBThread_Sf_SwigStatic_methods[]= { + { "GetBroadcasterClassName", _wrap_SBThread_GetBroadcasterClassName}, + { "EventIsThreadEvent", _wrap_SBThread_EventIsThreadEvent}, + { "GetStackFrameFromEvent", _wrap_SBThread_GetStackFrameFromEvent}, + { "GetThreadFromEvent", _wrap_SBThread_GetThreadFromEvent}, + {0,0} +}; +static swig_lua_class* swig_SBThread_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBThread_Sf_SwigStatic = { + "SBThread", + swig_SBThread_Sf_SwigStatic_methods, + swig_SBThread_Sf_SwigStatic_attributes, + swig_SBThread_Sf_SwigStatic_constants, + swig_SBThread_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBThread_bases[] = {0}; +static const char *swig_SBThread_base_names[] = {0}; +static swig_lua_class _wrap_class_SBThread = { "SBThread", "SBThread", &SWIGTYPE_p_lldb__SBThread,_proxy__wrap_new_SBThread, swig_delete_SBThread, swig_SBThread_methods, swig_SBThread_attributes, &swig_SBThread_Sf_SwigStatic, swig_SBThread_meta, swig_SBThread_bases, swig_SBThread_base_names }; + +static int _wrap_new_SBThreadCollection__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThreadCollection *result = 0 ; + + SWIG_check_num_args("lldb::SBThreadCollection::SBThreadCollection",0,0) + result = (lldb::SBThreadCollection *)new lldb::SBThreadCollection(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBThreadCollection,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBThreadCollection__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThreadCollection *arg1 = 0 ; + lldb::SBThreadCollection *result = 0 ; + + SWIG_check_num_args("lldb::SBThreadCollection::SBThreadCollection",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBThreadCollection::SBThreadCollection",1,"lldb::SBThreadCollection const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadCollection,0))){ + SWIG_fail_ptr("new_SBThreadCollection",1,SWIGTYPE_p_lldb__SBThreadCollection); + } + + result = (lldb::SBThreadCollection *)new lldb::SBThreadCollection((lldb::SBThreadCollection const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBThreadCollection,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBThreadCollection(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBThreadCollection__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThreadCollection, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBThreadCollection__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBThreadCollection'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBThreadCollection::SBThreadCollection()\n" + " lldb::SBThreadCollection::SBThreadCollection(lldb::SBThreadCollection const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBThreadCollection_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThreadCollection *arg1 = (lldb::SBThreadCollection *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBThreadCollection::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadCollection::IsValid",1,"lldb::SBThreadCollection const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadCollection,0))){ + SWIG_fail_ptr("SBThreadCollection_IsValid",1,SWIGTYPE_p_lldb__SBThreadCollection); + } + + result = (bool)((lldb::SBThreadCollection const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThreadCollection_GetSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThreadCollection *arg1 = (lldb::SBThreadCollection *) 0 ; + size_t result; + + SWIG_check_num_args("lldb::SBThreadCollection::GetSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadCollection::GetSize",1,"lldb::SBThreadCollection *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadCollection,0))){ + SWIG_fail_ptr("SBThreadCollection_GetSize",1,SWIGTYPE_p_lldb__SBThreadCollection); + } + + result = (arg1)->GetSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThreadCollection_GetThreadAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThreadCollection *arg1 = (lldb::SBThreadCollection *) 0 ; + size_t arg2 ; + lldb::SBThread result; + + SWIG_check_num_args("lldb::SBThreadCollection::GetThreadAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadCollection::GetThreadAtIndex",1,"lldb::SBThreadCollection *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBThreadCollection::GetThreadAtIndex",2,"size_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadCollection,0))){ + SWIG_fail_ptr("SBThreadCollection_GetThreadAtIndex",1,SWIGTYPE_p_lldb__SBThreadCollection); + } + + arg2 = (size_t)lua_tointeger(L, 2); + result = (arg1)->GetThreadAtIndex(arg2); + { + lldb::SBThread * resultptr = new lldb::SBThread(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThread,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBThreadCollection(void *obj) { +lldb::SBThreadCollection *arg1 = (lldb::SBThreadCollection *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBThreadCollection(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBThreadCollection); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBThreadCollection_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBThreadCollection_methods[]= { + { "IsValid", _wrap_SBThreadCollection_IsValid}, + { "GetSize", _wrap_SBThreadCollection_GetSize}, + { "GetThreadAtIndex", _wrap_SBThreadCollection_GetThreadAtIndex}, + {0,0} +}; +static swig_lua_method swig_SBThreadCollection_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBThreadCollection_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBThreadCollection_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBThreadCollection_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBThreadCollection_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBThreadCollection_Sf_SwigStatic = { + "SBThreadCollection", + swig_SBThreadCollection_Sf_SwigStatic_methods, + swig_SBThreadCollection_Sf_SwigStatic_attributes, + swig_SBThreadCollection_Sf_SwigStatic_constants, + swig_SBThreadCollection_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBThreadCollection_bases[] = {0}; +static const char *swig_SBThreadCollection_base_names[] = {0}; +static swig_lua_class _wrap_class_SBThreadCollection = { "SBThreadCollection", "SBThreadCollection", &SWIGTYPE_p_lldb__SBThreadCollection,_proxy__wrap_new_SBThreadCollection, swig_delete_SBThreadCollection, swig_SBThreadCollection_methods, swig_SBThreadCollection_attributes, &swig_SBThreadCollection_Sf_SwigStatic, swig_SBThreadCollection_meta, swig_SBThreadCollection_bases, swig_SBThreadCollection_base_names }; + +static int _wrap_new_SBThreadPlan__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThreadPlan *result = 0 ; + + SWIG_check_num_args("lldb::SBThreadPlan::SBThreadPlan",0,0) + result = (lldb::SBThreadPlan *)new lldb::SBThreadPlan(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBThreadPlan,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBThreadPlan__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThreadPlan *arg1 = 0 ; + lldb::SBThreadPlan *result = 0 ; + + SWIG_check_num_args("lldb::SBThreadPlan::SBThreadPlan",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::SBThreadPlan",1,"lldb::SBThreadPlan const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){ + SWIG_fail_ptr("new_SBThreadPlan",1,SWIGTYPE_p_lldb__SBThreadPlan); + } + + result = (lldb::SBThreadPlan *)new lldb::SBThreadPlan((lldb::SBThreadPlan const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBThreadPlan,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBThreadPlan__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = 0 ; + char *arg2 = (char *) 0 ; + lldb::SBThreadPlan *result = 0 ; + + SWIG_check_num_args("lldb::SBThreadPlan::SBThreadPlan",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::SBThreadPlan",1,"lldb::SBThread &"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBThreadPlan::SBThreadPlan",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("new_SBThreadPlan",1,SWIGTYPE_p_lldb__SBThread); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (lldb::SBThreadPlan *)new lldb::SBThreadPlan(*arg1,(char const *)arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBThreadPlan,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBThreadPlan__SWIG_3(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThread *arg1 = 0 ; + char *arg2 = (char *) 0 ; + lldb::SBStructuredData *arg3 = 0 ; + lldb::SBThreadPlan *result = 0 ; + + SWIG_check_num_args("lldb::SBThreadPlan::SBThreadPlan",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::SBThreadPlan",1,"lldb::SBThread &"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBThreadPlan::SBThreadPlan",2,"char const *"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBThreadPlan::SBThreadPlan",3,"lldb::SBStructuredData &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("new_SBThreadPlan",1,SWIGTYPE_p_lldb__SBThread); + } + + arg2 = (char *)lua_tostring(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("new_SBThreadPlan",3,SWIGTYPE_p_lldb__SBStructuredData); + } + + result = (lldb::SBThreadPlan *)new lldb::SBThreadPlan(*arg1,(char const *)arg2,*arg3); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBThreadPlan,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBThreadPlan(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBThreadPlan__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThreadPlan, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBThreadPlan__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + return _wrap_new_SBThreadPlan__SWIG_2(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBThreadPlan__SWIG_3(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBThreadPlan_IsValid__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBThreadPlan::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::IsValid",1,"lldb::SBThreadPlan const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){ + SWIG_fail_ptr("SBThreadPlan_IsValid",1,SWIGTYPE_p_lldb__SBThreadPlan); + } + + result = (bool)((lldb::SBThreadPlan const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThreadPlan_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + + SWIG_check_num_args("lldb::SBThreadPlan::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::Clear",1,"lldb::SBThreadPlan *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){ + SWIG_fail_ptr("SBThreadPlan_Clear",1,SWIGTYPE_p_lldb__SBThreadPlan); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThreadPlan_GetStopReason(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + lldb::StopReason result; + + SWIG_check_num_args("lldb::SBThreadPlan::GetStopReason",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::GetStopReason",1,"lldb::SBThreadPlan *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){ + SWIG_fail_ptr("SBThreadPlan_GetStopReason",1,SWIGTYPE_p_lldb__SBThreadPlan); + } + + result = (lldb::StopReason)(arg1)->GetStopReason(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThreadPlan_GetStopReasonDataCount(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + size_t result; + + SWIG_check_num_args("lldb::SBThreadPlan::GetStopReasonDataCount",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::GetStopReasonDataCount",1,"lldb::SBThreadPlan *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){ + SWIG_fail_ptr("SBThreadPlan_GetStopReasonDataCount",1,SWIGTYPE_p_lldb__SBThreadPlan); + } + + result = (arg1)->GetStopReasonDataCount(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThreadPlan_GetStopReasonDataAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + uint32_t arg2 ; + uint64_t result; + + SWIG_check_num_args("lldb::SBThreadPlan::GetStopReasonDataAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::GetStopReasonDataAtIndex",1,"lldb::SBThreadPlan *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBThreadPlan::GetStopReasonDataAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){ + SWIG_fail_ptr("SBThreadPlan_GetStopReasonDataAtIndex",1,SWIGTYPE_p_lldb__SBThreadPlan); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (uint64_t)(arg1)->GetStopReasonDataAtIndex(arg2); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThreadPlan_GetThread(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + lldb::SBThread result; + + SWIG_check_num_args("lldb::SBThreadPlan::GetThread",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::GetThread",1,"lldb::SBThreadPlan const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){ + SWIG_fail_ptr("SBThreadPlan_GetThread",1,SWIGTYPE_p_lldb__SBThreadPlan); + } + + result = ((lldb::SBThreadPlan const *)arg1)->GetThread(); + { + lldb::SBThread * resultptr = new lldb::SBThread(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThread,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThreadPlan_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBThreadPlan::GetDescription",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::GetDescription",1,"lldb::SBThreadPlan const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThreadPlan::GetDescription",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){ + SWIG_fail_ptr("SBThreadPlan_GetDescription",1,SWIGTYPE_p_lldb__SBThreadPlan); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBThreadPlan_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)((lldb::SBThreadPlan const *)arg1)->GetDescription(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThreadPlan_SetPlanComplete(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBThreadPlan::SetPlanComplete",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::SetPlanComplete",1,"lldb::SBThreadPlan *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBThreadPlan::SetPlanComplete",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){ + SWIG_fail_ptr("SBThreadPlan_SetPlanComplete",1,SWIGTYPE_p_lldb__SBThreadPlan); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetPlanComplete(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThreadPlan_IsPlanComplete(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBThreadPlan::IsPlanComplete",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::IsPlanComplete",1,"lldb::SBThreadPlan *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){ + SWIG_fail_ptr("SBThreadPlan_IsPlanComplete",1,SWIGTYPE_p_lldb__SBThreadPlan); + } + + result = (bool)(arg1)->IsPlanComplete(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThreadPlan_IsPlanStale(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBThreadPlan::IsPlanStale",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::IsPlanStale",1,"lldb::SBThreadPlan *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){ + SWIG_fail_ptr("SBThreadPlan_IsPlanStale",1,SWIGTYPE_p_lldb__SBThreadPlan); + } + + result = (bool)(arg1)->IsPlanStale(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThreadPlan_IsValid__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBThreadPlan::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::IsValid",1,"lldb::SBThreadPlan *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){ + SWIG_fail_ptr("SBThreadPlan_IsValid",1,SWIGTYPE_p_lldb__SBThreadPlan); + } + + result = (bool)(arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThreadPlan_IsValid(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThreadPlan, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBThreadPlan_IsValid__SWIG_1(L); + } + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThreadPlan, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBThreadPlan_IsValid__SWIG_0(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBThreadPlan_IsValid'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBThreadPlan::IsValid() const\n" + " lldb::SBThreadPlan::IsValid()\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBThreadPlan_GetStopOthers(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBThreadPlan::GetStopOthers",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::GetStopOthers",1,"lldb::SBThreadPlan *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){ + SWIG_fail_ptr("SBThreadPlan_GetStopOthers",1,SWIGTYPE_p_lldb__SBThreadPlan); + } + + result = (bool)(arg1)->GetStopOthers(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThreadPlan_SetStopOthers(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBThreadPlan::SetStopOthers",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::SetStopOthers",1,"lldb::SBThreadPlan *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBThreadPlan::SetStopOthers",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){ + SWIG_fail_ptr("SBThreadPlan_SetStopOthers",1,SWIGTYPE_p_lldb__SBThreadPlan); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetStopOthers(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThreadPlan_QueueThreadPlanForStepOverRange__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + lldb::SBAddress *arg2 = 0 ; + lldb::addr_t arg3 ; + lldb::SBThreadPlan result; + + SWIG_check_num_args("lldb::SBThreadPlan::QueueThreadPlanForStepOverRange",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepOverRange",1,"lldb::SBThreadPlan *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepOverRange",2,"lldb::SBAddress &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepOverRange",3,"lldb::addr_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){ + SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForStepOverRange",1,SWIGTYPE_p_lldb__SBThreadPlan); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForStepOverRange",2,SWIGTYPE_p_lldb__SBAddress); + } + + arg3 = (lldb::addr_t)lua_tointeger(L, 3); + result = (arg1)->QueueThreadPlanForStepOverRange(*arg2,arg3); + { + lldb::SBThreadPlan * resultptr = new lldb::SBThreadPlan(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThreadPlan,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThreadPlan_QueueThreadPlanForStepOverRange__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + lldb::SBAddress *arg2 = 0 ; + lldb::addr_t arg3 ; + lldb::SBError *arg4 = 0 ; + lldb::SBThreadPlan result; + + SWIG_check_num_args("lldb::SBThreadPlan::QueueThreadPlanForStepOverRange",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepOverRange",1,"lldb::SBThreadPlan *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepOverRange",2,"lldb::SBAddress &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepOverRange",3,"lldb::addr_t"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepOverRange",4,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){ + SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForStepOverRange",1,SWIGTYPE_p_lldb__SBThreadPlan); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForStepOverRange",2,SWIGTYPE_p_lldb__SBAddress); + } + + arg3 = (lldb::addr_t)lua_tointeger(L, 3); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForStepOverRange",4,SWIGTYPE_p_lldb__SBError); + } + + result = (arg1)->QueueThreadPlanForStepOverRange(*arg2,arg3,*arg4); + { + lldb::SBThreadPlan * resultptr = new lldb::SBThreadPlan(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThreadPlan,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThreadPlan_QueueThreadPlanForStepOverRange(lua_State* L) { + int argc; + int argv[5]={ + 1,2,3,4,5 + }; + + argc = lua_gettop(L); + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThreadPlan, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + return _wrap_SBThreadPlan_QueueThreadPlanForStepOverRange__SWIG_0(L); + } + } + } + } + if (argc == 4) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThreadPlan, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBThreadPlan_QueueThreadPlanForStepOverRange__SWIG_1(L); + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBThreadPlan_QueueThreadPlanForStepInRange__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + lldb::SBAddress *arg2 = 0 ; + lldb::addr_t arg3 ; + lldb::SBThreadPlan result; + + SWIG_check_num_args("lldb::SBThreadPlan::QueueThreadPlanForStepInRange",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepInRange",1,"lldb::SBThreadPlan *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepInRange",2,"lldb::SBAddress &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepInRange",3,"lldb::addr_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){ + SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForStepInRange",1,SWIGTYPE_p_lldb__SBThreadPlan); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForStepInRange",2,SWIGTYPE_p_lldb__SBAddress); + } + + arg3 = (lldb::addr_t)lua_tointeger(L, 3); + result = (arg1)->QueueThreadPlanForStepInRange(*arg2,arg3); + { + lldb::SBThreadPlan * resultptr = new lldb::SBThreadPlan(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThreadPlan,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThreadPlan_QueueThreadPlanForStepInRange__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + lldb::SBAddress *arg2 = 0 ; + lldb::addr_t arg3 ; + lldb::SBError *arg4 = 0 ; + lldb::SBThreadPlan result; + + SWIG_check_num_args("lldb::SBThreadPlan::QueueThreadPlanForStepInRange",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepInRange",1,"lldb::SBThreadPlan *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepInRange",2,"lldb::SBAddress &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepInRange",3,"lldb::addr_t"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepInRange",4,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){ + SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForStepInRange",1,SWIGTYPE_p_lldb__SBThreadPlan); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForStepInRange",2,SWIGTYPE_p_lldb__SBAddress); + } + + arg3 = (lldb::addr_t)lua_tointeger(L, 3); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForStepInRange",4,SWIGTYPE_p_lldb__SBError); + } + + result = (arg1)->QueueThreadPlanForStepInRange(*arg2,arg3,*arg4); + { + lldb::SBThreadPlan * resultptr = new lldb::SBThreadPlan(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThreadPlan,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThreadPlan_QueueThreadPlanForStepInRange(lua_State* L) { + int argc; + int argv[5]={ + 1,2,3,4,5 + }; + + argc = lua_gettop(L); + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThreadPlan, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + return _wrap_SBThreadPlan_QueueThreadPlanForStepInRange__SWIG_0(L); + } + } + } + } + if (argc == 4) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThreadPlan, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBThreadPlan_QueueThreadPlanForStepInRange__SWIG_1(L); + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBThreadPlan_QueueThreadPlanForStepOut__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + uint32_t arg2 ; + bool arg3 ; + lldb::SBThreadPlan result; + + SWIG_check_num_args("lldb::SBThreadPlan::QueueThreadPlanForStepOut",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepOut",1,"lldb::SBThreadPlan *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepOut",2,"uint32_t"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepOut",3,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){ + SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForStepOut",1,SWIGTYPE_p_lldb__SBThreadPlan); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + arg3 = (lua_toboolean(L, 3)!=0); + result = (arg1)->QueueThreadPlanForStepOut(arg2,arg3); + { + lldb::SBThreadPlan * resultptr = new lldb::SBThreadPlan(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThreadPlan,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThreadPlan_QueueThreadPlanForStepOut__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + uint32_t arg2 ; + lldb::SBThreadPlan result; + + SWIG_check_num_args("lldb::SBThreadPlan::QueueThreadPlanForStepOut",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepOut",1,"lldb::SBThreadPlan *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepOut",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){ + SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForStepOut",1,SWIGTYPE_p_lldb__SBThreadPlan); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->QueueThreadPlanForStepOut(arg2); + { + lldb::SBThreadPlan * resultptr = new lldb::SBThreadPlan(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThreadPlan,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThreadPlan_QueueThreadPlanForStepOut__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + uint32_t arg2 ; + bool arg3 ; + lldb::SBError *arg4 = 0 ; + lldb::SBThreadPlan result; + + SWIG_check_num_args("lldb::SBThreadPlan::QueueThreadPlanForStepOut",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepOut",1,"lldb::SBThreadPlan *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepOut",2,"uint32_t"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepOut",3,"bool"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepOut",4,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){ + SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForStepOut",1,SWIGTYPE_p_lldb__SBThreadPlan); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + arg3 = (lua_toboolean(L, 3)!=0); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForStepOut",4,SWIGTYPE_p_lldb__SBError); + } + + result = (arg1)->QueueThreadPlanForStepOut(arg2,arg3,*arg4); + { + lldb::SBThreadPlan * resultptr = new lldb::SBThreadPlan(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThreadPlan,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThreadPlan_QueueThreadPlanForStepOut(lua_State* L) { + int argc; + int argv[5]={ + 1,2,3,4,5 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThreadPlan, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_SBThreadPlan_QueueThreadPlanForStepOut__SWIG_1(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThreadPlan, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[2]); + } + if (_v) { + return _wrap_SBThreadPlan_QueueThreadPlanForStepOut__SWIG_0(L); + } + } + } + } + if (argc == 4) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThreadPlan, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[2]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBThreadPlan_QueueThreadPlanForStepOut__SWIG_2(L); + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBThreadPlan_QueueThreadPlanForRunToAddress__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + lldb::SBAddress arg2 ; + lldb::SBAddress *argp2 ; + lldb::SBThreadPlan result; + + SWIG_check_num_args("lldb::SBThreadPlan::QueueThreadPlanForRunToAddress",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForRunToAddress",1,"lldb::SBThreadPlan *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForRunToAddress",2,"lldb::SBAddress"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){ + SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForRunToAddress",1,SWIGTYPE_p_lldb__SBThreadPlan); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForRunToAddress",2,SWIGTYPE_p_lldb__SBAddress); + } + arg2 = *argp2; + + result = (arg1)->QueueThreadPlanForRunToAddress(arg2); + { + lldb::SBThreadPlan * resultptr = new lldb::SBThreadPlan(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThreadPlan,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThreadPlan_QueueThreadPlanForRunToAddress__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + lldb::SBAddress arg2 ; + lldb::SBError *arg3 = 0 ; + lldb::SBAddress *argp2 ; + lldb::SBThreadPlan result; + + SWIG_check_num_args("lldb::SBThreadPlan::QueueThreadPlanForRunToAddress",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForRunToAddress",1,"lldb::SBThreadPlan *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForRunToAddress",2,"lldb::SBAddress"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForRunToAddress",3,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){ + SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForRunToAddress",1,SWIGTYPE_p_lldb__SBThreadPlan); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBAddress,0))){ + SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForRunToAddress",2,SWIGTYPE_p_lldb__SBAddress); + } + arg2 = *argp2; + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForRunToAddress",3,SWIGTYPE_p_lldb__SBError); + } + + result = (arg1)->QueueThreadPlanForRunToAddress(arg2,*arg3); + { + lldb::SBThreadPlan * resultptr = new lldb::SBThreadPlan(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThreadPlan,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThreadPlan_QueueThreadPlanForRunToAddress(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThreadPlan, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBThreadPlan_QueueThreadPlanForRunToAddress__SWIG_0(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThreadPlan, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBAddress, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBThreadPlan_QueueThreadPlanForRunToAddress__SWIG_1(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBThreadPlan_QueueThreadPlanForStepScripted__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBThreadPlan result; + + SWIG_check_num_args("lldb::SBThreadPlan::QueueThreadPlanForStepScripted",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepScripted",1,"lldb::SBThreadPlan *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepScripted",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){ + SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForStepScripted",1,SWIGTYPE_p_lldb__SBThreadPlan); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->QueueThreadPlanForStepScripted((char const *)arg2); + { + lldb::SBThreadPlan * resultptr = new lldb::SBThreadPlan(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThreadPlan,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThreadPlan_QueueThreadPlanForStepScripted__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBError *arg3 = 0 ; + lldb::SBThreadPlan result; + + SWIG_check_num_args("lldb::SBThreadPlan::QueueThreadPlanForStepScripted",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepScripted",1,"lldb::SBThreadPlan *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepScripted",2,"char const *"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepScripted",3,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){ + SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForStepScripted",1,SWIGTYPE_p_lldb__SBThreadPlan); + } + + arg2 = (char *)lua_tostring(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForStepScripted",3,SWIGTYPE_p_lldb__SBError); + } + + result = (arg1)->QueueThreadPlanForStepScripted((char const *)arg2,*arg3); + { + lldb::SBThreadPlan * resultptr = new lldb::SBThreadPlan(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThreadPlan,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThreadPlan_QueueThreadPlanForStepScripted__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBStructuredData *arg3 = 0 ; + lldb::SBError *arg4 = 0 ; + lldb::SBThreadPlan result; + + SWIG_check_num_args("lldb::SBThreadPlan::QueueThreadPlanForStepScripted",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepScripted",1,"lldb::SBThreadPlan *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepScripted",2,"char const *"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepScripted",3,"lldb::SBStructuredData &"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBThreadPlan::QueueThreadPlanForStepScripted",4,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBThreadPlan,0))){ + SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForStepScripted",1,SWIGTYPE_p_lldb__SBThreadPlan); + } + + arg2 = (char *)lua_tostring(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForStepScripted",3,SWIGTYPE_p_lldb__SBStructuredData); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBThreadPlan_QueueThreadPlanForStepScripted",4,SWIGTYPE_p_lldb__SBError); + } + + result = (arg1)->QueueThreadPlanForStepScripted((char const *)arg2,*arg3,*arg4); + { + lldb::SBThreadPlan * resultptr = new lldb::SBThreadPlan(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThreadPlan,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBThreadPlan_QueueThreadPlanForStepScripted(lua_State* L) { + int argc; + int argv[5]={ + 1,2,3,4,5 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThreadPlan, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + return _wrap_SBThreadPlan_QueueThreadPlanForStepScripted__SWIG_0(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThreadPlan, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBThreadPlan_QueueThreadPlanForStepScripted__SWIG_1(L); + } + } + } + } + if (argc == 4) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBThreadPlan, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBThreadPlan_QueueThreadPlanForStepScripted__SWIG_2(L); + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static void swig_delete_SBThreadPlan(void *obj) { +lldb::SBThreadPlan *arg1 = (lldb::SBThreadPlan *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBThreadPlan(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBThreadPlan); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBThreadPlan_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBThreadPlan_methods[]= { + { "Clear", _wrap_SBThreadPlan_Clear}, + { "GetStopReason", _wrap_SBThreadPlan_GetStopReason}, + { "GetStopReasonDataCount", _wrap_SBThreadPlan_GetStopReasonDataCount}, + { "GetStopReasonDataAtIndex", _wrap_SBThreadPlan_GetStopReasonDataAtIndex}, + { "GetThread", _wrap_SBThreadPlan_GetThread}, + { "GetDescription", _wrap_SBThreadPlan_GetDescription}, + { "SetPlanComplete", _wrap_SBThreadPlan_SetPlanComplete}, + { "IsPlanComplete", _wrap_SBThreadPlan_IsPlanComplete}, + { "IsPlanStale", _wrap_SBThreadPlan_IsPlanStale}, + { "IsValid", _wrap_SBThreadPlan_IsValid}, + { "GetStopOthers", _wrap_SBThreadPlan_GetStopOthers}, + { "SetStopOthers", _wrap_SBThreadPlan_SetStopOthers}, + { "QueueThreadPlanForStepOverRange", _wrap_SBThreadPlan_QueueThreadPlanForStepOverRange}, + { "QueueThreadPlanForStepInRange", _wrap_SBThreadPlan_QueueThreadPlanForStepInRange}, + { "QueueThreadPlanForStepOut", _wrap_SBThreadPlan_QueueThreadPlanForStepOut}, + { "QueueThreadPlanForRunToAddress", _wrap_SBThreadPlan_QueueThreadPlanForRunToAddress}, + { "QueueThreadPlanForStepScripted", _wrap_SBThreadPlan_QueueThreadPlanForStepScripted}, + {0,0} +}; +static swig_lua_method swig_SBThreadPlan_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBThreadPlan_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBThreadPlan_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBThreadPlan_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBThreadPlan_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBThreadPlan_Sf_SwigStatic = { + "SBThreadPlan", + swig_SBThreadPlan_Sf_SwigStatic_methods, + swig_SBThreadPlan_Sf_SwigStatic_attributes, + swig_SBThreadPlan_Sf_SwigStatic_constants, + swig_SBThreadPlan_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBThreadPlan_bases[] = {0}; +static const char *swig_SBThreadPlan_base_names[] = {0}; +static swig_lua_class _wrap_class_SBThreadPlan = { "SBThreadPlan", "SBThreadPlan", &SWIGTYPE_p_lldb__SBThreadPlan,_proxy__wrap_new_SBThreadPlan, swig_delete_SBThreadPlan, swig_SBThreadPlan_methods, swig_SBThreadPlan_attributes, &swig_SBThreadPlan_Sf_SwigStatic, swig_SBThreadPlan_meta, swig_SBThreadPlan_bases, swig_SBThreadPlan_base_names }; + +static int _wrap_new_SBTrace(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTrace *result = 0 ; + + SWIG_check_num_args("lldb::SBTrace::SBTrace",0,0) + result = (lldb::SBTrace *)new lldb::SBTrace(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTrace,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTrace_LoadTraceFromFile(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBError *arg1 = 0 ; + lldb::SBDebugger *arg2 = 0 ; + lldb::SBFileSpec *arg3 = 0 ; + lldb::SBTrace result; + + SWIG_check_num_args("lldb::SBTrace::LoadTraceFromFile",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBTrace::LoadTraceFromFile",1,"lldb::SBError &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTrace::LoadTraceFromFile",2,"lldb::SBDebugger &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTrace::LoadTraceFromFile",3,"lldb::SBFileSpec const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBTrace_LoadTraceFromFile",1,SWIGTYPE_p_lldb__SBError); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBDebugger,0))){ + SWIG_fail_ptr("SBTrace_LoadTraceFromFile",2,SWIGTYPE_p_lldb__SBDebugger); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBTrace_LoadTraceFromFile",3,SWIGTYPE_p_lldb__SBFileSpec); + } + + result = lldb::SBTrace::LoadTraceFromFile(*arg1,*arg2,(lldb::SBFileSpec const &)*arg3); + { + lldb::SBTrace * resultptr = new lldb::SBTrace(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTrace,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTrace_CreateNewCursor(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTrace *arg1 = (lldb::SBTrace *) 0 ; + lldb::SBError *arg2 = 0 ; + lldb::SBThread *arg3 = 0 ; + lldb::SBTraceCursor result; + + SWIG_check_num_args("lldb::SBTrace::CreateNewCursor",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTrace::CreateNewCursor",1,"lldb::SBTrace *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTrace::CreateNewCursor",2,"lldb::SBError &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTrace::CreateNewCursor",3,"lldb::SBThread &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTrace,0))){ + SWIG_fail_ptr("SBTrace_CreateNewCursor",1,SWIGTYPE_p_lldb__SBTrace); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBTrace_CreateNewCursor",2,SWIGTYPE_p_lldb__SBError); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBTrace_CreateNewCursor",3,SWIGTYPE_p_lldb__SBThread); + } + + result = (arg1)->CreateNewCursor(*arg2,*arg3); + { + lldb::SBTraceCursor * resultptr = new lldb::SBTraceCursor(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTraceCursor,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTrace_SaveToDisk__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTrace *arg1 = (lldb::SBTrace *) 0 ; + lldb::SBError *arg2 = 0 ; + lldb::SBFileSpec *arg3 = 0 ; + bool arg4 ; + lldb::SBFileSpec result; + + SWIG_check_num_args("lldb::SBTrace::SaveToDisk",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTrace::SaveToDisk",1,"lldb::SBTrace *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTrace::SaveToDisk",2,"lldb::SBError &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTrace::SaveToDisk",3,"lldb::SBFileSpec const &"); + if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBTrace::SaveToDisk",4,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTrace,0))){ + SWIG_fail_ptr("SBTrace_SaveToDisk",1,SWIGTYPE_p_lldb__SBTrace); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBTrace_SaveToDisk",2,SWIGTYPE_p_lldb__SBError); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBTrace_SaveToDisk",3,SWIGTYPE_p_lldb__SBFileSpec); + } + + arg4 = (lua_toboolean(L, 4)!=0); + result = (arg1)->SaveToDisk(*arg2,(lldb::SBFileSpec const &)*arg3,arg4); + { + lldb::SBFileSpec * resultptr = new lldb::SBFileSpec(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTrace_SaveToDisk__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTrace *arg1 = (lldb::SBTrace *) 0 ; + lldb::SBError *arg2 = 0 ; + lldb::SBFileSpec *arg3 = 0 ; + lldb::SBFileSpec result; + + SWIG_check_num_args("lldb::SBTrace::SaveToDisk",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTrace::SaveToDisk",1,"lldb::SBTrace *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTrace::SaveToDisk",2,"lldb::SBError &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTrace::SaveToDisk",3,"lldb::SBFileSpec const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTrace,0))){ + SWIG_fail_ptr("SBTrace_SaveToDisk",1,SWIGTYPE_p_lldb__SBTrace); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBTrace_SaveToDisk",2,SWIGTYPE_p_lldb__SBError); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBFileSpec,0))){ + SWIG_fail_ptr("SBTrace_SaveToDisk",3,SWIGTYPE_p_lldb__SBFileSpec); + } + + result = (arg1)->SaveToDisk(*arg2,(lldb::SBFileSpec const &)*arg3); + { + lldb::SBFileSpec * resultptr = new lldb::SBFileSpec(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFileSpec,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTrace_SaveToDisk(lua_State* L) { + int argc; + int argv[5]={ + 1,2,3,4,5 + }; + + argc = lua_gettop(L); + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTrace, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBTrace_SaveToDisk__SWIG_1(L); + } + } + } + } + if (argc == 4) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTrace, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBFileSpec, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[3]); + } + if (_v) { + return _wrap_SBTrace_SaveToDisk__SWIG_0(L); + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBTrace_GetStartConfigurationHelp(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTrace *arg1 = (lldb::SBTrace *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBTrace::GetStartConfigurationHelp",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTrace::GetStartConfigurationHelp",1,"lldb::SBTrace *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTrace,0))){ + SWIG_fail_ptr("SBTrace_GetStartConfigurationHelp",1,SWIGTYPE_p_lldb__SBTrace); + } + + result = (char *)(arg1)->GetStartConfigurationHelp(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTrace_Start__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTrace *arg1 = (lldb::SBTrace *) 0 ; + lldb::SBStructuredData *arg2 = 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBTrace::Start",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTrace::Start",1,"lldb::SBTrace *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTrace::Start",2,"lldb::SBStructuredData const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTrace,0))){ + SWIG_fail_ptr("SBTrace_Start",1,SWIGTYPE_p_lldb__SBTrace); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("SBTrace_Start",2,SWIGTYPE_p_lldb__SBStructuredData); + } + + result = (arg1)->Start((lldb::SBStructuredData const &)*arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTrace_Start__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTrace *arg1 = (lldb::SBTrace *) 0 ; + lldb::SBThread *arg2 = 0 ; + lldb::SBStructuredData *arg3 = 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBTrace::Start",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTrace::Start",1,"lldb::SBTrace *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTrace::Start",2,"lldb::SBThread const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTrace::Start",3,"lldb::SBStructuredData const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTrace,0))){ + SWIG_fail_ptr("SBTrace_Start",1,SWIGTYPE_p_lldb__SBTrace); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBTrace_Start",2,SWIGTYPE_p_lldb__SBThread); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBStructuredData,0))){ + SWIG_fail_ptr("SBTrace_Start",3,SWIGTYPE_p_lldb__SBStructuredData); + } + + result = (arg1)->Start((lldb::SBThread const &)*arg2,(lldb::SBStructuredData const &)*arg3); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTrace_Start(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTrace, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBTrace_Start__SWIG_0(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTrace, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBStructuredData, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBTrace_Start__SWIG_1(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBTrace_Stop__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTrace *arg1 = (lldb::SBTrace *) 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBTrace::Stop",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTrace::Stop",1,"lldb::SBTrace *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTrace,0))){ + SWIG_fail_ptr("SBTrace_Stop",1,SWIGTYPE_p_lldb__SBTrace); + } + + result = (arg1)->Stop(); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTrace_Stop__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTrace *arg1 = (lldb::SBTrace *) 0 ; + lldb::SBThread *arg2 = 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBTrace::Stop",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTrace::Stop",1,"lldb::SBTrace *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTrace::Stop",2,"lldb::SBThread const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTrace,0))){ + SWIG_fail_ptr("SBTrace_Stop",1,SWIGTYPE_p_lldb__SBTrace); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBThread,0))){ + SWIG_fail_ptr("SBTrace_Stop",2,SWIGTYPE_p_lldb__SBThread); + } + + result = (arg1)->Stop((lldb::SBThread const &)*arg2); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTrace_Stop(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTrace, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBTrace_Stop__SWIG_0(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTrace, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBThread, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBTrace_Stop__SWIG_1(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBTrace_Stop'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBTrace::Stop()\n" + " lldb::SBTrace::Stop(lldb::SBThread const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBTrace_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTrace *arg1 = (lldb::SBTrace *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTrace::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTrace::IsValid",1,"lldb::SBTrace *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTrace,0))){ + SWIG_fail_ptr("SBTrace_IsValid",1,SWIGTYPE_p_lldb__SBTrace); + } + + result = (bool)(arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBTrace(void *obj) { +lldb::SBTrace *arg1 = (lldb::SBTrace *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBTrace(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBTrace); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBTrace_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBTrace_methods[]= { + { "CreateNewCursor", _wrap_SBTrace_CreateNewCursor}, + { "SaveToDisk", _wrap_SBTrace_SaveToDisk}, + { "GetStartConfigurationHelp", _wrap_SBTrace_GetStartConfigurationHelp}, + { "Start", _wrap_SBTrace_Start}, + { "Stop", _wrap_SBTrace_Stop}, + { "IsValid", _wrap_SBTrace_IsValid}, + {0,0} +}; +static swig_lua_method swig_SBTrace_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBTrace_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBTrace_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBTrace_Sf_SwigStatic_methods[]= { + { "LoadTraceFromFile", _wrap_SBTrace_LoadTraceFromFile}, + {0,0} +}; +static swig_lua_class* swig_SBTrace_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBTrace_Sf_SwigStatic = { + "SBTrace", + swig_SBTrace_Sf_SwigStatic_methods, + swig_SBTrace_Sf_SwigStatic_attributes, + swig_SBTrace_Sf_SwigStatic_constants, + swig_SBTrace_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBTrace_bases[] = {0}; +static const char *swig_SBTrace_base_names[] = {0}; +static swig_lua_class _wrap_class_SBTrace = { "SBTrace", "SBTrace", &SWIGTYPE_p_lldb__SBTrace,_proxy__wrap_new_SBTrace, swig_delete_SBTrace, swig_SBTrace_methods, swig_SBTrace_attributes, &swig_SBTrace_Sf_SwigStatic, swig_SBTrace_meta, swig_SBTrace_bases, swig_SBTrace_base_names }; + +static int _wrap_new_SBTraceCursor(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTraceCursor *result = 0 ; + + SWIG_check_num_args("lldb::SBTraceCursor::SBTraceCursor",0,0) + result = (lldb::SBTraceCursor *)new lldb::SBTraceCursor(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTraceCursor,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTraceCursor_SetForwards(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBTraceCursor::SetForwards",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTraceCursor::SetForwards",1,"lldb::SBTraceCursor *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBTraceCursor::SetForwards",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTraceCursor,0))){ + SWIG_fail_ptr("SBTraceCursor_SetForwards",1,SWIGTYPE_p_lldb__SBTraceCursor); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetForwards(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTraceCursor_IsForwards(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTraceCursor::IsForwards",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTraceCursor::IsForwards",1,"lldb::SBTraceCursor const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTraceCursor,0))){ + SWIG_fail_ptr("SBTraceCursor_IsForwards",1,SWIGTYPE_p_lldb__SBTraceCursor); + } + + result = (bool)((lldb::SBTraceCursor const *)arg1)->IsForwards(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTraceCursor_Next(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + + SWIG_check_num_args("lldb::SBTraceCursor::Next",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTraceCursor::Next",1,"lldb::SBTraceCursor *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTraceCursor,0))){ + SWIG_fail_ptr("SBTraceCursor_Next",1,SWIGTYPE_p_lldb__SBTraceCursor); + } + + (arg1)->Next(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTraceCursor_HasValue(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTraceCursor::HasValue",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTraceCursor::HasValue",1,"lldb::SBTraceCursor const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTraceCursor,0))){ + SWIG_fail_ptr("SBTraceCursor_HasValue",1,SWIGTYPE_p_lldb__SBTraceCursor); + } + + result = (bool)((lldb::SBTraceCursor const *)arg1)->HasValue(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTraceCursor_GoToId(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + lldb::user_id_t arg2 ; + bool result; + + SWIG_check_num_args("lldb::SBTraceCursor::GoToId",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTraceCursor::GoToId",1,"lldb::SBTraceCursor *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTraceCursor::GoToId",2,"lldb::user_id_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTraceCursor,0))){ + SWIG_fail_ptr("SBTraceCursor_GoToId",1,SWIGTYPE_p_lldb__SBTraceCursor); + } + + arg2 = (lldb::user_id_t)lua_tointeger(L, 2); + result = (bool)(arg1)->GoToId(arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTraceCursor_HasId(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + lldb::user_id_t arg2 ; + bool result; + + SWIG_check_num_args("lldb::SBTraceCursor::HasId",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTraceCursor::HasId",1,"lldb::SBTraceCursor const *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTraceCursor::HasId",2,"lldb::user_id_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTraceCursor,0))){ + SWIG_fail_ptr("SBTraceCursor_HasId",1,SWIGTYPE_p_lldb__SBTraceCursor); + } + + arg2 = (lldb::user_id_t)lua_tointeger(L, 2); + result = (bool)((lldb::SBTraceCursor const *)arg1)->HasId(arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTraceCursor_GetId(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + lldb::user_id_t result; + + SWIG_check_num_args("lldb::SBTraceCursor::GetId",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTraceCursor::GetId",1,"lldb::SBTraceCursor const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTraceCursor,0))){ + SWIG_fail_ptr("SBTraceCursor_GetId",1,SWIGTYPE_p_lldb__SBTraceCursor); + } + + result = (lldb::user_id_t)((lldb::SBTraceCursor const *)arg1)->GetId(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTraceCursor_Seek(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + int64_t arg2 ; + lldb::TraceCursorSeekType arg3 ; + bool result; + + SWIG_check_num_args("lldb::SBTraceCursor::Seek",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTraceCursor::Seek",1,"lldb::SBTraceCursor *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTraceCursor::Seek",2,"int64_t"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTraceCursor::Seek",3,"lldb::TraceCursorSeekType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTraceCursor,0))){ + SWIG_fail_ptr("SBTraceCursor_Seek",1,SWIGTYPE_p_lldb__SBTraceCursor); + } + + arg2 = (int64_t)lua_tointeger(L, 2); + arg3 = (lldb::TraceCursorSeekType)lua_tointeger(L, 3); + result = (bool)(arg1)->Seek(arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTraceCursor_GetItemKind(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + lldb::TraceItemKind result; + + SWIG_check_num_args("lldb::SBTraceCursor::GetItemKind",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTraceCursor::GetItemKind",1,"lldb::SBTraceCursor const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTraceCursor,0))){ + SWIG_fail_ptr("SBTraceCursor_GetItemKind",1,SWIGTYPE_p_lldb__SBTraceCursor); + } + + result = (lldb::TraceItemKind)((lldb::SBTraceCursor const *)arg1)->GetItemKind(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTraceCursor_IsError(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTraceCursor::IsError",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTraceCursor::IsError",1,"lldb::SBTraceCursor const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTraceCursor,0))){ + SWIG_fail_ptr("SBTraceCursor_IsError",1,SWIGTYPE_p_lldb__SBTraceCursor); + } + + result = (bool)((lldb::SBTraceCursor const *)arg1)->IsError(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTraceCursor_GetError(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBTraceCursor::GetError",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTraceCursor::GetError",1,"lldb::SBTraceCursor const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTraceCursor,0))){ + SWIG_fail_ptr("SBTraceCursor_GetError",1,SWIGTYPE_p_lldb__SBTraceCursor); + } + + result = (char *)((lldb::SBTraceCursor const *)arg1)->GetError(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTraceCursor_IsEvent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTraceCursor::IsEvent",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTraceCursor::IsEvent",1,"lldb::SBTraceCursor const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTraceCursor,0))){ + SWIG_fail_ptr("SBTraceCursor_IsEvent",1,SWIGTYPE_p_lldb__SBTraceCursor); + } + + result = (bool)((lldb::SBTraceCursor const *)arg1)->IsEvent(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTraceCursor_GetEventType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + lldb::TraceEvent result; + + SWIG_check_num_args("lldb::SBTraceCursor::GetEventType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTraceCursor::GetEventType",1,"lldb::SBTraceCursor const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTraceCursor,0))){ + SWIG_fail_ptr("SBTraceCursor_GetEventType",1,SWIGTYPE_p_lldb__SBTraceCursor); + } + + result = (lldb::TraceEvent)((lldb::SBTraceCursor const *)arg1)->GetEventType(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTraceCursor_GetEventTypeAsString(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBTraceCursor::GetEventTypeAsString",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTraceCursor::GetEventTypeAsString",1,"lldb::SBTraceCursor const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTraceCursor,0))){ + SWIG_fail_ptr("SBTraceCursor_GetEventTypeAsString",1,SWIGTYPE_p_lldb__SBTraceCursor); + } + + result = (char *)((lldb::SBTraceCursor const *)arg1)->GetEventTypeAsString(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTraceCursor_IsInstruction(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTraceCursor::IsInstruction",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTraceCursor::IsInstruction",1,"lldb::SBTraceCursor const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTraceCursor,0))){ + SWIG_fail_ptr("SBTraceCursor_IsInstruction",1,SWIGTYPE_p_lldb__SBTraceCursor); + } + + result = (bool)((lldb::SBTraceCursor const *)arg1)->IsInstruction(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTraceCursor_GetLoadAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + lldb::addr_t result; + + SWIG_check_num_args("lldb::SBTraceCursor::GetLoadAddress",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTraceCursor::GetLoadAddress",1,"lldb::SBTraceCursor const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTraceCursor,0))){ + SWIG_fail_ptr("SBTraceCursor_GetLoadAddress",1,SWIGTYPE_p_lldb__SBTraceCursor); + } + + result = (lldb::addr_t)((lldb::SBTraceCursor const *)arg1)->GetLoadAddress(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTraceCursor_GetCPU(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + lldb::cpu_id_t result; + + SWIG_check_num_args("lldb::SBTraceCursor::GetCPU",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTraceCursor::GetCPU",1,"lldb::SBTraceCursor const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTraceCursor,0))){ + SWIG_fail_ptr("SBTraceCursor_GetCPU",1,SWIGTYPE_p_lldb__SBTraceCursor); + } + + result = (lldb::cpu_id_t)((lldb::SBTraceCursor const *)arg1)->GetCPU(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTraceCursor_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTraceCursor::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTraceCursor::IsValid",1,"lldb::SBTraceCursor const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTraceCursor,0))){ + SWIG_fail_ptr("SBTraceCursor_IsValid",1,SWIGTYPE_p_lldb__SBTraceCursor); + } + + result = (bool)((lldb::SBTraceCursor const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBTraceCursor(void *obj) { +lldb::SBTraceCursor *arg1 = (lldb::SBTraceCursor *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBTraceCursor(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBTraceCursor); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBTraceCursor_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBTraceCursor_methods[]= { + { "SetForwards", _wrap_SBTraceCursor_SetForwards}, + { "IsForwards", _wrap_SBTraceCursor_IsForwards}, + { "Next", _wrap_SBTraceCursor_Next}, + { "HasValue", _wrap_SBTraceCursor_HasValue}, + { "GoToId", _wrap_SBTraceCursor_GoToId}, + { "HasId", _wrap_SBTraceCursor_HasId}, + { "GetId", _wrap_SBTraceCursor_GetId}, + { "Seek", _wrap_SBTraceCursor_Seek}, + { "GetItemKind", _wrap_SBTraceCursor_GetItemKind}, + { "IsError", _wrap_SBTraceCursor_IsError}, + { "GetError", _wrap_SBTraceCursor_GetError}, + { "IsEvent", _wrap_SBTraceCursor_IsEvent}, + { "GetEventType", _wrap_SBTraceCursor_GetEventType}, + { "GetEventTypeAsString", _wrap_SBTraceCursor_GetEventTypeAsString}, + { "IsInstruction", _wrap_SBTraceCursor_IsInstruction}, + { "GetLoadAddress", _wrap_SBTraceCursor_GetLoadAddress}, + { "GetCPU", _wrap_SBTraceCursor_GetCPU}, + { "IsValid", _wrap_SBTraceCursor_IsValid}, + {0,0} +}; +static swig_lua_method swig_SBTraceCursor_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBTraceCursor_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBTraceCursor_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBTraceCursor_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBTraceCursor_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBTraceCursor_Sf_SwigStatic = { + "SBTraceCursor", + swig_SBTraceCursor_Sf_SwigStatic_methods, + swig_SBTraceCursor_Sf_SwigStatic_attributes, + swig_SBTraceCursor_Sf_SwigStatic_constants, + swig_SBTraceCursor_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBTraceCursor_bases[] = {0}; +static const char *swig_SBTraceCursor_base_names[] = {0}; +static swig_lua_class _wrap_class_SBTraceCursor = { "SBTraceCursor", "SBTraceCursor", &SWIGTYPE_p_lldb__SBTraceCursor,_proxy__wrap_new_SBTraceCursor, swig_delete_SBTraceCursor, swig_SBTraceCursor_methods, swig_SBTraceCursor_attributes, &swig_SBTraceCursor_Sf_SwigStatic, swig_SBTraceCursor_meta, swig_SBTraceCursor_bases, swig_SBTraceCursor_base_names }; + +static int _wrap_new_SBTypeMember__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeMember *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeMember::SBTypeMember",0,0) + result = (lldb::SBTypeMember *)new lldb::SBTypeMember(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeMember,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBTypeMember__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeMember *arg1 = 0 ; + lldb::SBTypeMember *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeMember::SBTypeMember",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBTypeMember::SBTypeMember",1,"lldb::SBTypeMember const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMember,0))){ + SWIG_fail_ptr("new_SBTypeMember",1,SWIGTYPE_p_lldb__SBTypeMember); + } + + result = (lldb::SBTypeMember *)new lldb::SBTypeMember((lldb::SBTypeMember const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeMember,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBTypeMember(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBTypeMember__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTypeMember, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBTypeMember__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBTypeMember'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBTypeMember::SBTypeMember()\n" + " lldb::SBTypeMember::SBTypeMember(lldb::SBTypeMember const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBTypeMember_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeMember *arg1 = (lldb::SBTypeMember *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeMember::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMember::IsValid",1,"lldb::SBTypeMember const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMember,0))){ + SWIG_fail_ptr("SBTypeMember_IsValid",1,SWIGTYPE_p_lldb__SBTypeMember); + } + + result = (bool)((lldb::SBTypeMember const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeMember_GetName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeMember *arg1 = (lldb::SBTypeMember *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeMember::GetName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMember::GetName",1,"lldb::SBTypeMember *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMember,0))){ + SWIG_fail_ptr("SBTypeMember_GetName",1,SWIGTYPE_p_lldb__SBTypeMember); + } + + result = (char *)(arg1)->GetName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeMember_GetType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeMember *arg1 = (lldb::SBTypeMember *) 0 ; + lldb::SBType result; + + SWIG_check_num_args("lldb::SBTypeMember::GetType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMember::GetType",1,"lldb::SBTypeMember *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMember,0))){ + SWIG_fail_ptr("SBTypeMember_GetType",1,SWIGTYPE_p_lldb__SBTypeMember); + } + + result = (arg1)->GetType(); + { + lldb::SBType * resultptr = new lldb::SBType(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeMember_GetOffsetInBytes(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeMember *arg1 = (lldb::SBTypeMember *) 0 ; + uint64_t result; + + SWIG_check_num_args("lldb::SBTypeMember::GetOffsetInBytes",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMember::GetOffsetInBytes",1,"lldb::SBTypeMember *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMember,0))){ + SWIG_fail_ptr("SBTypeMember_GetOffsetInBytes",1,SWIGTYPE_p_lldb__SBTypeMember); + } + + result = (uint64_t)(arg1)->GetOffsetInBytes(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeMember_GetOffsetInBits(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeMember *arg1 = (lldb::SBTypeMember *) 0 ; + uint64_t result; + + SWIG_check_num_args("lldb::SBTypeMember::GetOffsetInBits",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMember::GetOffsetInBits",1,"lldb::SBTypeMember *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMember,0))){ + SWIG_fail_ptr("SBTypeMember_GetOffsetInBits",1,SWIGTYPE_p_lldb__SBTypeMember); + } + + result = (uint64_t)(arg1)->GetOffsetInBits(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeMember_IsBitfield(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeMember *arg1 = (lldb::SBTypeMember *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeMember::IsBitfield",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMember::IsBitfield",1,"lldb::SBTypeMember *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMember,0))){ + SWIG_fail_ptr("SBTypeMember_IsBitfield",1,SWIGTYPE_p_lldb__SBTypeMember); + } + + result = (bool)(arg1)->IsBitfield(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeMember_GetBitfieldSizeInBits(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeMember *arg1 = (lldb::SBTypeMember *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBTypeMember::GetBitfieldSizeInBits",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMember::GetBitfieldSizeInBits",1,"lldb::SBTypeMember *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMember,0))){ + SWIG_fail_ptr("SBTypeMember_GetBitfieldSizeInBits",1,SWIGTYPE_p_lldb__SBTypeMember); + } + + result = (uint32_t)(arg1)->GetBitfieldSizeInBits(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeMember_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeMember *arg1 = (lldb::SBTypeMember *) 0 ; + lldb::SBStream *arg2 = 0 ; + lldb::DescriptionLevel arg3 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeMember::GetDescription",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMember::GetDescription",1,"lldb::SBTypeMember *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeMember::GetDescription",2,"lldb::SBStream &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTypeMember::GetDescription",3,"lldb::DescriptionLevel"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMember,0))){ + SWIG_fail_ptr("SBTypeMember_GetDescription",1,SWIGTYPE_p_lldb__SBTypeMember); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBTypeMember_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + arg3 = (lldb::DescriptionLevel)lua_tointeger(L, 3); + result = (bool)(arg1)->GetDescription(*arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeMember___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeMember *arg1 = (lldb::SBTypeMember *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBTypeMember::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMember::__repr__",1,"lldb::SBTypeMember *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMember,0))){ + SWIG_fail_ptr("SBTypeMember___tostring",1,SWIGTYPE_p_lldb__SBTypeMember); + } + + result = lldb_SBTypeMember___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBTypeMember(void *obj) { +lldb::SBTypeMember *arg1 = (lldb::SBTypeMember *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBTypeMember(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBTypeMember); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBTypeMember_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBTypeMember_methods[]= { + { "IsValid", _wrap_SBTypeMember_IsValid}, + { "GetName", _wrap_SBTypeMember_GetName}, + { "GetType", _wrap_SBTypeMember_GetType}, + { "GetOffsetInBytes", _wrap_SBTypeMember_GetOffsetInBytes}, + { "GetOffsetInBits", _wrap_SBTypeMember_GetOffsetInBits}, + { "IsBitfield", _wrap_SBTypeMember_IsBitfield}, + { "GetBitfieldSizeInBits", _wrap_SBTypeMember_GetBitfieldSizeInBits}, + { "GetDescription", _wrap_SBTypeMember_GetDescription}, + { "__tostring", _wrap_SBTypeMember___tostring}, + {0,0} +}; +static swig_lua_method swig_SBTypeMember_meta[] = { + { "__tostring", _wrap_SBTypeMember___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBTypeMember_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBTypeMember_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBTypeMember_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBTypeMember_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBTypeMember_Sf_SwigStatic = { + "SBTypeMember", + swig_SBTypeMember_Sf_SwigStatic_methods, + swig_SBTypeMember_Sf_SwigStatic_attributes, + swig_SBTypeMember_Sf_SwigStatic_constants, + swig_SBTypeMember_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBTypeMember_bases[] = {0}; +static const char *swig_SBTypeMember_base_names[] = {0}; +static swig_lua_class _wrap_class_SBTypeMember = { "SBTypeMember", "SBTypeMember", &SWIGTYPE_p_lldb__SBTypeMember,_proxy__wrap_new_SBTypeMember, swig_delete_SBTypeMember, swig_SBTypeMember_methods, swig_SBTypeMember_attributes, &swig_SBTypeMember_Sf_SwigStatic, swig_SBTypeMember_meta, swig_SBTypeMember_bases, swig_SBTypeMember_base_names }; + +static int _wrap_new_SBTypeMemberFunction__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeMemberFunction *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeMemberFunction::SBTypeMemberFunction",0,0) + result = (lldb::SBTypeMemberFunction *)new lldb::SBTypeMemberFunction(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeMemberFunction,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBTypeMemberFunction__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeMemberFunction *arg1 = 0 ; + lldb::SBTypeMemberFunction *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeMemberFunction::SBTypeMemberFunction",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBTypeMemberFunction::SBTypeMemberFunction",1,"lldb::SBTypeMemberFunction const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMemberFunction,0))){ + SWIG_fail_ptr("new_SBTypeMemberFunction",1,SWIGTYPE_p_lldb__SBTypeMemberFunction); + } + + result = (lldb::SBTypeMemberFunction *)new lldb::SBTypeMemberFunction((lldb::SBTypeMemberFunction const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeMemberFunction,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBTypeMemberFunction(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBTypeMemberFunction__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTypeMemberFunction, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBTypeMemberFunction__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBTypeMemberFunction'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBTypeMemberFunction::SBTypeMemberFunction()\n" + " lldb::SBTypeMemberFunction::SBTypeMemberFunction(lldb::SBTypeMemberFunction const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBTypeMemberFunction_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeMemberFunction::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMemberFunction::IsValid",1,"lldb::SBTypeMemberFunction const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMemberFunction,0))){ + SWIG_fail_ptr("SBTypeMemberFunction_IsValid",1,SWIGTYPE_p_lldb__SBTypeMemberFunction); + } + + result = (bool)((lldb::SBTypeMemberFunction const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeMemberFunction_GetName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeMemberFunction::GetName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMemberFunction::GetName",1,"lldb::SBTypeMemberFunction *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMemberFunction,0))){ + SWIG_fail_ptr("SBTypeMemberFunction_GetName",1,SWIGTYPE_p_lldb__SBTypeMemberFunction); + } + + result = (char *)(arg1)->GetName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeMemberFunction_GetDemangledName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeMemberFunction::GetDemangledName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMemberFunction::GetDemangledName",1,"lldb::SBTypeMemberFunction *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMemberFunction,0))){ + SWIG_fail_ptr("SBTypeMemberFunction_GetDemangledName",1,SWIGTYPE_p_lldb__SBTypeMemberFunction); + } + + result = (char *)(arg1)->GetDemangledName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeMemberFunction_GetMangledName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeMemberFunction::GetMangledName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMemberFunction::GetMangledName",1,"lldb::SBTypeMemberFunction *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMemberFunction,0))){ + SWIG_fail_ptr("SBTypeMemberFunction_GetMangledName",1,SWIGTYPE_p_lldb__SBTypeMemberFunction); + } + + result = (char *)(arg1)->GetMangledName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeMemberFunction_GetType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) 0 ; + lldb::SBType result; + + SWIG_check_num_args("lldb::SBTypeMemberFunction::GetType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMemberFunction::GetType",1,"lldb::SBTypeMemberFunction *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMemberFunction,0))){ + SWIG_fail_ptr("SBTypeMemberFunction_GetType",1,SWIGTYPE_p_lldb__SBTypeMemberFunction); + } + + result = (arg1)->GetType(); + { + lldb::SBType * resultptr = new lldb::SBType(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeMemberFunction_GetReturnType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) 0 ; + lldb::SBType result; + + SWIG_check_num_args("lldb::SBTypeMemberFunction::GetReturnType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMemberFunction::GetReturnType",1,"lldb::SBTypeMemberFunction *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMemberFunction,0))){ + SWIG_fail_ptr("SBTypeMemberFunction_GetReturnType",1,SWIGTYPE_p_lldb__SBTypeMemberFunction); + } + + result = (arg1)->GetReturnType(); + { + lldb::SBType * resultptr = new lldb::SBType(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeMemberFunction_GetNumberOfArguments(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBTypeMemberFunction::GetNumberOfArguments",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMemberFunction::GetNumberOfArguments",1,"lldb::SBTypeMemberFunction *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMemberFunction,0))){ + SWIG_fail_ptr("SBTypeMemberFunction_GetNumberOfArguments",1,SWIGTYPE_p_lldb__SBTypeMemberFunction); + } + + result = (uint32_t)(arg1)->GetNumberOfArguments(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeMemberFunction_GetArgumentTypeAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) 0 ; + uint32_t arg2 ; + lldb::SBType result; + + SWIG_check_num_args("lldb::SBTypeMemberFunction::GetArgumentTypeAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMemberFunction::GetArgumentTypeAtIndex",1,"lldb::SBTypeMemberFunction *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeMemberFunction::GetArgumentTypeAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMemberFunction,0))){ + SWIG_fail_ptr("SBTypeMemberFunction_GetArgumentTypeAtIndex",1,SWIGTYPE_p_lldb__SBTypeMemberFunction); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetArgumentTypeAtIndex(arg2); + { + lldb::SBType * resultptr = new lldb::SBType(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeMemberFunction_GetKind(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) 0 ; + lldb::MemberFunctionKind result; + + SWIG_check_num_args("lldb::SBTypeMemberFunction::GetKind",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMemberFunction::GetKind",1,"lldb::SBTypeMemberFunction *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMemberFunction,0))){ + SWIG_fail_ptr("SBTypeMemberFunction_GetKind",1,SWIGTYPE_p_lldb__SBTypeMemberFunction); + } + + result = (lldb::MemberFunctionKind)(arg1)->GetKind(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeMemberFunction_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) 0 ; + lldb::SBStream *arg2 = 0 ; + lldb::DescriptionLevel arg3 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeMemberFunction::GetDescription",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMemberFunction::GetDescription",1,"lldb::SBTypeMemberFunction *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeMemberFunction::GetDescription",2,"lldb::SBStream &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTypeMemberFunction::GetDescription",3,"lldb::DescriptionLevel"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMemberFunction,0))){ + SWIG_fail_ptr("SBTypeMemberFunction_GetDescription",1,SWIGTYPE_p_lldb__SBTypeMemberFunction); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBTypeMemberFunction_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + arg3 = (lldb::DescriptionLevel)lua_tointeger(L, 3); + result = (bool)(arg1)->GetDescription(*arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeMemberFunction___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBTypeMemberFunction::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeMemberFunction::__repr__",1,"lldb::SBTypeMemberFunction *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeMemberFunction,0))){ + SWIG_fail_ptr("SBTypeMemberFunction___tostring",1,SWIGTYPE_p_lldb__SBTypeMemberFunction); + } + + result = lldb_SBTypeMemberFunction___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBTypeMemberFunction(void *obj) { +lldb::SBTypeMemberFunction *arg1 = (lldb::SBTypeMemberFunction *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBTypeMemberFunction(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBTypeMemberFunction); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBTypeMemberFunction_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBTypeMemberFunction_methods[]= { + { "IsValid", _wrap_SBTypeMemberFunction_IsValid}, + { "GetName", _wrap_SBTypeMemberFunction_GetName}, + { "GetDemangledName", _wrap_SBTypeMemberFunction_GetDemangledName}, + { "GetMangledName", _wrap_SBTypeMemberFunction_GetMangledName}, + { "GetType", _wrap_SBTypeMemberFunction_GetType}, + { "GetReturnType", _wrap_SBTypeMemberFunction_GetReturnType}, + { "GetNumberOfArguments", _wrap_SBTypeMemberFunction_GetNumberOfArguments}, + { "GetArgumentTypeAtIndex", _wrap_SBTypeMemberFunction_GetArgumentTypeAtIndex}, + { "GetKind", _wrap_SBTypeMemberFunction_GetKind}, + { "GetDescription", _wrap_SBTypeMemberFunction_GetDescription}, + { "__tostring", _wrap_SBTypeMemberFunction___tostring}, + {0,0} +}; +static swig_lua_method swig_SBTypeMemberFunction_meta[] = { + { "__tostring", _wrap_SBTypeMemberFunction___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBTypeMemberFunction_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBTypeMemberFunction_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBTypeMemberFunction_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBTypeMemberFunction_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBTypeMemberFunction_Sf_SwigStatic = { + "SBTypeMemberFunction", + swig_SBTypeMemberFunction_Sf_SwigStatic_methods, + swig_SBTypeMemberFunction_Sf_SwigStatic_attributes, + swig_SBTypeMemberFunction_Sf_SwigStatic_constants, + swig_SBTypeMemberFunction_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBTypeMemberFunction_bases[] = {0}; +static const char *swig_SBTypeMemberFunction_base_names[] = {0}; +static swig_lua_class _wrap_class_SBTypeMemberFunction = { "SBTypeMemberFunction", "SBTypeMemberFunction", &SWIGTYPE_p_lldb__SBTypeMemberFunction,_proxy__wrap_new_SBTypeMemberFunction, swig_delete_SBTypeMemberFunction, swig_SBTypeMemberFunction_methods, swig_SBTypeMemberFunction_attributes, &swig_SBTypeMemberFunction_Sf_SwigStatic, swig_SBTypeMemberFunction_meta, swig_SBTypeMemberFunction_bases, swig_SBTypeMemberFunction_base_names }; + +static int _wrap_new_SBTypeStaticField__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeStaticField *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeStaticField::SBTypeStaticField",0,0) + result = (lldb::SBTypeStaticField *)new lldb::SBTypeStaticField(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeStaticField,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBTypeStaticField__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeStaticField *arg1 = 0 ; + lldb::SBTypeStaticField *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeStaticField::SBTypeStaticField",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBTypeStaticField::SBTypeStaticField",1,"lldb::SBTypeStaticField const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeStaticField,0))){ + SWIG_fail_ptr("new_SBTypeStaticField",1,SWIGTYPE_p_lldb__SBTypeStaticField); + } + + result = (lldb::SBTypeStaticField *)new lldb::SBTypeStaticField((lldb::SBTypeStaticField const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeStaticField,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBTypeStaticField(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBTypeStaticField__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTypeStaticField, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBTypeStaticField__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBTypeStaticField'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBTypeStaticField::SBTypeStaticField()\n" + " lldb::SBTypeStaticField::SBTypeStaticField(lldb::SBTypeStaticField const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBTypeStaticField_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeStaticField *arg1 = (lldb::SBTypeStaticField *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeStaticField::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeStaticField::IsValid",1,"lldb::SBTypeStaticField const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeStaticField,0))){ + SWIG_fail_ptr("SBTypeStaticField_IsValid",1,SWIGTYPE_p_lldb__SBTypeStaticField); + } + + result = (bool)((lldb::SBTypeStaticField const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeStaticField_GetName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeStaticField *arg1 = (lldb::SBTypeStaticField *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeStaticField::GetName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeStaticField::GetName",1,"lldb::SBTypeStaticField *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeStaticField,0))){ + SWIG_fail_ptr("SBTypeStaticField_GetName",1,SWIGTYPE_p_lldb__SBTypeStaticField); + } + + result = (char *)(arg1)->GetName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeStaticField_GetMangledName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeStaticField *arg1 = (lldb::SBTypeStaticField *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeStaticField::GetMangledName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeStaticField::GetMangledName",1,"lldb::SBTypeStaticField *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeStaticField,0))){ + SWIG_fail_ptr("SBTypeStaticField_GetMangledName",1,SWIGTYPE_p_lldb__SBTypeStaticField); + } + + result = (char *)(arg1)->GetMangledName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeStaticField_GetType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeStaticField *arg1 = (lldb::SBTypeStaticField *) 0 ; + lldb::SBType result; + + SWIG_check_num_args("lldb::SBTypeStaticField::GetType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeStaticField::GetType",1,"lldb::SBTypeStaticField *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeStaticField,0))){ + SWIG_fail_ptr("SBTypeStaticField_GetType",1,SWIGTYPE_p_lldb__SBTypeStaticField); + } + + result = (arg1)->GetType(); + { + lldb::SBType * resultptr = new lldb::SBType(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeStaticField_GetConstantValue(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeStaticField *arg1 = (lldb::SBTypeStaticField *) 0 ; + lldb::SBTarget arg2 ; + lldb::SBTarget *argp2 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBTypeStaticField::GetConstantValue",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeStaticField::GetConstantValue",1,"lldb::SBTypeStaticField *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeStaticField::GetConstantValue",2,"lldb::SBTarget"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeStaticField,0))){ + SWIG_fail_ptr("SBTypeStaticField_GetConstantValue",1,SWIGTYPE_p_lldb__SBTypeStaticField); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBTypeStaticField_GetConstantValue",2,SWIGTYPE_p_lldb__SBTarget); + } + arg2 = *argp2; + + result = (arg1)->GetConstantValue(arg2); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBTypeStaticField(void *obj) { +lldb::SBTypeStaticField *arg1 = (lldb::SBTypeStaticField *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBTypeStaticField(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBTypeStaticField); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBTypeStaticField_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBTypeStaticField_methods[]= { + { "IsValid", _wrap_SBTypeStaticField_IsValid}, + { "GetName", _wrap_SBTypeStaticField_GetName}, + { "GetMangledName", _wrap_SBTypeStaticField_GetMangledName}, + { "GetType", _wrap_SBTypeStaticField_GetType}, + { "GetConstantValue", _wrap_SBTypeStaticField_GetConstantValue}, + {0,0} +}; +static swig_lua_method swig_SBTypeStaticField_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBTypeStaticField_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBTypeStaticField_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBTypeStaticField_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBTypeStaticField_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBTypeStaticField_Sf_SwigStatic = { + "SBTypeStaticField", + swig_SBTypeStaticField_Sf_SwigStatic_methods, + swig_SBTypeStaticField_Sf_SwigStatic_attributes, + swig_SBTypeStaticField_Sf_SwigStatic_constants, + swig_SBTypeStaticField_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBTypeStaticField_bases[] = {0}; +static const char *swig_SBTypeStaticField_base_names[] = {0}; +static swig_lua_class _wrap_class_SBTypeStaticField = { "SBTypeStaticField", "SBTypeStaticField", &SWIGTYPE_p_lldb__SBTypeStaticField,_proxy__wrap_new_SBTypeStaticField, swig_delete_SBTypeStaticField, swig_SBTypeStaticField_methods, swig_SBTypeStaticField_attributes, &swig_SBTypeStaticField_Sf_SwigStatic, swig_SBTypeStaticField_meta, swig_SBTypeStaticField_bases, swig_SBTypeStaticField_base_names }; + +static int _wrap_new_SBType__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *result = 0 ; + + SWIG_check_num_args("lldb::SBType::SBType",0,0) + result = (lldb::SBType *)new lldb::SBType(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBType__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = 0 ; + lldb::SBType *result = 0 ; + + SWIG_check_num_args("lldb::SBType::SBType",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBType::SBType",1,"lldb::SBType const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("new_SBType",1,SWIGTYPE_p_lldb__SBType); + } + + result = (lldb::SBType *)new lldb::SBType((lldb::SBType const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBType(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBType__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBType, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBType__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBType'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBType::SBType()\n" + " lldb::SBType::SBType(lldb::SBType const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBType_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBType::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::IsValid",1,"lldb::SBType const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_IsValid",1,SWIGTYPE_p_lldb__SBType); + } + + result = (bool)((lldb::SBType const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetByteSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + uint64_t result; + + SWIG_check_num_args("lldb::SBType::GetByteSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetByteSize",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetByteSize",1,SWIGTYPE_p_lldb__SBType); + } + + result = (uint64_t)(arg1)->GetByteSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetByteAlign(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + uint64_t result; + + SWIG_check_num_args("lldb::SBType::GetByteAlign",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetByteAlign",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetByteAlign",1,SWIGTYPE_p_lldb__SBType); + } + + result = (uint64_t)(arg1)->GetByteAlign(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_IsPointerType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBType::IsPointerType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::IsPointerType",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_IsPointerType",1,SWIGTYPE_p_lldb__SBType); + } + + result = (bool)(arg1)->IsPointerType(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_IsReferenceType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBType::IsReferenceType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::IsReferenceType",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_IsReferenceType",1,SWIGTYPE_p_lldb__SBType); + } + + result = (bool)(arg1)->IsReferenceType(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_IsFunctionType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBType::IsFunctionType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::IsFunctionType",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_IsFunctionType",1,SWIGTYPE_p_lldb__SBType); + } + + result = (bool)(arg1)->IsFunctionType(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_IsPolymorphicClass(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBType::IsPolymorphicClass",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::IsPolymorphicClass",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_IsPolymorphicClass",1,SWIGTYPE_p_lldb__SBType); + } + + result = (bool)(arg1)->IsPolymorphicClass(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_IsArrayType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBType::IsArrayType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::IsArrayType",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_IsArrayType",1,SWIGTYPE_p_lldb__SBType); + } + + result = (bool)(arg1)->IsArrayType(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_IsVectorType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBType::IsVectorType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::IsVectorType",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_IsVectorType",1,SWIGTYPE_p_lldb__SBType); + } + + result = (bool)(arg1)->IsVectorType(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_IsTypedefType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBType::IsTypedefType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::IsTypedefType",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_IsTypedefType",1,SWIGTYPE_p_lldb__SBType); + } + + result = (bool)(arg1)->IsTypedefType(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_IsAnonymousType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBType::IsAnonymousType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::IsAnonymousType",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_IsAnonymousType",1,SWIGTYPE_p_lldb__SBType); + } + + result = (bool)(arg1)->IsAnonymousType(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_IsScopedEnumerationType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBType::IsScopedEnumerationType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::IsScopedEnumerationType",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_IsScopedEnumerationType",1,SWIGTYPE_p_lldb__SBType); + } + + result = (bool)(arg1)->IsScopedEnumerationType(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_IsAggregateType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBType::IsAggregateType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::IsAggregateType",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_IsAggregateType",1,SWIGTYPE_p_lldb__SBType); + } + + result = (bool)(arg1)->IsAggregateType(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetPointerType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType result; + + SWIG_check_num_args("lldb::SBType::GetPointerType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetPointerType",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetPointerType",1,SWIGTYPE_p_lldb__SBType); + } + + result = (arg1)->GetPointerType(); + { + lldb::SBType * resultptr = new lldb::SBType(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetPointeeType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType result; + + SWIG_check_num_args("lldb::SBType::GetPointeeType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetPointeeType",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetPointeeType",1,SWIGTYPE_p_lldb__SBType); + } + + result = (arg1)->GetPointeeType(); + { + lldb::SBType * resultptr = new lldb::SBType(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetReferenceType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType result; + + SWIG_check_num_args("lldb::SBType::GetReferenceType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetReferenceType",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetReferenceType",1,SWIGTYPE_p_lldb__SBType); + } + + result = (arg1)->GetReferenceType(); + { + lldb::SBType * resultptr = new lldb::SBType(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetTypedefedType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType result; + + SWIG_check_num_args("lldb::SBType::GetTypedefedType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetTypedefedType",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetTypedefedType",1,SWIGTYPE_p_lldb__SBType); + } + + result = (arg1)->GetTypedefedType(); + { + lldb::SBType * resultptr = new lldb::SBType(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetDereferencedType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType result; + + SWIG_check_num_args("lldb::SBType::GetDereferencedType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetDereferencedType",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetDereferencedType",1,SWIGTYPE_p_lldb__SBType); + } + + result = (arg1)->GetDereferencedType(); + { + lldb::SBType * resultptr = new lldb::SBType(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetUnqualifiedType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType result; + + SWIG_check_num_args("lldb::SBType::GetUnqualifiedType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetUnqualifiedType",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetUnqualifiedType",1,SWIGTYPE_p_lldb__SBType); + } + + result = (arg1)->GetUnqualifiedType(); + { + lldb::SBType * resultptr = new lldb::SBType(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetArrayElementType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType result; + + SWIG_check_num_args("lldb::SBType::GetArrayElementType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetArrayElementType",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetArrayElementType",1,SWIGTYPE_p_lldb__SBType); + } + + result = (arg1)->GetArrayElementType(); + { + lldb::SBType * resultptr = new lldb::SBType(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetArrayType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + uint64_t arg2 ; + lldb::SBType result; + + SWIG_check_num_args("lldb::SBType::GetArrayType",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetArrayType",1,"lldb::SBType *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBType::GetArrayType",2,"uint64_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetArrayType",1,SWIGTYPE_p_lldb__SBType); + } + + arg2 = (uint64_t)lua_tointeger(L, 2); + result = (arg1)->GetArrayType(arg2); + { + lldb::SBType * resultptr = new lldb::SBType(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetVectorElementType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType result; + + SWIG_check_num_args("lldb::SBType::GetVectorElementType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetVectorElementType",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetVectorElementType",1,SWIGTYPE_p_lldb__SBType); + } + + result = (arg1)->GetVectorElementType(); + { + lldb::SBType * resultptr = new lldb::SBType(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetCanonicalType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType result; + + SWIG_check_num_args("lldb::SBType::GetCanonicalType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetCanonicalType",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetCanonicalType",1,SWIGTYPE_p_lldb__SBType); + } + + result = (arg1)->GetCanonicalType(); + { + lldb::SBType * resultptr = new lldb::SBType(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetEnumerationIntegerType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType result; + + SWIG_check_num_args("lldb::SBType::GetEnumerationIntegerType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetEnumerationIntegerType",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetEnumerationIntegerType",1,SWIGTYPE_p_lldb__SBType); + } + + result = (arg1)->GetEnumerationIntegerType(); + { + lldb::SBType * resultptr = new lldb::SBType(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetBasicType__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::BasicType result; + + SWIG_check_num_args("lldb::SBType::GetBasicType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetBasicType",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetBasicType",1,SWIGTYPE_p_lldb__SBType); + } + + result = (lldb::BasicType)(arg1)->GetBasicType(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetBasicType__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::BasicType arg2 ; + lldb::SBType result; + + SWIG_check_num_args("lldb::SBType::GetBasicType",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetBasicType",1,"lldb::SBType *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBType::GetBasicType",2,"lldb::BasicType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetBasicType",1,SWIGTYPE_p_lldb__SBType); + } + + arg2 = (lldb::BasicType)lua_tointeger(L, 2); + result = (arg1)->GetBasicType(arg2); + { + lldb::SBType * resultptr = new lldb::SBType(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetBasicType(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBType, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBType_GetBasicType__SWIG_0(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBType, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_SBType_GetBasicType__SWIG_1(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBType_GetBasicType'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBType::GetBasicType()\n" + " lldb::SBType::GetBasicType(lldb::BasicType)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBType_GetNumberOfFields(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBType::GetNumberOfFields",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetNumberOfFields",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetNumberOfFields",1,SWIGTYPE_p_lldb__SBType); + } + + result = (uint32_t)(arg1)->GetNumberOfFields(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetNumberOfDirectBaseClasses(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBType::GetNumberOfDirectBaseClasses",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetNumberOfDirectBaseClasses",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetNumberOfDirectBaseClasses",1,SWIGTYPE_p_lldb__SBType); + } + + result = (uint32_t)(arg1)->GetNumberOfDirectBaseClasses(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetNumberOfVirtualBaseClasses(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBType::GetNumberOfVirtualBaseClasses",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetNumberOfVirtualBaseClasses",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetNumberOfVirtualBaseClasses",1,SWIGTYPE_p_lldb__SBType); + } + + result = (uint32_t)(arg1)->GetNumberOfVirtualBaseClasses(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetFieldAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + uint32_t arg2 ; + lldb::SBTypeMember result; + + SWIG_check_num_args("lldb::SBType::GetFieldAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetFieldAtIndex",1,"lldb::SBType *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBType::GetFieldAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetFieldAtIndex",1,SWIGTYPE_p_lldb__SBType); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetFieldAtIndex(arg2); + { + lldb::SBTypeMember * resultptr = new lldb::SBTypeMember(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeMember,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetDirectBaseClassAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + uint32_t arg2 ; + lldb::SBTypeMember result; + + SWIG_check_num_args("lldb::SBType::GetDirectBaseClassAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetDirectBaseClassAtIndex",1,"lldb::SBType *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBType::GetDirectBaseClassAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetDirectBaseClassAtIndex",1,SWIGTYPE_p_lldb__SBType); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetDirectBaseClassAtIndex(arg2); + { + lldb::SBTypeMember * resultptr = new lldb::SBTypeMember(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeMember,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetVirtualBaseClassAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + uint32_t arg2 ; + lldb::SBTypeMember result; + + SWIG_check_num_args("lldb::SBType::GetVirtualBaseClassAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetVirtualBaseClassAtIndex",1,"lldb::SBType *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBType::GetVirtualBaseClassAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetVirtualBaseClassAtIndex",1,SWIGTYPE_p_lldb__SBType); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetVirtualBaseClassAtIndex(arg2); + { + lldb::SBTypeMember * resultptr = new lldb::SBTypeMember(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeMember,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetStaticFieldWithName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBTypeStaticField result; + + SWIG_check_num_args("lldb::SBType::GetStaticFieldWithName",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetStaticFieldWithName",1,"lldb::SBType *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBType::GetStaticFieldWithName",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetStaticFieldWithName",1,SWIGTYPE_p_lldb__SBType); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->GetStaticFieldWithName((char const *)arg2); + { + lldb::SBTypeStaticField * resultptr = new lldb::SBTypeStaticField(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeStaticField,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetEnumMembers(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBTypeEnumMemberList result; + + SWIG_check_num_args("lldb::SBType::GetEnumMembers",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetEnumMembers",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetEnumMembers",1,SWIGTYPE_p_lldb__SBType); + } + + result = (arg1)->GetEnumMembers(); + { + lldb::SBTypeEnumMemberList * resultptr = new lldb::SBTypeEnumMemberList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeEnumMemberList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetNumberOfTemplateArguments(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBType::GetNumberOfTemplateArguments",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetNumberOfTemplateArguments",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetNumberOfTemplateArguments",1,SWIGTYPE_p_lldb__SBType); + } + + result = (uint32_t)(arg1)->GetNumberOfTemplateArguments(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetTemplateArgumentType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + uint32_t arg2 ; + lldb::SBType result; + + SWIG_check_num_args("lldb::SBType::GetTemplateArgumentType",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetTemplateArgumentType",1,"lldb::SBType *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBType::GetTemplateArgumentType",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetTemplateArgumentType",1,SWIGTYPE_p_lldb__SBType); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetTemplateArgumentType(arg2); + { + lldb::SBType * resultptr = new lldb::SBType(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetTemplateArgumentKind(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + uint32_t arg2 ; + lldb::TemplateArgumentKind result; + + SWIG_check_num_args("lldb::SBType::GetTemplateArgumentKind",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetTemplateArgumentKind",1,"lldb::SBType *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBType::GetTemplateArgumentKind",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetTemplateArgumentKind",1,SWIGTYPE_p_lldb__SBType); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (lldb::TemplateArgumentKind)(arg1)->GetTemplateArgumentKind(arg2); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetFunctionReturnType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType result; + + SWIG_check_num_args("lldb::SBType::GetFunctionReturnType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetFunctionReturnType",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetFunctionReturnType",1,SWIGTYPE_p_lldb__SBType); + } + + result = (arg1)->GetFunctionReturnType(); + { + lldb::SBType * resultptr = new lldb::SBType(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetFunctionArgumentTypes(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBTypeList result; + + SWIG_check_num_args("lldb::SBType::GetFunctionArgumentTypes",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetFunctionArgumentTypes",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetFunctionArgumentTypes",1,SWIGTYPE_p_lldb__SBType); + } + + result = (arg1)->GetFunctionArgumentTypes(); + { + lldb::SBTypeList * resultptr = new lldb::SBTypeList(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeList,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetNumberOfMemberFunctions(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBType::GetNumberOfMemberFunctions",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetNumberOfMemberFunctions",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetNumberOfMemberFunctions",1,SWIGTYPE_p_lldb__SBType); + } + + result = (uint32_t)(arg1)->GetNumberOfMemberFunctions(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetMemberFunctionAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + uint32_t arg2 ; + lldb::SBTypeMemberFunction result; + + SWIG_check_num_args("lldb::SBType::GetMemberFunctionAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetMemberFunctionAtIndex",1,"lldb::SBType *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBType::GetMemberFunctionAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetMemberFunctionAtIndex",1,SWIGTYPE_p_lldb__SBType); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetMemberFunctionAtIndex(arg2); + { + lldb::SBTypeMemberFunction * resultptr = new lldb::SBTypeMemberFunction(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeMemberFunction,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetModule(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBModule result; + + SWIG_check_num_args("lldb::SBType::GetModule",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetModule",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetModule",1,SWIGTYPE_p_lldb__SBType); + } + + result = (arg1)->GetModule(); + { + lldb::SBModule * resultptr = new lldb::SBModule(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBModule,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBType::GetName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetName",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetName",1,SWIGTYPE_p_lldb__SBType); + } + + result = (char *)(arg1)->GetName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetDisplayTypeName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBType::GetDisplayTypeName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetDisplayTypeName",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetDisplayTypeName",1,SWIGTYPE_p_lldb__SBType); + } + + result = (char *)(arg1)->GetDisplayTypeName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetTypeClass(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::TypeClass result; + + SWIG_check_num_args("lldb::SBType::GetTypeClass",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetTypeClass",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetTypeClass",1,SWIGTYPE_p_lldb__SBType); + } + + result = (lldb::TypeClass)(arg1)->GetTypeClass(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_IsTypeComplete(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBType::IsTypeComplete",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::IsTypeComplete",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_IsTypeComplete",1,SWIGTYPE_p_lldb__SBType); + } + + result = (bool)(arg1)->IsTypeComplete(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetTypeFlags(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBType::GetTypeFlags",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetTypeFlags",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetTypeFlags",1,SWIGTYPE_p_lldb__SBType); + } + + result = (uint32_t)(arg1)->GetTypeFlags(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBStream *arg2 = 0 ; + lldb::DescriptionLevel arg3 ; + bool result; + + SWIG_check_num_args("lldb::SBType::GetDescription",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::GetDescription",1,"lldb::SBType *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBType::GetDescription",2,"lldb::SBStream &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBType::GetDescription",3,"lldb::DescriptionLevel"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_GetDescription",1,SWIGTYPE_p_lldb__SBType); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBType_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + arg3 = (lldb::DescriptionLevel)lua_tointeger(L, 3); + result = (bool)(arg1)->GetDescription(*arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType_FindDirectNestedType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBType result; + + SWIG_check_num_args("lldb::SBType::FindDirectNestedType",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::FindDirectNestedType",1,"lldb::SBType *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBType::FindDirectNestedType",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType_FindDirectNestedType",1,SWIGTYPE_p_lldb__SBType); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->FindDirectNestedType((char const *)arg2); + { + lldb::SBType * resultptr = new lldb::SBType(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType___eq(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + lldb::SBType *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBType::operator ==",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::operator ==",1,"lldb::SBType *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBType::operator ==",2,"lldb::SBType &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType___eq",1,SWIGTYPE_p_lldb__SBType); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType___eq",2,SWIGTYPE_p_lldb__SBType); + } + + result = (bool)(arg1)->operator ==(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBType___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType *arg1 = (lldb::SBType *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBType::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBType::__repr__",1,"lldb::SBType *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBType___tostring",1,SWIGTYPE_p_lldb__SBType); + } + + result = lldb_SBType___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBType(void *obj) { +lldb::SBType *arg1 = (lldb::SBType *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBType(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBType); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBType_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBType_methods[]= { + { "IsValid", _wrap_SBType_IsValid}, + { "GetByteSize", _wrap_SBType_GetByteSize}, + { "GetByteAlign", _wrap_SBType_GetByteAlign}, + { "IsPointerType", _wrap_SBType_IsPointerType}, + { "IsReferenceType", _wrap_SBType_IsReferenceType}, + { "IsFunctionType", _wrap_SBType_IsFunctionType}, + { "IsPolymorphicClass", _wrap_SBType_IsPolymorphicClass}, + { "IsArrayType", _wrap_SBType_IsArrayType}, + { "IsVectorType", _wrap_SBType_IsVectorType}, + { "IsTypedefType", _wrap_SBType_IsTypedefType}, + { "IsAnonymousType", _wrap_SBType_IsAnonymousType}, + { "IsScopedEnumerationType", _wrap_SBType_IsScopedEnumerationType}, + { "IsAggregateType", _wrap_SBType_IsAggregateType}, + { "GetPointerType", _wrap_SBType_GetPointerType}, + { "GetPointeeType", _wrap_SBType_GetPointeeType}, + { "GetReferenceType", _wrap_SBType_GetReferenceType}, + { "GetTypedefedType", _wrap_SBType_GetTypedefedType}, + { "GetDereferencedType", _wrap_SBType_GetDereferencedType}, + { "GetUnqualifiedType", _wrap_SBType_GetUnqualifiedType}, + { "GetArrayElementType", _wrap_SBType_GetArrayElementType}, + { "GetArrayType", _wrap_SBType_GetArrayType}, + { "GetVectorElementType", _wrap_SBType_GetVectorElementType}, + { "GetCanonicalType", _wrap_SBType_GetCanonicalType}, + { "GetEnumerationIntegerType", _wrap_SBType_GetEnumerationIntegerType}, + { "GetBasicType", _wrap_SBType_GetBasicType}, + { "GetNumberOfFields", _wrap_SBType_GetNumberOfFields}, + { "GetNumberOfDirectBaseClasses", _wrap_SBType_GetNumberOfDirectBaseClasses}, + { "GetNumberOfVirtualBaseClasses", _wrap_SBType_GetNumberOfVirtualBaseClasses}, + { "GetFieldAtIndex", _wrap_SBType_GetFieldAtIndex}, + { "GetDirectBaseClassAtIndex", _wrap_SBType_GetDirectBaseClassAtIndex}, + { "GetVirtualBaseClassAtIndex", _wrap_SBType_GetVirtualBaseClassAtIndex}, + { "GetStaticFieldWithName", _wrap_SBType_GetStaticFieldWithName}, + { "GetEnumMembers", _wrap_SBType_GetEnumMembers}, + { "GetNumberOfTemplateArguments", _wrap_SBType_GetNumberOfTemplateArguments}, + { "GetTemplateArgumentType", _wrap_SBType_GetTemplateArgumentType}, + { "GetTemplateArgumentKind", _wrap_SBType_GetTemplateArgumentKind}, + { "GetFunctionReturnType", _wrap_SBType_GetFunctionReturnType}, + { "GetFunctionArgumentTypes", _wrap_SBType_GetFunctionArgumentTypes}, + { "GetNumberOfMemberFunctions", _wrap_SBType_GetNumberOfMemberFunctions}, + { "GetMemberFunctionAtIndex", _wrap_SBType_GetMemberFunctionAtIndex}, + { "GetModule", _wrap_SBType_GetModule}, + { "GetName", _wrap_SBType_GetName}, + { "GetDisplayTypeName", _wrap_SBType_GetDisplayTypeName}, + { "GetTypeClass", _wrap_SBType_GetTypeClass}, + { "IsTypeComplete", _wrap_SBType_IsTypeComplete}, + { "GetTypeFlags", _wrap_SBType_GetTypeFlags}, + { "GetDescription", _wrap_SBType_GetDescription}, + { "FindDirectNestedType", _wrap_SBType_FindDirectNestedType}, + { "__eq", _wrap_SBType___eq}, + { "__tostring", _wrap_SBType___tostring}, + {0,0} +}; +static swig_lua_method swig_SBType_meta[] = { + { "__eq", _wrap_SBType___eq}, + { "__tostring", _wrap_SBType___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBType_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBType_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBType_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBType_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBType_Sf_SwigStatic = { + "SBType", + swig_SBType_Sf_SwigStatic_methods, + swig_SBType_Sf_SwigStatic_attributes, + swig_SBType_Sf_SwigStatic_constants, + swig_SBType_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBType_bases[] = {0}; +static const char *swig_SBType_base_names[] = {0}; +static swig_lua_class _wrap_class_SBType = { "SBType", "SBType", &SWIGTYPE_p_lldb__SBType,_proxy__wrap_new_SBType, swig_delete_SBType, swig_SBType_methods, swig_SBType_attributes, &swig_SBType_Sf_SwigStatic, swig_SBType_meta, swig_SBType_bases, swig_SBType_base_names }; + +static int _wrap_new_SBTypeList__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeList *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeList::SBTypeList",0,0) + result = (lldb::SBTypeList *)new lldb::SBTypeList(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeList,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBTypeList__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeList *arg1 = 0 ; + lldb::SBTypeList *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeList::SBTypeList",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBTypeList::SBTypeList",1,"lldb::SBTypeList const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeList,0))){ + SWIG_fail_ptr("new_SBTypeList",1,SWIGTYPE_p_lldb__SBTypeList); + } + + result = (lldb::SBTypeList *)new lldb::SBTypeList((lldb::SBTypeList const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeList,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBTypeList(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBTypeList__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTypeList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBTypeList__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBTypeList'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBTypeList::SBTypeList()\n" + " lldb::SBTypeList::SBTypeList(lldb::SBTypeList const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBTypeList_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeList *arg1 = (lldb::SBTypeList *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeList::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeList::IsValid",1,"lldb::SBTypeList *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeList,0))){ + SWIG_fail_ptr("SBTypeList_IsValid",1,SWIGTYPE_p_lldb__SBTypeList); + } + + result = (bool)(arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeList_Append(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeList *arg1 = (lldb::SBTypeList *) 0 ; + lldb::SBType arg2 ; + lldb::SBType *argp2 ; + + SWIG_check_num_args("lldb::SBTypeList::Append",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeList::Append",1,"lldb::SBTypeList *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeList::Append",2,"lldb::SBType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeList,0))){ + SWIG_fail_ptr("SBTypeList_Append",1,SWIGTYPE_p_lldb__SBTypeList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBTypeList_Append",2,SWIGTYPE_p_lldb__SBType); + } + arg2 = *argp2; + + (arg1)->Append(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeList_GetTypeAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeList *arg1 = (lldb::SBTypeList *) 0 ; + uint32_t arg2 ; + lldb::SBType result; + + SWIG_check_num_args("lldb::SBTypeList::GetTypeAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeList::GetTypeAtIndex",1,"lldb::SBTypeList *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeList::GetTypeAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeList,0))){ + SWIG_fail_ptr("SBTypeList_GetTypeAtIndex",1,SWIGTYPE_p_lldb__SBTypeList); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetTypeAtIndex(arg2); + { + lldb::SBType * resultptr = new lldb::SBType(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeList_GetSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeList *arg1 = (lldb::SBTypeList *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBTypeList::GetSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeList::GetSize",1,"lldb::SBTypeList *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeList,0))){ + SWIG_fail_ptr("SBTypeList_GetSize",1,SWIGTYPE_p_lldb__SBTypeList); + } + + result = (uint32_t)(arg1)->GetSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBTypeList(void *obj) { +lldb::SBTypeList *arg1 = (lldb::SBTypeList *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBTypeList(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBTypeList); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBTypeList_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBTypeList_methods[]= { + { "IsValid", _wrap_SBTypeList_IsValid}, + { "Append", _wrap_SBTypeList_Append}, + { "GetTypeAtIndex", _wrap_SBTypeList_GetTypeAtIndex}, + { "GetSize", _wrap_SBTypeList_GetSize}, + {0,0} +}; +static swig_lua_method swig_SBTypeList_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBTypeList_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBTypeList_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBTypeList_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBTypeList_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBTypeList_Sf_SwigStatic = { + "SBTypeList", + swig_SBTypeList_Sf_SwigStatic_methods, + swig_SBTypeList_Sf_SwigStatic_attributes, + swig_SBTypeList_Sf_SwigStatic_constants, + swig_SBTypeList_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBTypeList_bases[] = {0}; +static const char *swig_SBTypeList_base_names[] = {0}; +static swig_lua_class _wrap_class_SBTypeList = { "SBTypeList", "SBTypeList", &SWIGTYPE_p_lldb__SBTypeList,_proxy__wrap_new_SBTypeList, swig_delete_SBTypeList, swig_SBTypeList_methods, swig_SBTypeList_attributes, &swig_SBTypeList_Sf_SwigStatic, swig_SBTypeList_meta, swig_SBTypeList_bases, swig_SBTypeList_base_names }; + +static int _wrap_new_SBTypeCategory__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeCategory::SBTypeCategory",0,0) + result = (lldb::SBTypeCategory *)new lldb::SBTypeCategory(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeCategory,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBTypeCategory__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *arg1 = 0 ; + lldb::SBTypeCategory *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeCategory::SBTypeCategory",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::SBTypeCategory",1,"lldb::SBTypeCategory const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("new_SBTypeCategory",1,SWIGTYPE_p_lldb__SBTypeCategory); + } + + result = (lldb::SBTypeCategory *)new lldb::SBTypeCategory((lldb::SBTypeCategory const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeCategory,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBTypeCategory(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBTypeCategory__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTypeCategory, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBTypeCategory__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBTypeCategory'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBTypeCategory::SBTypeCategory()\n" + " lldb::SBTypeCategory::SBTypeCategory(lldb::SBTypeCategory const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBTypeCategory_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeCategory::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::IsValid",1,"lldb::SBTypeCategory const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("SBTypeCategory_IsValid",1,SWIGTYPE_p_lldb__SBTypeCategory); + } + + result = (bool)((lldb::SBTypeCategory const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeCategory_GetEnabled(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeCategory::GetEnabled",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetEnabled",1,"lldb::SBTypeCategory *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("SBTypeCategory_GetEnabled",1,SWIGTYPE_p_lldb__SBTypeCategory); + } + + result = (bool)(arg1)->GetEnabled(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeCategory_SetEnabled(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBTypeCategory::SetEnabled",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::SetEnabled",1,"lldb::SBTypeCategory *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::SetEnabled",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("SBTypeCategory_SetEnabled",1,SWIGTYPE_p_lldb__SBTypeCategory); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetEnabled(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeCategory_GetName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeCategory::GetName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetName",1,"lldb::SBTypeCategory *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("SBTypeCategory_GetName",1,SWIGTYPE_p_lldb__SBTypeCategory); + } + + result = (char *)(arg1)->GetName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeCategory_GetLanguageAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + uint32_t arg2 ; + lldb::LanguageType result; + + SWIG_check_num_args("lldb::SBTypeCategory::GetLanguageAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetLanguageAtIndex",1,"lldb::SBTypeCategory *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::GetLanguageAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("SBTypeCategory_GetLanguageAtIndex",1,SWIGTYPE_p_lldb__SBTypeCategory); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (lldb::LanguageType)(arg1)->GetLanguageAtIndex(arg2); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeCategory_GetNumLanguages(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBTypeCategory::GetNumLanguages",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetNumLanguages",1,"lldb::SBTypeCategory *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("SBTypeCategory_GetNumLanguages",1,SWIGTYPE_p_lldb__SBTypeCategory); + } + + result = (uint32_t)(arg1)->GetNumLanguages(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeCategory_AddLanguage(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::LanguageType arg2 ; + + SWIG_check_num_args("lldb::SBTypeCategory::AddLanguage",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::AddLanguage",1,"lldb::SBTypeCategory *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::AddLanguage",2,"lldb::LanguageType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("SBTypeCategory_AddLanguage",1,SWIGTYPE_p_lldb__SBTypeCategory); + } + + arg2 = (lldb::LanguageType)lua_tointeger(L, 2); + (arg1)->AddLanguage(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeCategory_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBStream *arg2 = 0 ; + lldb::DescriptionLevel arg3 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeCategory::GetDescription",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetDescription",1,"lldb::SBTypeCategory *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::GetDescription",2,"lldb::SBStream &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTypeCategory::GetDescription",3,"lldb::DescriptionLevel"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("SBTypeCategory_GetDescription",1,SWIGTYPE_p_lldb__SBTypeCategory); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBTypeCategory_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + arg3 = (lldb::DescriptionLevel)lua_tointeger(L, 3); + result = (bool)(arg1)->GetDescription(*arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeCategory_GetNumFormats(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBTypeCategory::GetNumFormats",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetNumFormats",1,"lldb::SBTypeCategory *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("SBTypeCategory_GetNumFormats",1,SWIGTYPE_p_lldb__SBTypeCategory); + } + + result = (uint32_t)(arg1)->GetNumFormats(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeCategory_GetNumSummaries(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBTypeCategory::GetNumSummaries",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetNumSummaries",1,"lldb::SBTypeCategory *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("SBTypeCategory_GetNumSummaries",1,SWIGTYPE_p_lldb__SBTypeCategory); + } + + result = (uint32_t)(arg1)->GetNumSummaries(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeCategory_GetNumFilters(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBTypeCategory::GetNumFilters",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetNumFilters",1,"lldb::SBTypeCategory *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("SBTypeCategory_GetNumFilters",1,SWIGTYPE_p_lldb__SBTypeCategory); + } + + result = (uint32_t)(arg1)->GetNumFilters(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeCategory_GetNumSynthetics(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBTypeCategory::GetNumSynthetics",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetNumSynthetics",1,"lldb::SBTypeCategory *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("SBTypeCategory_GetNumSynthetics",1,SWIGTYPE_p_lldb__SBTypeCategory); + } + + result = (uint32_t)(arg1)->GetNumSynthetics(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeCategory_GetTypeNameSpecifierForFilterAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + uint32_t arg2 ; + lldb::SBTypeNameSpecifier result; + + SWIG_check_num_args("lldb::SBTypeCategory::GetTypeNameSpecifierForFilterAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetTypeNameSpecifierForFilterAtIndex",1,"lldb::SBTypeCategory *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::GetTypeNameSpecifierForFilterAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("SBTypeCategory_GetTypeNameSpecifierForFilterAtIndex",1,SWIGTYPE_p_lldb__SBTypeCategory); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetTypeNameSpecifierForFilterAtIndex(arg2); + { + lldb::SBTypeNameSpecifier * resultptr = new lldb::SBTypeNameSpecifier(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeNameSpecifier,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeCategory_GetTypeNameSpecifierForFormatAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + uint32_t arg2 ; + lldb::SBTypeNameSpecifier result; + + SWIG_check_num_args("lldb::SBTypeCategory::GetTypeNameSpecifierForFormatAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetTypeNameSpecifierForFormatAtIndex",1,"lldb::SBTypeCategory *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::GetTypeNameSpecifierForFormatAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("SBTypeCategory_GetTypeNameSpecifierForFormatAtIndex",1,SWIGTYPE_p_lldb__SBTypeCategory); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetTypeNameSpecifierForFormatAtIndex(arg2); + { + lldb::SBTypeNameSpecifier * resultptr = new lldb::SBTypeNameSpecifier(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeNameSpecifier,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeCategory_GetTypeNameSpecifierForSummaryAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + uint32_t arg2 ; + lldb::SBTypeNameSpecifier result; + + SWIG_check_num_args("lldb::SBTypeCategory::GetTypeNameSpecifierForSummaryAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetTypeNameSpecifierForSummaryAtIndex",1,"lldb::SBTypeCategory *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::GetTypeNameSpecifierForSummaryAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("SBTypeCategory_GetTypeNameSpecifierForSummaryAtIndex",1,SWIGTYPE_p_lldb__SBTypeCategory); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetTypeNameSpecifierForSummaryAtIndex(arg2); + { + lldb::SBTypeNameSpecifier * resultptr = new lldb::SBTypeNameSpecifier(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeNameSpecifier,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeCategory_GetTypeNameSpecifierForSyntheticAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + uint32_t arg2 ; + lldb::SBTypeNameSpecifier result; + + SWIG_check_num_args("lldb::SBTypeCategory::GetTypeNameSpecifierForSyntheticAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetTypeNameSpecifierForSyntheticAtIndex",1,"lldb::SBTypeCategory *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::GetTypeNameSpecifierForSyntheticAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("SBTypeCategory_GetTypeNameSpecifierForSyntheticAtIndex",1,SWIGTYPE_p_lldb__SBTypeCategory); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetTypeNameSpecifierForSyntheticAtIndex(arg2); + { + lldb::SBTypeNameSpecifier * resultptr = new lldb::SBTypeNameSpecifier(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeNameSpecifier,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeCategory_GetFilterForType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeNameSpecifier arg2 ; + lldb::SBTypeNameSpecifier *argp2 ; + lldb::SBTypeFilter result; + + SWIG_check_num_args("lldb::SBTypeCategory::GetFilterForType",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetFilterForType",1,"lldb::SBTypeCategory *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::GetFilterForType",2,"lldb::SBTypeNameSpecifier"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("SBTypeCategory_GetFilterForType",1,SWIGTYPE_p_lldb__SBTypeCategory); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){ + SWIG_fail_ptr("SBTypeCategory_GetFilterForType",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier); + } + arg2 = *argp2; + + result = (arg1)->GetFilterForType(arg2); + { + lldb::SBTypeFilter * resultptr = new lldb::SBTypeFilter(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeFilter,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeCategory_GetFormatForType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeNameSpecifier arg2 ; + lldb::SBTypeNameSpecifier *argp2 ; + lldb::SBTypeFormat result; + + SWIG_check_num_args("lldb::SBTypeCategory::GetFormatForType",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetFormatForType",1,"lldb::SBTypeCategory *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::GetFormatForType",2,"lldb::SBTypeNameSpecifier"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("SBTypeCategory_GetFormatForType",1,SWIGTYPE_p_lldb__SBTypeCategory); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){ + SWIG_fail_ptr("SBTypeCategory_GetFormatForType",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier); + } + arg2 = *argp2; + + result = (arg1)->GetFormatForType(arg2); + { + lldb::SBTypeFormat * resultptr = new lldb::SBTypeFormat(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeFormat,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeCategory_GetSummaryForType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeNameSpecifier arg2 ; + lldb::SBTypeNameSpecifier *argp2 ; + lldb::SBTypeSummary result; + + SWIG_check_num_args("lldb::SBTypeCategory::GetSummaryForType",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetSummaryForType",1,"lldb::SBTypeCategory *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::GetSummaryForType",2,"lldb::SBTypeNameSpecifier"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("SBTypeCategory_GetSummaryForType",1,SWIGTYPE_p_lldb__SBTypeCategory); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){ + SWIG_fail_ptr("SBTypeCategory_GetSummaryForType",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier); + } + arg2 = *argp2; + + result = (arg1)->GetSummaryForType(arg2); + { + lldb::SBTypeSummary * resultptr = new lldb::SBTypeSummary(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSummary,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeCategory_GetSyntheticForType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeNameSpecifier arg2 ; + lldb::SBTypeNameSpecifier *argp2 ; + lldb::SBTypeSynthetic result; + + SWIG_check_num_args("lldb::SBTypeCategory::GetSyntheticForType",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetSyntheticForType",1,"lldb::SBTypeCategory *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::GetSyntheticForType",2,"lldb::SBTypeNameSpecifier"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("SBTypeCategory_GetSyntheticForType",1,SWIGTYPE_p_lldb__SBTypeCategory); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){ + SWIG_fail_ptr("SBTypeCategory_GetSyntheticForType",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier); + } + arg2 = *argp2; + + result = (arg1)->GetSyntheticForType(arg2); + { + lldb::SBTypeSynthetic * resultptr = new lldb::SBTypeSynthetic(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSynthetic,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeCategory_GetFilterAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + uint32_t arg2 ; + lldb::SBTypeFilter result; + + SWIG_check_num_args("lldb::SBTypeCategory::GetFilterAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetFilterAtIndex",1,"lldb::SBTypeCategory *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::GetFilterAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("SBTypeCategory_GetFilterAtIndex",1,SWIGTYPE_p_lldb__SBTypeCategory); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetFilterAtIndex(arg2); + { + lldb::SBTypeFilter * resultptr = new lldb::SBTypeFilter(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeFilter,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeCategory_GetFormatAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + uint32_t arg2 ; + lldb::SBTypeFormat result; + + SWIG_check_num_args("lldb::SBTypeCategory::GetFormatAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetFormatAtIndex",1,"lldb::SBTypeCategory *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::GetFormatAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("SBTypeCategory_GetFormatAtIndex",1,SWIGTYPE_p_lldb__SBTypeCategory); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetFormatAtIndex(arg2); + { + lldb::SBTypeFormat * resultptr = new lldb::SBTypeFormat(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeFormat,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeCategory_GetSummaryAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + uint32_t arg2 ; + lldb::SBTypeSummary result; + + SWIG_check_num_args("lldb::SBTypeCategory::GetSummaryAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetSummaryAtIndex",1,"lldb::SBTypeCategory *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::GetSummaryAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("SBTypeCategory_GetSummaryAtIndex",1,SWIGTYPE_p_lldb__SBTypeCategory); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetSummaryAtIndex(arg2); + { + lldb::SBTypeSummary * resultptr = new lldb::SBTypeSummary(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSummary,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeCategory_GetSyntheticAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + uint32_t arg2 ; + lldb::SBTypeSynthetic result; + + SWIG_check_num_args("lldb::SBTypeCategory::GetSyntheticAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::GetSyntheticAtIndex",1,"lldb::SBTypeCategory *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::GetSyntheticAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("SBTypeCategory_GetSyntheticAtIndex",1,SWIGTYPE_p_lldb__SBTypeCategory); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetSyntheticAtIndex(arg2); + { + lldb::SBTypeSynthetic * resultptr = new lldb::SBTypeSynthetic(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSynthetic,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeCategory_AddTypeFormat(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeNameSpecifier arg2 ; + lldb::SBTypeFormat arg3 ; + lldb::SBTypeNameSpecifier *argp2 ; + lldb::SBTypeFormat *argp3 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeCategory::AddTypeFormat",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::AddTypeFormat",1,"lldb::SBTypeCategory *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::AddTypeFormat",2,"lldb::SBTypeNameSpecifier"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTypeCategory::AddTypeFormat",3,"lldb::SBTypeFormat"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("SBTypeCategory_AddTypeFormat",1,SWIGTYPE_p_lldb__SBTypeCategory); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){ + SWIG_fail_ptr("SBTypeCategory_AddTypeFormat",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier); + } + arg2 = *argp2; + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_lldb__SBTypeFormat,0))){ + SWIG_fail_ptr("SBTypeCategory_AddTypeFormat",3,SWIGTYPE_p_lldb__SBTypeFormat); + } + arg3 = *argp3; + + result = (bool)(arg1)->AddTypeFormat(arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeCategory_DeleteTypeFormat(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeNameSpecifier arg2 ; + lldb::SBTypeNameSpecifier *argp2 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeCategory::DeleteTypeFormat",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::DeleteTypeFormat",1,"lldb::SBTypeCategory *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::DeleteTypeFormat",2,"lldb::SBTypeNameSpecifier"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("SBTypeCategory_DeleteTypeFormat",1,SWIGTYPE_p_lldb__SBTypeCategory); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){ + SWIG_fail_ptr("SBTypeCategory_DeleteTypeFormat",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier); + } + arg2 = *argp2; + + result = (bool)(arg1)->DeleteTypeFormat(arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeCategory_AddTypeSummary(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeNameSpecifier arg2 ; + lldb::SBTypeSummary arg3 ; + lldb::SBTypeNameSpecifier *argp2 ; + lldb::SBTypeSummary *argp3 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeCategory::AddTypeSummary",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::AddTypeSummary",1,"lldb::SBTypeCategory *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::AddTypeSummary",2,"lldb::SBTypeNameSpecifier"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTypeCategory::AddTypeSummary",3,"lldb::SBTypeSummary"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("SBTypeCategory_AddTypeSummary",1,SWIGTYPE_p_lldb__SBTypeCategory); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){ + SWIG_fail_ptr("SBTypeCategory_AddTypeSummary",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier); + } + arg2 = *argp2; + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_lldb__SBTypeSummary,0))){ + SWIG_fail_ptr("SBTypeCategory_AddTypeSummary",3,SWIGTYPE_p_lldb__SBTypeSummary); + } + arg3 = *argp3; + + result = (bool)(arg1)->AddTypeSummary(arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeCategory_DeleteTypeSummary(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeNameSpecifier arg2 ; + lldb::SBTypeNameSpecifier *argp2 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeCategory::DeleteTypeSummary",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::DeleteTypeSummary",1,"lldb::SBTypeCategory *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::DeleteTypeSummary",2,"lldb::SBTypeNameSpecifier"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("SBTypeCategory_DeleteTypeSummary",1,SWIGTYPE_p_lldb__SBTypeCategory); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){ + SWIG_fail_ptr("SBTypeCategory_DeleteTypeSummary",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier); + } + arg2 = *argp2; + + result = (bool)(arg1)->DeleteTypeSummary(arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeCategory_AddTypeFilter(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeNameSpecifier arg2 ; + lldb::SBTypeFilter arg3 ; + lldb::SBTypeNameSpecifier *argp2 ; + lldb::SBTypeFilter *argp3 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeCategory::AddTypeFilter",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::AddTypeFilter",1,"lldb::SBTypeCategory *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::AddTypeFilter",2,"lldb::SBTypeNameSpecifier"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTypeCategory::AddTypeFilter",3,"lldb::SBTypeFilter"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("SBTypeCategory_AddTypeFilter",1,SWIGTYPE_p_lldb__SBTypeCategory); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){ + SWIG_fail_ptr("SBTypeCategory_AddTypeFilter",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier); + } + arg2 = *argp2; + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_lldb__SBTypeFilter,0))){ + SWIG_fail_ptr("SBTypeCategory_AddTypeFilter",3,SWIGTYPE_p_lldb__SBTypeFilter); + } + arg3 = *argp3; + + result = (bool)(arg1)->AddTypeFilter(arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeCategory_DeleteTypeFilter(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeNameSpecifier arg2 ; + lldb::SBTypeNameSpecifier *argp2 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeCategory::DeleteTypeFilter",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::DeleteTypeFilter",1,"lldb::SBTypeCategory *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::DeleteTypeFilter",2,"lldb::SBTypeNameSpecifier"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("SBTypeCategory_DeleteTypeFilter",1,SWIGTYPE_p_lldb__SBTypeCategory); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){ + SWIG_fail_ptr("SBTypeCategory_DeleteTypeFilter",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier); + } + arg2 = *argp2; + + result = (bool)(arg1)->DeleteTypeFilter(arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeCategory_AddTypeSynthetic(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeNameSpecifier arg2 ; + lldb::SBTypeSynthetic arg3 ; + lldb::SBTypeNameSpecifier *argp2 ; + lldb::SBTypeSynthetic *argp3 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeCategory::AddTypeSynthetic",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::AddTypeSynthetic",1,"lldb::SBTypeCategory *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::AddTypeSynthetic",2,"lldb::SBTypeNameSpecifier"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBTypeCategory::AddTypeSynthetic",3,"lldb::SBTypeSynthetic"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("SBTypeCategory_AddTypeSynthetic",1,SWIGTYPE_p_lldb__SBTypeCategory); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){ + SWIG_fail_ptr("SBTypeCategory_AddTypeSynthetic",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier); + } + arg2 = *argp2; + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_lldb__SBTypeSynthetic,0))){ + SWIG_fail_ptr("SBTypeCategory_AddTypeSynthetic",3,SWIGTYPE_p_lldb__SBTypeSynthetic); + } + arg3 = *argp3; + + result = (bool)(arg1)->AddTypeSynthetic(arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeCategory_DeleteTypeSynthetic(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeNameSpecifier arg2 ; + lldb::SBTypeNameSpecifier *argp2 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeCategory::DeleteTypeSynthetic",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::DeleteTypeSynthetic",1,"lldb::SBTypeCategory *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::DeleteTypeSynthetic",2,"lldb::SBTypeNameSpecifier"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("SBTypeCategory_DeleteTypeSynthetic",1,SWIGTYPE_p_lldb__SBTypeCategory); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){ + SWIG_fail_ptr("SBTypeCategory_DeleteTypeSynthetic",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier); + } + arg2 = *argp2; + + result = (bool)(arg1)->DeleteTypeSynthetic(arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeCategory___eq(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + lldb::SBTypeCategory *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeCategory::operator ==",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::operator ==",1,"lldb::SBTypeCategory *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeCategory::operator ==",2,"lldb::SBTypeCategory &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("SBTypeCategory___eq",1,SWIGTYPE_p_lldb__SBTypeCategory); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("SBTypeCategory___eq",2,SWIGTYPE_p_lldb__SBTypeCategory); + } + + result = (bool)(arg1)->operator ==(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeCategory___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBTypeCategory::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeCategory::__repr__",1,"lldb::SBTypeCategory *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeCategory,0))){ + SWIG_fail_ptr("SBTypeCategory___tostring",1,SWIGTYPE_p_lldb__SBTypeCategory); + } + + result = lldb_SBTypeCategory___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBTypeCategory(void *obj) { +lldb::SBTypeCategory *arg1 = (lldb::SBTypeCategory *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBTypeCategory(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBTypeCategory); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBTypeCategory_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBTypeCategory_methods[]= { + { "IsValid", _wrap_SBTypeCategory_IsValid}, + { "GetEnabled", _wrap_SBTypeCategory_GetEnabled}, + { "SetEnabled", _wrap_SBTypeCategory_SetEnabled}, + { "GetName", _wrap_SBTypeCategory_GetName}, + { "GetLanguageAtIndex", _wrap_SBTypeCategory_GetLanguageAtIndex}, + { "GetNumLanguages", _wrap_SBTypeCategory_GetNumLanguages}, + { "AddLanguage", _wrap_SBTypeCategory_AddLanguage}, + { "GetDescription", _wrap_SBTypeCategory_GetDescription}, + { "GetNumFormats", _wrap_SBTypeCategory_GetNumFormats}, + { "GetNumSummaries", _wrap_SBTypeCategory_GetNumSummaries}, + { "GetNumFilters", _wrap_SBTypeCategory_GetNumFilters}, + { "GetNumSynthetics", _wrap_SBTypeCategory_GetNumSynthetics}, + { "GetTypeNameSpecifierForFilterAtIndex", _wrap_SBTypeCategory_GetTypeNameSpecifierForFilterAtIndex}, + { "GetTypeNameSpecifierForFormatAtIndex", _wrap_SBTypeCategory_GetTypeNameSpecifierForFormatAtIndex}, + { "GetTypeNameSpecifierForSummaryAtIndex", _wrap_SBTypeCategory_GetTypeNameSpecifierForSummaryAtIndex}, + { "GetTypeNameSpecifierForSyntheticAtIndex", _wrap_SBTypeCategory_GetTypeNameSpecifierForSyntheticAtIndex}, + { "GetFilterForType", _wrap_SBTypeCategory_GetFilterForType}, + { "GetFormatForType", _wrap_SBTypeCategory_GetFormatForType}, + { "GetSummaryForType", _wrap_SBTypeCategory_GetSummaryForType}, + { "GetSyntheticForType", _wrap_SBTypeCategory_GetSyntheticForType}, + { "GetFilterAtIndex", _wrap_SBTypeCategory_GetFilterAtIndex}, + { "GetFormatAtIndex", _wrap_SBTypeCategory_GetFormatAtIndex}, + { "GetSummaryAtIndex", _wrap_SBTypeCategory_GetSummaryAtIndex}, + { "GetSyntheticAtIndex", _wrap_SBTypeCategory_GetSyntheticAtIndex}, + { "AddTypeFormat", _wrap_SBTypeCategory_AddTypeFormat}, + { "DeleteTypeFormat", _wrap_SBTypeCategory_DeleteTypeFormat}, + { "AddTypeSummary", _wrap_SBTypeCategory_AddTypeSummary}, + { "DeleteTypeSummary", _wrap_SBTypeCategory_DeleteTypeSummary}, + { "AddTypeFilter", _wrap_SBTypeCategory_AddTypeFilter}, + { "DeleteTypeFilter", _wrap_SBTypeCategory_DeleteTypeFilter}, + { "AddTypeSynthetic", _wrap_SBTypeCategory_AddTypeSynthetic}, + { "DeleteTypeSynthetic", _wrap_SBTypeCategory_DeleteTypeSynthetic}, + { "__eq", _wrap_SBTypeCategory___eq}, + { "__tostring", _wrap_SBTypeCategory___tostring}, + {0,0} +}; +static swig_lua_method swig_SBTypeCategory_meta[] = { + { "__eq", _wrap_SBTypeCategory___eq}, + { "__tostring", _wrap_SBTypeCategory___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBTypeCategory_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBTypeCategory_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBTypeCategory_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBTypeCategory_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBTypeCategory_Sf_SwigStatic = { + "SBTypeCategory", + swig_SBTypeCategory_Sf_SwigStatic_methods, + swig_SBTypeCategory_Sf_SwigStatic_attributes, + swig_SBTypeCategory_Sf_SwigStatic_constants, + swig_SBTypeCategory_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBTypeCategory_bases[] = {0}; +static const char *swig_SBTypeCategory_base_names[] = {0}; +static swig_lua_class _wrap_class_SBTypeCategory = { "SBTypeCategory", "SBTypeCategory", &SWIGTYPE_p_lldb__SBTypeCategory,_proxy__wrap_new_SBTypeCategory, swig_delete_SBTypeCategory, swig_SBTypeCategory_methods, swig_SBTypeCategory_attributes, &swig_SBTypeCategory_Sf_SwigStatic, swig_SBTypeCategory_meta, swig_SBTypeCategory_bases, swig_SBTypeCategory_base_names }; + +static int _wrap_new_SBTypeEnumMember__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeEnumMember *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeEnumMember::SBTypeEnumMember",0,0) + result = (lldb::SBTypeEnumMember *)new lldb::SBTypeEnumMember(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeEnumMember,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBTypeEnumMember__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeEnumMember *arg1 = 0 ; + lldb::SBTypeEnumMember *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeEnumMember::SBTypeEnumMember",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBTypeEnumMember::SBTypeEnumMember",1,"lldb::SBTypeEnumMember const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeEnumMember,0))){ + SWIG_fail_ptr("new_SBTypeEnumMember",1,SWIGTYPE_p_lldb__SBTypeEnumMember); + } + + result = (lldb::SBTypeEnumMember *)new lldb::SBTypeEnumMember((lldb::SBTypeEnumMember const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeEnumMember,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBTypeEnumMember(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBTypeEnumMember__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTypeEnumMember, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBTypeEnumMember__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBTypeEnumMember'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBTypeEnumMember::SBTypeEnumMember()\n" + " lldb::SBTypeEnumMember::SBTypeEnumMember(lldb::SBTypeEnumMember const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBTypeEnumMember_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeEnumMember *arg1 = (lldb::SBTypeEnumMember *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeEnumMember::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeEnumMember::IsValid",1,"lldb::SBTypeEnumMember const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeEnumMember,0))){ + SWIG_fail_ptr("SBTypeEnumMember_IsValid",1,SWIGTYPE_p_lldb__SBTypeEnumMember); + } + + result = (bool)((lldb::SBTypeEnumMember const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeEnumMember_GetValueAsSigned(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeEnumMember *arg1 = (lldb::SBTypeEnumMember *) 0 ; + int64_t result; + + SWIG_check_num_args("lldb::SBTypeEnumMember::GetValueAsSigned",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeEnumMember::GetValueAsSigned",1,"lldb::SBTypeEnumMember *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeEnumMember,0))){ + SWIG_fail_ptr("SBTypeEnumMember_GetValueAsSigned",1,SWIGTYPE_p_lldb__SBTypeEnumMember); + } + + result = (int64_t)(arg1)->GetValueAsSigned(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeEnumMember_GetValueAsUnsigned(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeEnumMember *arg1 = (lldb::SBTypeEnumMember *) 0 ; + uint64_t result; + + SWIG_check_num_args("lldb::SBTypeEnumMember::GetValueAsUnsigned",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeEnumMember::GetValueAsUnsigned",1,"lldb::SBTypeEnumMember *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeEnumMember,0))){ + SWIG_fail_ptr("SBTypeEnumMember_GetValueAsUnsigned",1,SWIGTYPE_p_lldb__SBTypeEnumMember); + } + + result = (uint64_t)(arg1)->GetValueAsUnsigned(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeEnumMember_GetName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeEnumMember *arg1 = (lldb::SBTypeEnumMember *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeEnumMember::GetName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeEnumMember::GetName",1,"lldb::SBTypeEnumMember *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeEnumMember,0))){ + SWIG_fail_ptr("SBTypeEnumMember_GetName",1,SWIGTYPE_p_lldb__SBTypeEnumMember); + } + + result = (char *)(arg1)->GetName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeEnumMember_GetType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeEnumMember *arg1 = (lldb::SBTypeEnumMember *) 0 ; + lldb::SBType result; + + SWIG_check_num_args("lldb::SBTypeEnumMember::GetType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeEnumMember::GetType",1,"lldb::SBTypeEnumMember *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeEnumMember,0))){ + SWIG_fail_ptr("SBTypeEnumMember_GetType",1,SWIGTYPE_p_lldb__SBTypeEnumMember); + } + + result = (arg1)->GetType(); + { + lldb::SBType * resultptr = new lldb::SBType(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeEnumMember_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeEnumMember *arg1 = (lldb::SBTypeEnumMember *) 0 ; + lldb::SBStream *arg2 = 0 ; + lldb::DescriptionLevel arg3 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeEnumMember::GetDescription",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeEnumMember::GetDescription",1,"lldb::SBTypeEnumMember *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeEnumMember::GetDescription",2,"lldb::SBStream &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTypeEnumMember::GetDescription",3,"lldb::DescriptionLevel"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeEnumMember,0))){ + SWIG_fail_ptr("SBTypeEnumMember_GetDescription",1,SWIGTYPE_p_lldb__SBTypeEnumMember); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBTypeEnumMember_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + arg3 = (lldb::DescriptionLevel)lua_tointeger(L, 3); + result = (bool)(arg1)->GetDescription(*arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeEnumMember___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeEnumMember *arg1 = (lldb::SBTypeEnumMember *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBTypeEnumMember::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeEnumMember::__repr__",1,"lldb::SBTypeEnumMember *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeEnumMember,0))){ + SWIG_fail_ptr("SBTypeEnumMember___tostring",1,SWIGTYPE_p_lldb__SBTypeEnumMember); + } + + result = lldb_SBTypeEnumMember___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBTypeEnumMember(void *obj) { +lldb::SBTypeEnumMember *arg1 = (lldb::SBTypeEnumMember *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBTypeEnumMember(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBTypeEnumMember); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBTypeEnumMember_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBTypeEnumMember_methods[]= { + { "IsValid", _wrap_SBTypeEnumMember_IsValid}, + { "GetValueAsSigned", _wrap_SBTypeEnumMember_GetValueAsSigned}, + { "GetValueAsUnsigned", _wrap_SBTypeEnumMember_GetValueAsUnsigned}, + { "GetName", _wrap_SBTypeEnumMember_GetName}, + { "GetType", _wrap_SBTypeEnumMember_GetType}, + { "GetDescription", _wrap_SBTypeEnumMember_GetDescription}, + { "__tostring", _wrap_SBTypeEnumMember___tostring}, + {0,0} +}; +static swig_lua_method swig_SBTypeEnumMember_meta[] = { + { "__tostring", _wrap_SBTypeEnumMember___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBTypeEnumMember_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBTypeEnumMember_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBTypeEnumMember_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBTypeEnumMember_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBTypeEnumMember_Sf_SwigStatic = { + "SBTypeEnumMember", + swig_SBTypeEnumMember_Sf_SwigStatic_methods, + swig_SBTypeEnumMember_Sf_SwigStatic_attributes, + swig_SBTypeEnumMember_Sf_SwigStatic_constants, + swig_SBTypeEnumMember_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBTypeEnumMember_bases[] = {0}; +static const char *swig_SBTypeEnumMember_base_names[] = {0}; +static swig_lua_class _wrap_class_SBTypeEnumMember = { "SBTypeEnumMember", "SBTypeEnumMember", &SWIGTYPE_p_lldb__SBTypeEnumMember,_proxy__wrap_new_SBTypeEnumMember, swig_delete_SBTypeEnumMember, swig_SBTypeEnumMember_methods, swig_SBTypeEnumMember_attributes, &swig_SBTypeEnumMember_Sf_SwigStatic, swig_SBTypeEnumMember_meta, swig_SBTypeEnumMember_bases, swig_SBTypeEnumMember_base_names }; + +static int _wrap_new_SBTypeEnumMemberList__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeEnumMemberList *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeEnumMemberList::SBTypeEnumMemberList",0,0) + result = (lldb::SBTypeEnumMemberList *)new lldb::SBTypeEnumMemberList(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeEnumMemberList,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBTypeEnumMemberList__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeEnumMemberList *arg1 = 0 ; + lldb::SBTypeEnumMemberList *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeEnumMemberList::SBTypeEnumMemberList",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBTypeEnumMemberList::SBTypeEnumMemberList",1,"lldb::SBTypeEnumMemberList const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeEnumMemberList,0))){ + SWIG_fail_ptr("new_SBTypeEnumMemberList",1,SWIGTYPE_p_lldb__SBTypeEnumMemberList); + } + + result = (lldb::SBTypeEnumMemberList *)new lldb::SBTypeEnumMemberList((lldb::SBTypeEnumMemberList const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeEnumMemberList,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBTypeEnumMemberList(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBTypeEnumMemberList__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTypeEnumMemberList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBTypeEnumMemberList__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBTypeEnumMemberList'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBTypeEnumMemberList::SBTypeEnumMemberList()\n" + " lldb::SBTypeEnumMemberList::SBTypeEnumMemberList(lldb::SBTypeEnumMemberList const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBTypeEnumMemberList_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeEnumMemberList *arg1 = (lldb::SBTypeEnumMemberList *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeEnumMemberList::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeEnumMemberList::IsValid",1,"lldb::SBTypeEnumMemberList *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeEnumMemberList,0))){ + SWIG_fail_ptr("SBTypeEnumMemberList_IsValid",1,SWIGTYPE_p_lldb__SBTypeEnumMemberList); + } + + result = (bool)(arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeEnumMemberList_Append(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeEnumMemberList *arg1 = (lldb::SBTypeEnumMemberList *) 0 ; + lldb::SBTypeEnumMember arg2 ; + lldb::SBTypeEnumMember *argp2 ; + + SWIG_check_num_args("lldb::SBTypeEnumMemberList::Append",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeEnumMemberList::Append",1,"lldb::SBTypeEnumMemberList *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeEnumMemberList::Append",2,"lldb::SBTypeEnumMember"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeEnumMemberList,0))){ + SWIG_fail_ptr("SBTypeEnumMemberList_Append",1,SWIGTYPE_p_lldb__SBTypeEnumMemberList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBTypeEnumMember,0))){ + SWIG_fail_ptr("SBTypeEnumMemberList_Append",2,SWIGTYPE_p_lldb__SBTypeEnumMember); + } + arg2 = *argp2; + + (arg1)->Append(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeEnumMemberList_GetTypeEnumMemberAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeEnumMemberList *arg1 = (lldb::SBTypeEnumMemberList *) 0 ; + uint32_t arg2 ; + lldb::SBTypeEnumMember result; + + SWIG_check_num_args("lldb::SBTypeEnumMemberList::GetTypeEnumMemberAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeEnumMemberList::GetTypeEnumMemberAtIndex",1,"lldb::SBTypeEnumMemberList *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeEnumMemberList::GetTypeEnumMemberAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeEnumMemberList,0))){ + SWIG_fail_ptr("SBTypeEnumMemberList_GetTypeEnumMemberAtIndex",1,SWIGTYPE_p_lldb__SBTypeEnumMemberList); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetTypeEnumMemberAtIndex(arg2); + { + lldb::SBTypeEnumMember * resultptr = new lldb::SBTypeEnumMember(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeEnumMember,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeEnumMemberList_GetSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeEnumMemberList *arg1 = (lldb::SBTypeEnumMemberList *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBTypeEnumMemberList::GetSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeEnumMemberList::GetSize",1,"lldb::SBTypeEnumMemberList *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeEnumMemberList,0))){ + SWIG_fail_ptr("SBTypeEnumMemberList_GetSize",1,SWIGTYPE_p_lldb__SBTypeEnumMemberList); + } + + result = (uint32_t)(arg1)->GetSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBTypeEnumMemberList(void *obj) { +lldb::SBTypeEnumMemberList *arg1 = (lldb::SBTypeEnumMemberList *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBTypeEnumMemberList(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBTypeEnumMemberList); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBTypeEnumMemberList_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBTypeEnumMemberList_methods[]= { + { "IsValid", _wrap_SBTypeEnumMemberList_IsValid}, + { "Append", _wrap_SBTypeEnumMemberList_Append}, + { "GetTypeEnumMemberAtIndex", _wrap_SBTypeEnumMemberList_GetTypeEnumMemberAtIndex}, + { "GetSize", _wrap_SBTypeEnumMemberList_GetSize}, + {0,0} +}; +static swig_lua_method swig_SBTypeEnumMemberList_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBTypeEnumMemberList_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBTypeEnumMemberList_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBTypeEnumMemberList_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBTypeEnumMemberList_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBTypeEnumMemberList_Sf_SwigStatic = { + "SBTypeEnumMemberList", + swig_SBTypeEnumMemberList_Sf_SwigStatic_methods, + swig_SBTypeEnumMemberList_Sf_SwigStatic_attributes, + swig_SBTypeEnumMemberList_Sf_SwigStatic_constants, + swig_SBTypeEnumMemberList_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBTypeEnumMemberList_bases[] = {0}; +static const char *swig_SBTypeEnumMemberList_base_names[] = {0}; +static swig_lua_class _wrap_class_SBTypeEnumMemberList = { "SBTypeEnumMemberList", "SBTypeEnumMemberList", &SWIGTYPE_p_lldb__SBTypeEnumMemberList,_proxy__wrap_new_SBTypeEnumMemberList, swig_delete_SBTypeEnumMemberList, swig_SBTypeEnumMemberList_methods, swig_SBTypeEnumMemberList_attributes, &swig_SBTypeEnumMemberList_Sf_SwigStatic, swig_SBTypeEnumMemberList_meta, swig_SBTypeEnumMemberList_bases, swig_SBTypeEnumMemberList_base_names }; + +static int _wrap_new_SBTypeFilter__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeFilter *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeFilter::SBTypeFilter",0,0) + result = (lldb::SBTypeFilter *)new lldb::SBTypeFilter(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeFilter,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBTypeFilter__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + uint32_t arg1 ; + lldb::SBTypeFilter *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeFilter::SBTypeFilter",1,1) + if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBTypeFilter::SBTypeFilter",1,"uint32_t"); + arg1 = (uint32_t)lua_tointeger(L, 1); + result = (lldb::SBTypeFilter *)new lldb::SBTypeFilter(arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeFilter,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBTypeFilter__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeFilter *arg1 = 0 ; + lldb::SBTypeFilter *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeFilter::SBTypeFilter",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBTypeFilter::SBTypeFilter",1,"lldb::SBTypeFilter const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFilter,0))){ + SWIG_fail_ptr("new_SBTypeFilter",1,SWIGTYPE_p_lldb__SBTypeFilter); + } + + result = (lldb::SBTypeFilter *)new lldb::SBTypeFilter((lldb::SBTypeFilter const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeFilter,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBTypeFilter(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBTypeFilter__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTypeFilter, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBTypeFilter__SWIG_2(L); + } + } + if (argc == 1) { + int _v = 0; + { + _v = lua_isnumber(L,argv[0]); + } + if (_v) { + return _wrap_new_SBTypeFilter__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBTypeFilter_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeFilter::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFilter::IsValid",1,"lldb::SBTypeFilter const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFilter,0))){ + SWIG_fail_ptr("SBTypeFilter_IsValid",1,SWIGTYPE_p_lldb__SBTypeFilter); + } + + result = (bool)((lldb::SBTypeFilter const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeFilter_GetNumberOfExpressionPaths(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBTypeFilter::GetNumberOfExpressionPaths",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFilter::GetNumberOfExpressionPaths",1,"lldb::SBTypeFilter *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFilter,0))){ + SWIG_fail_ptr("SBTypeFilter_GetNumberOfExpressionPaths",1,SWIGTYPE_p_lldb__SBTypeFilter); + } + + result = (uint32_t)(arg1)->GetNumberOfExpressionPaths(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeFilter_GetExpressionPathAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ; + uint32_t arg2 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeFilter::GetExpressionPathAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFilter::GetExpressionPathAtIndex",1,"lldb::SBTypeFilter *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeFilter::GetExpressionPathAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFilter,0))){ + SWIG_fail_ptr("SBTypeFilter_GetExpressionPathAtIndex",1,SWIGTYPE_p_lldb__SBTypeFilter); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (char *)(arg1)->GetExpressionPathAtIndex(arg2); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeFilter_ReplaceExpressionPathAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ; + uint32_t arg2 ; + char *arg3 = (char *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeFilter::ReplaceExpressionPathAtIndex",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFilter::ReplaceExpressionPathAtIndex",1,"lldb::SBTypeFilter *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeFilter::ReplaceExpressionPathAtIndex",2,"uint32_t"); + if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBTypeFilter::ReplaceExpressionPathAtIndex",3,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFilter,0))){ + SWIG_fail_ptr("SBTypeFilter_ReplaceExpressionPathAtIndex",1,SWIGTYPE_p_lldb__SBTypeFilter); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + arg3 = (char *)lua_tostring(L, 3); + result = (bool)(arg1)->ReplaceExpressionPathAtIndex(arg2,(char const *)arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeFilter_AppendExpressionPath(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBTypeFilter::AppendExpressionPath",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFilter::AppendExpressionPath",1,"lldb::SBTypeFilter *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTypeFilter::AppendExpressionPath",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFilter,0))){ + SWIG_fail_ptr("SBTypeFilter_AppendExpressionPath",1,SWIGTYPE_p_lldb__SBTypeFilter); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->AppendExpressionPath((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeFilter_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ; + + SWIG_check_num_args("lldb::SBTypeFilter::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFilter::Clear",1,"lldb::SBTypeFilter *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFilter,0))){ + SWIG_fail_ptr("SBTypeFilter_Clear",1,SWIGTYPE_p_lldb__SBTypeFilter); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeFilter_GetOptions(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBTypeFilter::GetOptions",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFilter::GetOptions",1,"lldb::SBTypeFilter *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFilter,0))){ + SWIG_fail_ptr("SBTypeFilter_GetOptions",1,SWIGTYPE_p_lldb__SBTypeFilter); + } + + result = (uint32_t)(arg1)->GetOptions(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeFilter_SetOptions(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ; + uint32_t arg2 ; + + SWIG_check_num_args("lldb::SBTypeFilter::SetOptions",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFilter::SetOptions",1,"lldb::SBTypeFilter *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeFilter::SetOptions",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFilter,0))){ + SWIG_fail_ptr("SBTypeFilter_SetOptions",1,SWIGTYPE_p_lldb__SBTypeFilter); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + (arg1)->SetOptions(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeFilter_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ; + lldb::SBStream *arg2 = 0 ; + lldb::DescriptionLevel arg3 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeFilter::GetDescription",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFilter::GetDescription",1,"lldb::SBTypeFilter *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeFilter::GetDescription",2,"lldb::SBStream &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTypeFilter::GetDescription",3,"lldb::DescriptionLevel"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFilter,0))){ + SWIG_fail_ptr("SBTypeFilter_GetDescription",1,SWIGTYPE_p_lldb__SBTypeFilter); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBTypeFilter_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + arg3 = (lldb::DescriptionLevel)lua_tointeger(L, 3); + result = (bool)(arg1)->GetDescription(*arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeFilter_IsEqualTo(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ; + lldb::SBTypeFilter *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeFilter::IsEqualTo",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFilter::IsEqualTo",1,"lldb::SBTypeFilter *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeFilter::IsEqualTo",2,"lldb::SBTypeFilter &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFilter,0))){ + SWIG_fail_ptr("SBTypeFilter_IsEqualTo",1,SWIGTYPE_p_lldb__SBTypeFilter); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTypeFilter,0))){ + SWIG_fail_ptr("SBTypeFilter_IsEqualTo",2,SWIGTYPE_p_lldb__SBTypeFilter); + } + + result = (bool)(arg1)->IsEqualTo(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeFilter___eq(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ; + lldb::SBTypeFilter *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeFilter::operator ==",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFilter::operator ==",1,"lldb::SBTypeFilter *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeFilter::operator ==",2,"lldb::SBTypeFilter &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFilter,0))){ + SWIG_fail_ptr("SBTypeFilter___eq",1,SWIGTYPE_p_lldb__SBTypeFilter); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTypeFilter,0))){ + SWIG_fail_ptr("SBTypeFilter___eq",2,SWIGTYPE_p_lldb__SBTypeFilter); + } + + result = (bool)(arg1)->operator ==(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeFilter___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBTypeFilter::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFilter::__repr__",1,"lldb::SBTypeFilter *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFilter,0))){ + SWIG_fail_ptr("SBTypeFilter___tostring",1,SWIGTYPE_p_lldb__SBTypeFilter); + } + + result = lldb_SBTypeFilter___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBTypeFilter(void *obj) { +lldb::SBTypeFilter *arg1 = (lldb::SBTypeFilter *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBTypeFilter(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBTypeFilter); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBTypeFilter_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBTypeFilter_methods[]= { + { "IsValid", _wrap_SBTypeFilter_IsValid}, + { "GetNumberOfExpressionPaths", _wrap_SBTypeFilter_GetNumberOfExpressionPaths}, + { "GetExpressionPathAtIndex", _wrap_SBTypeFilter_GetExpressionPathAtIndex}, + { "ReplaceExpressionPathAtIndex", _wrap_SBTypeFilter_ReplaceExpressionPathAtIndex}, + { "AppendExpressionPath", _wrap_SBTypeFilter_AppendExpressionPath}, + { "Clear", _wrap_SBTypeFilter_Clear}, + { "GetOptions", _wrap_SBTypeFilter_GetOptions}, + { "SetOptions", _wrap_SBTypeFilter_SetOptions}, + { "GetDescription", _wrap_SBTypeFilter_GetDescription}, + { "IsEqualTo", _wrap_SBTypeFilter_IsEqualTo}, + { "__eq", _wrap_SBTypeFilter___eq}, + { "__tostring", _wrap_SBTypeFilter___tostring}, + {0,0} +}; +static swig_lua_method swig_SBTypeFilter_meta[] = { + { "__eq", _wrap_SBTypeFilter___eq}, + { "__tostring", _wrap_SBTypeFilter___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBTypeFilter_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBTypeFilter_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBTypeFilter_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBTypeFilter_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBTypeFilter_Sf_SwigStatic = { + "SBTypeFilter", + swig_SBTypeFilter_Sf_SwigStatic_methods, + swig_SBTypeFilter_Sf_SwigStatic_attributes, + swig_SBTypeFilter_Sf_SwigStatic_constants, + swig_SBTypeFilter_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBTypeFilter_bases[] = {0}; +static const char *swig_SBTypeFilter_base_names[] = {0}; +static swig_lua_class _wrap_class_SBTypeFilter = { "SBTypeFilter", "SBTypeFilter", &SWIGTYPE_p_lldb__SBTypeFilter,_proxy__wrap_new_SBTypeFilter, swig_delete_SBTypeFilter, swig_SBTypeFilter_methods, swig_SBTypeFilter_attributes, &swig_SBTypeFilter_Sf_SwigStatic, swig_SBTypeFilter_meta, swig_SBTypeFilter_bases, swig_SBTypeFilter_base_names }; + +static int _wrap_new_SBTypeFormat__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeFormat *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeFormat::SBTypeFormat",0,0) + result = (lldb::SBTypeFormat *)new lldb::SBTypeFormat(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeFormat,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBTypeFormat__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::Format arg1 ; + uint32_t arg2 ; + lldb::SBTypeFormat *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeFormat::SBTypeFormat",2,2) + if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBTypeFormat::SBTypeFormat",1,"lldb::Format"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeFormat::SBTypeFormat",2,"uint32_t"); + arg1 = (lldb::Format)lua_tointeger(L, 1); + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (lldb::SBTypeFormat *)new lldb::SBTypeFormat(arg1,arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeFormat,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBTypeFormat__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::Format arg1 ; + lldb::SBTypeFormat *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeFormat::SBTypeFormat",1,1) + if(!lua_isinteger(L,1)) SWIG_fail_arg("lldb::SBTypeFormat::SBTypeFormat",1,"lldb::Format"); + arg1 = (lldb::Format)lua_tointeger(L, 1); + result = (lldb::SBTypeFormat *)new lldb::SBTypeFormat(arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeFormat,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBTypeFormat__SWIG_3(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + uint32_t arg2 ; + lldb::SBTypeFormat *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeFormat::SBTypeFormat",2,2) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBTypeFormat::SBTypeFormat",1,"char const *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeFormat::SBTypeFormat",2,"uint32_t"); + arg1 = (char *)lua_tostring(L, 1); + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (lldb::SBTypeFormat *)new lldb::SBTypeFormat((char const *)arg1,arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeFormat,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBTypeFormat__SWIG_4(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + lldb::SBTypeFormat *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeFormat::SBTypeFormat",1,1) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBTypeFormat::SBTypeFormat",1,"char const *"); + arg1 = (char *)lua_tostring(L, 1); + result = (lldb::SBTypeFormat *)new lldb::SBTypeFormat((char const *)arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeFormat,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBTypeFormat__SWIG_5(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeFormat *arg1 = 0 ; + lldb::SBTypeFormat *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeFormat::SBTypeFormat",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBTypeFormat::SBTypeFormat",1,"lldb::SBTypeFormat const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFormat,0))){ + SWIG_fail_ptr("new_SBTypeFormat",1,SWIGTYPE_p_lldb__SBTypeFormat); + } + + result = (lldb::SBTypeFormat *)new lldb::SBTypeFormat((lldb::SBTypeFormat const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeFormat,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBTypeFormat(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBTypeFormat__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTypeFormat, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBTypeFormat__SWIG_5(L); + } + } + if (argc == 1) { + int _v = 0; + { + _v = lua_isnumber(L,argv[0]); + } + if (_v) { + return _wrap_new_SBTypeFormat__SWIG_2(L); + } + } + if (argc == 1) { + int _v = 0; + { + _v = SWIG_lua_isnilstring(L,argv[0]); + } + if (_v) { + return _wrap_new_SBTypeFormat__SWIG_4(L); + } + } + if (argc == 2) { + int _v = 0; + { + _v = lua_isnumber(L,argv[0]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_new_SBTypeFormat__SWIG_1(L); + } + } + } + if (argc == 2) { + int _v = 0; + { + _v = SWIG_lua_isnilstring(L,argv[0]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_new_SBTypeFormat__SWIG_3(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBTypeFormat_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeFormat::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFormat::IsValid",1,"lldb::SBTypeFormat const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFormat,0))){ + SWIG_fail_ptr("SBTypeFormat_IsValid",1,SWIGTYPE_p_lldb__SBTypeFormat); + } + + result = (bool)((lldb::SBTypeFormat const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeFormat_GetFormat(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ; + lldb::Format result; + + SWIG_check_num_args("lldb::SBTypeFormat::GetFormat",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFormat::GetFormat",1,"lldb::SBTypeFormat *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFormat,0))){ + SWIG_fail_ptr("SBTypeFormat_GetFormat",1,SWIGTYPE_p_lldb__SBTypeFormat); + } + + result = (lldb::Format)(arg1)->GetFormat(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeFormat_GetTypeName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeFormat::GetTypeName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFormat::GetTypeName",1,"lldb::SBTypeFormat *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFormat,0))){ + SWIG_fail_ptr("SBTypeFormat_GetTypeName",1,SWIGTYPE_p_lldb__SBTypeFormat); + } + + result = (char *)(arg1)->GetTypeName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeFormat_GetOptions(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBTypeFormat::GetOptions",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFormat::GetOptions",1,"lldb::SBTypeFormat *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFormat,0))){ + SWIG_fail_ptr("SBTypeFormat_GetOptions",1,SWIGTYPE_p_lldb__SBTypeFormat); + } + + result = (uint32_t)(arg1)->GetOptions(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeFormat_SetFormat(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ; + lldb::Format arg2 ; + + SWIG_check_num_args("lldb::SBTypeFormat::SetFormat",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFormat::SetFormat",1,"lldb::SBTypeFormat *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeFormat::SetFormat",2,"lldb::Format"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFormat,0))){ + SWIG_fail_ptr("SBTypeFormat_SetFormat",1,SWIGTYPE_p_lldb__SBTypeFormat); + } + + arg2 = (lldb::Format)lua_tointeger(L, 2); + (arg1)->SetFormat(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeFormat_SetTypeName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBTypeFormat::SetTypeName",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFormat::SetTypeName",1,"lldb::SBTypeFormat *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTypeFormat::SetTypeName",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFormat,0))){ + SWIG_fail_ptr("SBTypeFormat_SetTypeName",1,SWIGTYPE_p_lldb__SBTypeFormat); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetTypeName((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeFormat_SetOptions(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ; + uint32_t arg2 ; + + SWIG_check_num_args("lldb::SBTypeFormat::SetOptions",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFormat::SetOptions",1,"lldb::SBTypeFormat *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeFormat::SetOptions",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFormat,0))){ + SWIG_fail_ptr("SBTypeFormat_SetOptions",1,SWIGTYPE_p_lldb__SBTypeFormat); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + (arg1)->SetOptions(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeFormat_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ; + lldb::SBStream *arg2 = 0 ; + lldb::DescriptionLevel arg3 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeFormat::GetDescription",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFormat::GetDescription",1,"lldb::SBTypeFormat *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeFormat::GetDescription",2,"lldb::SBStream &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTypeFormat::GetDescription",3,"lldb::DescriptionLevel"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFormat,0))){ + SWIG_fail_ptr("SBTypeFormat_GetDescription",1,SWIGTYPE_p_lldb__SBTypeFormat); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBTypeFormat_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + arg3 = (lldb::DescriptionLevel)lua_tointeger(L, 3); + result = (bool)(arg1)->GetDescription(*arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeFormat_IsEqualTo(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ; + lldb::SBTypeFormat *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeFormat::IsEqualTo",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFormat::IsEqualTo",1,"lldb::SBTypeFormat *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeFormat::IsEqualTo",2,"lldb::SBTypeFormat &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFormat,0))){ + SWIG_fail_ptr("SBTypeFormat_IsEqualTo",1,SWIGTYPE_p_lldb__SBTypeFormat); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTypeFormat,0))){ + SWIG_fail_ptr("SBTypeFormat_IsEqualTo",2,SWIGTYPE_p_lldb__SBTypeFormat); + } + + result = (bool)(arg1)->IsEqualTo(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeFormat___eq(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ; + lldb::SBTypeFormat *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeFormat::operator ==",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFormat::operator ==",1,"lldb::SBTypeFormat *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeFormat::operator ==",2,"lldb::SBTypeFormat &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFormat,0))){ + SWIG_fail_ptr("SBTypeFormat___eq",1,SWIGTYPE_p_lldb__SBTypeFormat); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTypeFormat,0))){ + SWIG_fail_ptr("SBTypeFormat___eq",2,SWIGTYPE_p_lldb__SBTypeFormat); + } + + result = (bool)(arg1)->operator ==(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeFormat___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBTypeFormat::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeFormat::__repr__",1,"lldb::SBTypeFormat *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeFormat,0))){ + SWIG_fail_ptr("SBTypeFormat___tostring",1,SWIGTYPE_p_lldb__SBTypeFormat); + } + + result = lldb_SBTypeFormat___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBTypeFormat(void *obj) { +lldb::SBTypeFormat *arg1 = (lldb::SBTypeFormat *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBTypeFormat(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBTypeFormat); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBTypeFormat_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBTypeFormat_methods[]= { + { "IsValid", _wrap_SBTypeFormat_IsValid}, + { "GetFormat", _wrap_SBTypeFormat_GetFormat}, + { "GetTypeName", _wrap_SBTypeFormat_GetTypeName}, + { "GetOptions", _wrap_SBTypeFormat_GetOptions}, + { "SetFormat", _wrap_SBTypeFormat_SetFormat}, + { "SetTypeName", _wrap_SBTypeFormat_SetTypeName}, + { "SetOptions", _wrap_SBTypeFormat_SetOptions}, + { "GetDescription", _wrap_SBTypeFormat_GetDescription}, + { "IsEqualTo", _wrap_SBTypeFormat_IsEqualTo}, + { "__eq", _wrap_SBTypeFormat___eq}, + { "__tostring", _wrap_SBTypeFormat___tostring}, + {0,0} +}; +static swig_lua_method swig_SBTypeFormat_meta[] = { + { "__eq", _wrap_SBTypeFormat___eq}, + { "__tostring", _wrap_SBTypeFormat___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBTypeFormat_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBTypeFormat_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBTypeFormat_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBTypeFormat_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBTypeFormat_Sf_SwigStatic = { + "SBTypeFormat", + swig_SBTypeFormat_Sf_SwigStatic_methods, + swig_SBTypeFormat_Sf_SwigStatic_attributes, + swig_SBTypeFormat_Sf_SwigStatic_constants, + swig_SBTypeFormat_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBTypeFormat_bases[] = {0}; +static const char *swig_SBTypeFormat_base_names[] = {0}; +static swig_lua_class _wrap_class_SBTypeFormat = { "SBTypeFormat", "SBTypeFormat", &SWIGTYPE_p_lldb__SBTypeFormat,_proxy__wrap_new_SBTypeFormat, swig_delete_SBTypeFormat, swig_SBTypeFormat_methods, swig_SBTypeFormat_attributes, &swig_SBTypeFormat_Sf_SwigStatic, swig_SBTypeFormat_meta, swig_SBTypeFormat_bases, swig_SBTypeFormat_base_names }; + +static int _wrap_new_SBTypeNameSpecifier__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeNameSpecifier *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeNameSpecifier::SBTypeNameSpecifier",0,0) + result = (lldb::SBTypeNameSpecifier *)new lldb::SBTypeNameSpecifier(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeNameSpecifier,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBTypeNameSpecifier__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + bool arg2 ; + lldb::SBTypeNameSpecifier *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeNameSpecifier::SBTypeNameSpecifier",2,2) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::SBTypeNameSpecifier",1,"char const *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::SBTypeNameSpecifier",2,"bool"); + arg1 = (char *)lua_tostring(L, 1); + arg2 = (lua_toboolean(L, 2)!=0); + result = (lldb::SBTypeNameSpecifier *)new lldb::SBTypeNameSpecifier((char const *)arg1,arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeNameSpecifier,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBTypeNameSpecifier__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + lldb::SBTypeNameSpecifier *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeNameSpecifier::SBTypeNameSpecifier",1,1) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::SBTypeNameSpecifier",1,"char const *"); + arg1 = (char *)lua_tostring(L, 1); + result = (lldb::SBTypeNameSpecifier *)new lldb::SBTypeNameSpecifier((char const *)arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeNameSpecifier,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBTypeNameSpecifier__SWIG_3(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + lldb::FormatterMatchType arg2 ; + lldb::SBTypeNameSpecifier *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeNameSpecifier::SBTypeNameSpecifier",2,2) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::SBTypeNameSpecifier",1,"char const *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::SBTypeNameSpecifier",2,"lldb::FormatterMatchType"); + arg1 = (char *)lua_tostring(L, 1); + arg2 = (lldb::FormatterMatchType)lua_tointeger(L, 2); + result = (lldb::SBTypeNameSpecifier *)new lldb::SBTypeNameSpecifier((char const *)arg1,arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeNameSpecifier,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBTypeNameSpecifier__SWIG_4(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBType arg1 ; + lldb::SBType *argp1 ; + lldb::SBTypeNameSpecifier *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeNameSpecifier::SBTypeNameSpecifier",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::SBTypeNameSpecifier",1,"lldb::SBType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&argp1,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("new_SBTypeNameSpecifier",1,SWIGTYPE_p_lldb__SBType); + } + arg1 = *argp1; + + result = (lldb::SBTypeNameSpecifier *)new lldb::SBTypeNameSpecifier(arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeNameSpecifier,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBTypeNameSpecifier__SWIG_5(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeNameSpecifier *arg1 = 0 ; + lldb::SBTypeNameSpecifier *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeNameSpecifier::SBTypeNameSpecifier",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::SBTypeNameSpecifier",1,"lldb::SBTypeNameSpecifier const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){ + SWIG_fail_ptr("new_SBTypeNameSpecifier",1,SWIGTYPE_p_lldb__SBTypeNameSpecifier); + } + + result = (lldb::SBTypeNameSpecifier *)new lldb::SBTypeNameSpecifier((lldb::SBTypeNameSpecifier const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeNameSpecifier,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBTypeNameSpecifier(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBTypeNameSpecifier__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBType, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBTypeNameSpecifier__SWIG_4(L); + } + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTypeNameSpecifier, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBTypeNameSpecifier__SWIG_5(L); + } + } + if (argc == 1) { + int _v = 0; + { + _v = SWIG_lua_isnilstring(L,argv[0]); + } + if (_v) { + return _wrap_new_SBTypeNameSpecifier__SWIG_2(L); + } + } + if (argc == 2) { + int _v = 0; + { + _v = SWIG_lua_isnilstring(L,argv[0]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[1]); + } + if (_v) { + return _wrap_new_SBTypeNameSpecifier__SWIG_1(L); + } + } + } + if (argc == 2) { + int _v = 0; + { + _v = SWIG_lua_isnilstring(L,argv[0]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_new_SBTypeNameSpecifier__SWIG_3(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBTypeNameSpecifier_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeNameSpecifier *arg1 = (lldb::SBTypeNameSpecifier *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeNameSpecifier::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::IsValid",1,"lldb::SBTypeNameSpecifier const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){ + SWIG_fail_ptr("SBTypeNameSpecifier_IsValid",1,SWIGTYPE_p_lldb__SBTypeNameSpecifier); + } + + result = (bool)((lldb::SBTypeNameSpecifier const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeNameSpecifier_GetName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeNameSpecifier *arg1 = (lldb::SBTypeNameSpecifier *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeNameSpecifier::GetName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::GetName",1,"lldb::SBTypeNameSpecifier *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){ + SWIG_fail_ptr("SBTypeNameSpecifier_GetName",1,SWIGTYPE_p_lldb__SBTypeNameSpecifier); + } + + result = (char *)(arg1)->GetName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeNameSpecifier_GetType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeNameSpecifier *arg1 = (lldb::SBTypeNameSpecifier *) 0 ; + lldb::SBType result; + + SWIG_check_num_args("lldb::SBTypeNameSpecifier::GetType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::GetType",1,"lldb::SBTypeNameSpecifier *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){ + SWIG_fail_ptr("SBTypeNameSpecifier_GetType",1,SWIGTYPE_p_lldb__SBTypeNameSpecifier); + } + + result = (arg1)->GetType(); + { + lldb::SBType * resultptr = new lldb::SBType(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeNameSpecifier_GetMatchType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeNameSpecifier *arg1 = (lldb::SBTypeNameSpecifier *) 0 ; + lldb::FormatterMatchType result; + + SWIG_check_num_args("lldb::SBTypeNameSpecifier::GetMatchType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::GetMatchType",1,"lldb::SBTypeNameSpecifier *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){ + SWIG_fail_ptr("SBTypeNameSpecifier_GetMatchType",1,SWIGTYPE_p_lldb__SBTypeNameSpecifier); + } + + result = (lldb::FormatterMatchType)(arg1)->GetMatchType(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeNameSpecifier_IsRegex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeNameSpecifier *arg1 = (lldb::SBTypeNameSpecifier *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeNameSpecifier::IsRegex",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::IsRegex",1,"lldb::SBTypeNameSpecifier *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){ + SWIG_fail_ptr("SBTypeNameSpecifier_IsRegex",1,SWIGTYPE_p_lldb__SBTypeNameSpecifier); + } + + result = (bool)(arg1)->IsRegex(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeNameSpecifier_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeNameSpecifier *arg1 = (lldb::SBTypeNameSpecifier *) 0 ; + lldb::SBStream *arg2 = 0 ; + lldb::DescriptionLevel arg3 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeNameSpecifier::GetDescription",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::GetDescription",1,"lldb::SBTypeNameSpecifier *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::GetDescription",2,"lldb::SBStream &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::GetDescription",3,"lldb::DescriptionLevel"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){ + SWIG_fail_ptr("SBTypeNameSpecifier_GetDescription",1,SWIGTYPE_p_lldb__SBTypeNameSpecifier); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBTypeNameSpecifier_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + arg3 = (lldb::DescriptionLevel)lua_tointeger(L, 3); + result = (bool)(arg1)->GetDescription(*arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeNameSpecifier_IsEqualTo(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeNameSpecifier *arg1 = (lldb::SBTypeNameSpecifier *) 0 ; + lldb::SBTypeNameSpecifier *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeNameSpecifier::IsEqualTo",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::IsEqualTo",1,"lldb::SBTypeNameSpecifier *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::IsEqualTo",2,"lldb::SBTypeNameSpecifier &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){ + SWIG_fail_ptr("SBTypeNameSpecifier_IsEqualTo",1,SWIGTYPE_p_lldb__SBTypeNameSpecifier); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){ + SWIG_fail_ptr("SBTypeNameSpecifier_IsEqualTo",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier); + } + + result = (bool)(arg1)->IsEqualTo(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeNameSpecifier___eq(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeNameSpecifier *arg1 = (lldb::SBTypeNameSpecifier *) 0 ; + lldb::SBTypeNameSpecifier *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeNameSpecifier::operator ==",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::operator ==",1,"lldb::SBTypeNameSpecifier *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::operator ==",2,"lldb::SBTypeNameSpecifier &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){ + SWIG_fail_ptr("SBTypeNameSpecifier___eq",1,SWIGTYPE_p_lldb__SBTypeNameSpecifier); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){ + SWIG_fail_ptr("SBTypeNameSpecifier___eq",2,SWIGTYPE_p_lldb__SBTypeNameSpecifier); + } + + result = (bool)(arg1)->operator ==(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeNameSpecifier___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeNameSpecifier *arg1 = (lldb::SBTypeNameSpecifier *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBTypeNameSpecifier::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeNameSpecifier::__repr__",1,"lldb::SBTypeNameSpecifier *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeNameSpecifier,0))){ + SWIG_fail_ptr("SBTypeNameSpecifier___tostring",1,SWIGTYPE_p_lldb__SBTypeNameSpecifier); + } + + result = lldb_SBTypeNameSpecifier___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBTypeNameSpecifier(void *obj) { +lldb::SBTypeNameSpecifier *arg1 = (lldb::SBTypeNameSpecifier *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBTypeNameSpecifier(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBTypeNameSpecifier); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBTypeNameSpecifier_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBTypeNameSpecifier_methods[]= { + { "IsValid", _wrap_SBTypeNameSpecifier_IsValid}, + { "GetName", _wrap_SBTypeNameSpecifier_GetName}, + { "GetType", _wrap_SBTypeNameSpecifier_GetType}, + { "GetMatchType", _wrap_SBTypeNameSpecifier_GetMatchType}, + { "IsRegex", _wrap_SBTypeNameSpecifier_IsRegex}, + { "GetDescription", _wrap_SBTypeNameSpecifier_GetDescription}, + { "IsEqualTo", _wrap_SBTypeNameSpecifier_IsEqualTo}, + { "__eq", _wrap_SBTypeNameSpecifier___eq}, + { "__tostring", _wrap_SBTypeNameSpecifier___tostring}, + {0,0} +}; +static swig_lua_method swig_SBTypeNameSpecifier_meta[] = { + { "__eq", _wrap_SBTypeNameSpecifier___eq}, + { "__tostring", _wrap_SBTypeNameSpecifier___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBTypeNameSpecifier_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBTypeNameSpecifier_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBTypeNameSpecifier_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBTypeNameSpecifier_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBTypeNameSpecifier_Sf_SwigStatic = { + "SBTypeNameSpecifier", + swig_SBTypeNameSpecifier_Sf_SwigStatic_methods, + swig_SBTypeNameSpecifier_Sf_SwigStatic_attributes, + swig_SBTypeNameSpecifier_Sf_SwigStatic_constants, + swig_SBTypeNameSpecifier_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBTypeNameSpecifier_bases[] = {0}; +static const char *swig_SBTypeNameSpecifier_base_names[] = {0}; +static swig_lua_class _wrap_class_SBTypeNameSpecifier = { "SBTypeNameSpecifier", "SBTypeNameSpecifier", &SWIGTYPE_p_lldb__SBTypeNameSpecifier,_proxy__wrap_new_SBTypeNameSpecifier, swig_delete_SBTypeNameSpecifier, swig_SBTypeNameSpecifier_methods, swig_SBTypeNameSpecifier_attributes, &swig_SBTypeNameSpecifier_Sf_SwigStatic, swig_SBTypeNameSpecifier_meta, swig_SBTypeNameSpecifier_bases, swig_SBTypeNameSpecifier_base_names }; + +static int _wrap_new_SBTypeSummaryOptions__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSummaryOptions *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeSummaryOptions::SBTypeSummaryOptions",0,0) + result = (lldb::SBTypeSummaryOptions *)new lldb::SBTypeSummaryOptions(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeSummaryOptions,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBTypeSummaryOptions__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSummaryOptions *arg1 = 0 ; + lldb::SBTypeSummaryOptions *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeSummaryOptions::SBTypeSummaryOptions",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBTypeSummaryOptions::SBTypeSummaryOptions",1,"lldb::SBTypeSummaryOptions const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummaryOptions,0))){ + SWIG_fail_ptr("new_SBTypeSummaryOptions",1,SWIGTYPE_p_lldb__SBTypeSummaryOptions); + } + + result = (lldb::SBTypeSummaryOptions *)new lldb::SBTypeSummaryOptions((lldb::SBTypeSummaryOptions const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeSummaryOptions,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBTypeSummaryOptions(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBTypeSummaryOptions__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTypeSummaryOptions, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBTypeSummaryOptions__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBTypeSummaryOptions'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBTypeSummaryOptions::SBTypeSummaryOptions()\n" + " lldb::SBTypeSummaryOptions::SBTypeSummaryOptions(lldb::SBTypeSummaryOptions const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBTypeSummaryOptions_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSummaryOptions *arg1 = (lldb::SBTypeSummaryOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeSummaryOptions::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummaryOptions::IsValid",1,"lldb::SBTypeSummaryOptions *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummaryOptions,0))){ + SWIG_fail_ptr("SBTypeSummaryOptions_IsValid",1,SWIGTYPE_p_lldb__SBTypeSummaryOptions); + } + + result = (bool)(arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSummaryOptions_GetLanguage(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSummaryOptions *arg1 = (lldb::SBTypeSummaryOptions *) 0 ; + lldb::LanguageType result; + + SWIG_check_num_args("lldb::SBTypeSummaryOptions::GetLanguage",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummaryOptions::GetLanguage",1,"lldb::SBTypeSummaryOptions *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummaryOptions,0))){ + SWIG_fail_ptr("SBTypeSummaryOptions_GetLanguage",1,SWIGTYPE_p_lldb__SBTypeSummaryOptions); + } + + result = (lldb::LanguageType)(arg1)->GetLanguage(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSummaryOptions_GetCapping(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSummaryOptions *arg1 = (lldb::SBTypeSummaryOptions *) 0 ; + lldb::TypeSummaryCapping result; + + SWIG_check_num_args("lldb::SBTypeSummaryOptions::GetCapping",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummaryOptions::GetCapping",1,"lldb::SBTypeSummaryOptions *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummaryOptions,0))){ + SWIG_fail_ptr("SBTypeSummaryOptions_GetCapping",1,SWIGTYPE_p_lldb__SBTypeSummaryOptions); + } + + result = (lldb::TypeSummaryCapping)(arg1)->GetCapping(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSummaryOptions_SetLanguage(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSummaryOptions *arg1 = (lldb::SBTypeSummaryOptions *) 0 ; + lldb::LanguageType arg2 ; + + SWIG_check_num_args("lldb::SBTypeSummaryOptions::SetLanguage",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummaryOptions::SetLanguage",1,"lldb::SBTypeSummaryOptions *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeSummaryOptions::SetLanguage",2,"lldb::LanguageType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummaryOptions,0))){ + SWIG_fail_ptr("SBTypeSummaryOptions_SetLanguage",1,SWIGTYPE_p_lldb__SBTypeSummaryOptions); + } + + arg2 = (lldb::LanguageType)lua_tointeger(L, 2); + (arg1)->SetLanguage(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSummaryOptions_SetCapping(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSummaryOptions *arg1 = (lldb::SBTypeSummaryOptions *) 0 ; + lldb::TypeSummaryCapping arg2 ; + + SWIG_check_num_args("lldb::SBTypeSummaryOptions::SetCapping",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummaryOptions::SetCapping",1,"lldb::SBTypeSummaryOptions *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeSummaryOptions::SetCapping",2,"lldb::TypeSummaryCapping"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummaryOptions,0))){ + SWIG_fail_ptr("SBTypeSummaryOptions_SetCapping",1,SWIGTYPE_p_lldb__SBTypeSummaryOptions); + } + + arg2 = (lldb::TypeSummaryCapping)lua_tointeger(L, 2); + (arg1)->SetCapping(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBTypeSummaryOptions(void *obj) { +lldb::SBTypeSummaryOptions *arg1 = (lldb::SBTypeSummaryOptions *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBTypeSummaryOptions(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBTypeSummaryOptions); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBTypeSummaryOptions_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBTypeSummaryOptions_methods[]= { + { "IsValid", _wrap_SBTypeSummaryOptions_IsValid}, + { "GetLanguage", _wrap_SBTypeSummaryOptions_GetLanguage}, + { "GetCapping", _wrap_SBTypeSummaryOptions_GetCapping}, + { "SetLanguage", _wrap_SBTypeSummaryOptions_SetLanguage}, + { "SetCapping", _wrap_SBTypeSummaryOptions_SetCapping}, + {0,0} +}; +static swig_lua_method swig_SBTypeSummaryOptions_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBTypeSummaryOptions_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBTypeSummaryOptions_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBTypeSummaryOptions_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBTypeSummaryOptions_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBTypeSummaryOptions_Sf_SwigStatic = { + "SBTypeSummaryOptions", + swig_SBTypeSummaryOptions_Sf_SwigStatic_methods, + swig_SBTypeSummaryOptions_Sf_SwigStatic_attributes, + swig_SBTypeSummaryOptions_Sf_SwigStatic_constants, + swig_SBTypeSummaryOptions_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBTypeSummaryOptions_bases[] = {0}; +static const char *swig_SBTypeSummaryOptions_base_names[] = {0}; +static swig_lua_class _wrap_class_SBTypeSummaryOptions = { "SBTypeSummaryOptions", "SBTypeSummaryOptions", &SWIGTYPE_p_lldb__SBTypeSummaryOptions,_proxy__wrap_new_SBTypeSummaryOptions, swig_delete_SBTypeSummaryOptions, swig_SBTypeSummaryOptions_methods, swig_SBTypeSummaryOptions_attributes, &swig_SBTypeSummaryOptions_Sf_SwigStatic, swig_SBTypeSummaryOptions_meta, swig_SBTypeSummaryOptions_bases, swig_SBTypeSummaryOptions_base_names }; + +static int _wrap_new_SBTypeSummary__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSummary *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeSummary::SBTypeSummary",0,0) + result = (lldb::SBTypeSummary *)new lldb::SBTypeSummary(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeSummary,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSummary_CreateWithSummaryString__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + uint32_t arg2 ; + lldb::SBTypeSummary result; + + SWIG_check_num_args("lldb::SBTypeSummary::CreateWithSummaryString",2,2) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::CreateWithSummaryString",1,"char const *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeSummary::CreateWithSummaryString",2,"uint32_t"); + arg1 = (char *)lua_tostring(L, 1); + arg2 = (uint32_t)lua_tointeger(L, 2); + result = lldb::SBTypeSummary::CreateWithSummaryString((char const *)arg1,arg2); + { + lldb::SBTypeSummary * resultptr = new lldb::SBTypeSummary(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSummary,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSummary_CreateWithSummaryString__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + lldb::SBTypeSummary result; + + SWIG_check_num_args("lldb::SBTypeSummary::CreateWithSummaryString",1,1) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::CreateWithSummaryString",1,"char const *"); + arg1 = (char *)lua_tostring(L, 1); + result = lldb::SBTypeSummary::CreateWithSummaryString((char const *)arg1); + { + lldb::SBTypeSummary * resultptr = new lldb::SBTypeSummary(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSummary,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSummary_CreateWithSummaryString(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + _v = SWIG_lua_isnilstring(L,argv[0]); + } + if (_v) { + return _wrap_SBTypeSummary_CreateWithSummaryString__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + _v = SWIG_lua_isnilstring(L,argv[0]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_SBTypeSummary_CreateWithSummaryString__SWIG_0(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBTypeSummary_CreateWithFunctionName__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + uint32_t arg2 ; + lldb::SBTypeSummary result; + + SWIG_check_num_args("lldb::SBTypeSummary::CreateWithFunctionName",2,2) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::CreateWithFunctionName",1,"char const *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeSummary::CreateWithFunctionName",2,"uint32_t"); + arg1 = (char *)lua_tostring(L, 1); + arg2 = (uint32_t)lua_tointeger(L, 2); + result = lldb::SBTypeSummary::CreateWithFunctionName((char const *)arg1,arg2); + { + lldb::SBTypeSummary * resultptr = new lldb::SBTypeSummary(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSummary,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSummary_CreateWithFunctionName__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + lldb::SBTypeSummary result; + + SWIG_check_num_args("lldb::SBTypeSummary::CreateWithFunctionName",1,1) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::CreateWithFunctionName",1,"char const *"); + arg1 = (char *)lua_tostring(L, 1); + result = lldb::SBTypeSummary::CreateWithFunctionName((char const *)arg1); + { + lldb::SBTypeSummary * resultptr = new lldb::SBTypeSummary(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSummary,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSummary_CreateWithFunctionName(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + _v = SWIG_lua_isnilstring(L,argv[0]); + } + if (_v) { + return _wrap_SBTypeSummary_CreateWithFunctionName__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + _v = SWIG_lua_isnilstring(L,argv[0]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_SBTypeSummary_CreateWithFunctionName__SWIG_0(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBTypeSummary_CreateWithScriptCode__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + uint32_t arg2 ; + lldb::SBTypeSummary result; + + SWIG_check_num_args("lldb::SBTypeSummary::CreateWithScriptCode",2,2) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::CreateWithScriptCode",1,"char const *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeSummary::CreateWithScriptCode",2,"uint32_t"); + arg1 = (char *)lua_tostring(L, 1); + arg2 = (uint32_t)lua_tointeger(L, 2); + result = lldb::SBTypeSummary::CreateWithScriptCode((char const *)arg1,arg2); + { + lldb::SBTypeSummary * resultptr = new lldb::SBTypeSummary(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSummary,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSummary_CreateWithScriptCode__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + lldb::SBTypeSummary result; + + SWIG_check_num_args("lldb::SBTypeSummary::CreateWithScriptCode",1,1) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::CreateWithScriptCode",1,"char const *"); + arg1 = (char *)lua_tostring(L, 1); + result = lldb::SBTypeSummary::CreateWithScriptCode((char const *)arg1); + { + lldb::SBTypeSummary * resultptr = new lldb::SBTypeSummary(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSummary,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSummary_CreateWithScriptCode(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + _v = SWIG_lua_isnilstring(L,argv[0]); + } + if (_v) { + return _wrap_SBTypeSummary_CreateWithScriptCode__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + _v = SWIG_lua_isnilstring(L,argv[0]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_SBTypeSummary_CreateWithScriptCode__SWIG_0(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_new_SBTypeSummary__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSummary *arg1 = 0 ; + lldb::SBTypeSummary *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeSummary::SBTypeSummary",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::SBTypeSummary",1,"lldb::SBTypeSummary const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummary,0))){ + SWIG_fail_ptr("new_SBTypeSummary",1,SWIGTYPE_p_lldb__SBTypeSummary); + } + + result = (lldb::SBTypeSummary *)new lldb::SBTypeSummary((lldb::SBTypeSummary const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeSummary,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBTypeSummary(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBTypeSummary__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTypeSummary, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBTypeSummary__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBTypeSummary'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBTypeSummary::SBTypeSummary()\n" + " lldb::SBTypeSummary::SBTypeSummary(lldb::SBTypeSummary const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBTypeSummary_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeSummary::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::IsValid",1,"lldb::SBTypeSummary const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummary,0))){ + SWIG_fail_ptr("SBTypeSummary_IsValid",1,SWIGTYPE_p_lldb__SBTypeSummary); + } + + result = (bool)((lldb::SBTypeSummary const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSummary_IsFunctionCode(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeSummary::IsFunctionCode",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::IsFunctionCode",1,"lldb::SBTypeSummary *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummary,0))){ + SWIG_fail_ptr("SBTypeSummary_IsFunctionCode",1,SWIGTYPE_p_lldb__SBTypeSummary); + } + + result = (bool)(arg1)->IsFunctionCode(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSummary_IsFunctionName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeSummary::IsFunctionName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::IsFunctionName",1,"lldb::SBTypeSummary *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummary,0))){ + SWIG_fail_ptr("SBTypeSummary_IsFunctionName",1,SWIGTYPE_p_lldb__SBTypeSummary); + } + + result = (bool)(arg1)->IsFunctionName(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSummary_IsSummaryString(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeSummary::IsSummaryString",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::IsSummaryString",1,"lldb::SBTypeSummary *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummary,0))){ + SWIG_fail_ptr("SBTypeSummary_IsSummaryString",1,SWIGTYPE_p_lldb__SBTypeSummary); + } + + result = (bool)(arg1)->IsSummaryString(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSummary_GetData(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeSummary::GetData",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::GetData",1,"lldb::SBTypeSummary *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummary,0))){ + SWIG_fail_ptr("SBTypeSummary_GetData",1,SWIGTYPE_p_lldb__SBTypeSummary); + } + + result = (char *)(arg1)->GetData(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSummary_SetSummaryString(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBTypeSummary::SetSummaryString",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::SetSummaryString",1,"lldb::SBTypeSummary *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTypeSummary::SetSummaryString",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummary,0))){ + SWIG_fail_ptr("SBTypeSummary_SetSummaryString",1,SWIGTYPE_p_lldb__SBTypeSummary); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetSummaryString((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSummary_SetFunctionName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBTypeSummary::SetFunctionName",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::SetFunctionName",1,"lldb::SBTypeSummary *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTypeSummary::SetFunctionName",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummary,0))){ + SWIG_fail_ptr("SBTypeSummary_SetFunctionName",1,SWIGTYPE_p_lldb__SBTypeSummary); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetFunctionName((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSummary_SetFunctionCode(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBTypeSummary::SetFunctionCode",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::SetFunctionCode",1,"lldb::SBTypeSummary *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTypeSummary::SetFunctionCode",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummary,0))){ + SWIG_fail_ptr("SBTypeSummary_SetFunctionCode",1,SWIGTYPE_p_lldb__SBTypeSummary); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetFunctionCode((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSummary_GetOptions(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBTypeSummary::GetOptions",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::GetOptions",1,"lldb::SBTypeSummary *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummary,0))){ + SWIG_fail_ptr("SBTypeSummary_GetOptions",1,SWIGTYPE_p_lldb__SBTypeSummary); + } + + result = (uint32_t)(arg1)->GetOptions(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSummary_SetOptions(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ; + uint32_t arg2 ; + + SWIG_check_num_args("lldb::SBTypeSummary::SetOptions",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::SetOptions",1,"lldb::SBTypeSummary *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeSummary::SetOptions",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummary,0))){ + SWIG_fail_ptr("SBTypeSummary_SetOptions",1,SWIGTYPE_p_lldb__SBTypeSummary); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + (arg1)->SetOptions(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSummary_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ; + lldb::SBStream *arg2 = 0 ; + lldb::DescriptionLevel arg3 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeSummary::GetDescription",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::GetDescription",1,"lldb::SBTypeSummary *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeSummary::GetDescription",2,"lldb::SBStream &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTypeSummary::GetDescription",3,"lldb::DescriptionLevel"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummary,0))){ + SWIG_fail_ptr("SBTypeSummary_GetDescription",1,SWIGTYPE_p_lldb__SBTypeSummary); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBTypeSummary_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + arg3 = (lldb::DescriptionLevel)lua_tointeger(L, 3); + result = (bool)(arg1)->GetDescription(*arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSummary_DoesPrintValue(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ; + lldb::SBValue arg2 ; + lldb::SBValue *argp2 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeSummary::DoesPrintValue",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::DoesPrintValue",1,"lldb::SBTypeSummary *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeSummary::DoesPrintValue",2,"lldb::SBValue"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummary,0))){ + SWIG_fail_ptr("SBTypeSummary_DoesPrintValue",1,SWIGTYPE_p_lldb__SBTypeSummary); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBTypeSummary_DoesPrintValue",2,SWIGTYPE_p_lldb__SBValue); + } + arg2 = *argp2; + + result = (bool)(arg1)->DoesPrintValue(arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSummary_IsEqualTo(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ; + lldb::SBTypeSummary *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeSummary::IsEqualTo",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::IsEqualTo",1,"lldb::SBTypeSummary *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeSummary::IsEqualTo",2,"lldb::SBTypeSummary &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummary,0))){ + SWIG_fail_ptr("SBTypeSummary_IsEqualTo",1,SWIGTYPE_p_lldb__SBTypeSummary); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTypeSummary,0))){ + SWIG_fail_ptr("SBTypeSummary_IsEqualTo",2,SWIGTYPE_p_lldb__SBTypeSummary); + } + + result = (bool)(arg1)->IsEqualTo(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSummary___eq(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ; + lldb::SBTypeSummary *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeSummary::operator ==",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::operator ==",1,"lldb::SBTypeSummary *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeSummary::operator ==",2,"lldb::SBTypeSummary &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummary,0))){ + SWIG_fail_ptr("SBTypeSummary___eq",1,SWIGTYPE_p_lldb__SBTypeSummary); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTypeSummary,0))){ + SWIG_fail_ptr("SBTypeSummary___eq",2,SWIGTYPE_p_lldb__SBTypeSummary); + } + + result = (bool)(arg1)->operator ==(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSummary___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBTypeSummary::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSummary::__repr__",1,"lldb::SBTypeSummary *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSummary,0))){ + SWIG_fail_ptr("SBTypeSummary___tostring",1,SWIGTYPE_p_lldb__SBTypeSummary); + } + + result = lldb_SBTypeSummary___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBTypeSummary(void *obj) { +lldb::SBTypeSummary *arg1 = (lldb::SBTypeSummary *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBTypeSummary(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBTypeSummary); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBTypeSummary_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBTypeSummary_methods[]= { + { "IsValid", _wrap_SBTypeSummary_IsValid}, + { "IsFunctionCode", _wrap_SBTypeSummary_IsFunctionCode}, + { "IsFunctionName", _wrap_SBTypeSummary_IsFunctionName}, + { "IsSummaryString", _wrap_SBTypeSummary_IsSummaryString}, + { "GetData", _wrap_SBTypeSummary_GetData}, + { "SetSummaryString", _wrap_SBTypeSummary_SetSummaryString}, + { "SetFunctionName", _wrap_SBTypeSummary_SetFunctionName}, + { "SetFunctionCode", _wrap_SBTypeSummary_SetFunctionCode}, + { "GetOptions", _wrap_SBTypeSummary_GetOptions}, + { "SetOptions", _wrap_SBTypeSummary_SetOptions}, + { "GetDescription", _wrap_SBTypeSummary_GetDescription}, + { "DoesPrintValue", _wrap_SBTypeSummary_DoesPrintValue}, + { "IsEqualTo", _wrap_SBTypeSummary_IsEqualTo}, + { "__eq", _wrap_SBTypeSummary___eq}, + { "__tostring", _wrap_SBTypeSummary___tostring}, + {0,0} +}; +static swig_lua_method swig_SBTypeSummary_meta[] = { + { "__eq", _wrap_SBTypeSummary___eq}, + { "__tostring", _wrap_SBTypeSummary___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBTypeSummary_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBTypeSummary_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBTypeSummary_Sf_SwigStatic_methods[]= { + { "CreateWithSummaryString", _wrap_SBTypeSummary_CreateWithSummaryString}, + { "CreateWithFunctionName", _wrap_SBTypeSummary_CreateWithFunctionName}, + { "CreateWithScriptCode", _wrap_SBTypeSummary_CreateWithScriptCode}, + {0,0} +}; +static swig_lua_class* swig_SBTypeSummary_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBTypeSummary_Sf_SwigStatic = { + "SBTypeSummary", + swig_SBTypeSummary_Sf_SwigStatic_methods, + swig_SBTypeSummary_Sf_SwigStatic_attributes, + swig_SBTypeSummary_Sf_SwigStatic_constants, + swig_SBTypeSummary_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBTypeSummary_bases[] = {0}; +static const char *swig_SBTypeSummary_base_names[] = {0}; +static swig_lua_class _wrap_class_SBTypeSummary = { "SBTypeSummary", "SBTypeSummary", &SWIGTYPE_p_lldb__SBTypeSummary,_proxy__wrap_new_SBTypeSummary, swig_delete_SBTypeSummary, swig_SBTypeSummary_methods, swig_SBTypeSummary_attributes, &swig_SBTypeSummary_Sf_SwigStatic, swig_SBTypeSummary_meta, swig_SBTypeSummary_bases, swig_SBTypeSummary_base_names }; + +static int _wrap_new_SBTypeSynthetic__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSynthetic *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeSynthetic::SBTypeSynthetic",0,0) + result = (lldb::SBTypeSynthetic *)new lldb::SBTypeSynthetic(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeSynthetic,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSynthetic_CreateWithClassName__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + uint32_t arg2 ; + lldb::SBTypeSynthetic result; + + SWIG_check_num_args("lldb::SBTypeSynthetic::CreateWithClassName",2,2) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBTypeSynthetic::CreateWithClassName",1,"char const *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeSynthetic::CreateWithClassName",2,"uint32_t"); + arg1 = (char *)lua_tostring(L, 1); + arg2 = (uint32_t)lua_tointeger(L, 2); + result = lldb::SBTypeSynthetic::CreateWithClassName((char const *)arg1,arg2); + { + lldb::SBTypeSynthetic * resultptr = new lldb::SBTypeSynthetic(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSynthetic,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSynthetic_CreateWithClassName__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + lldb::SBTypeSynthetic result; + + SWIG_check_num_args("lldb::SBTypeSynthetic::CreateWithClassName",1,1) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBTypeSynthetic::CreateWithClassName",1,"char const *"); + arg1 = (char *)lua_tostring(L, 1); + result = lldb::SBTypeSynthetic::CreateWithClassName((char const *)arg1); + { + lldb::SBTypeSynthetic * resultptr = new lldb::SBTypeSynthetic(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSynthetic,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSynthetic_CreateWithClassName(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + _v = SWIG_lua_isnilstring(L,argv[0]); + } + if (_v) { + return _wrap_SBTypeSynthetic_CreateWithClassName__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + _v = SWIG_lua_isnilstring(L,argv[0]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_SBTypeSynthetic_CreateWithClassName__SWIG_0(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBTypeSynthetic_CreateWithScriptCode__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + uint32_t arg2 ; + lldb::SBTypeSynthetic result; + + SWIG_check_num_args("lldb::SBTypeSynthetic::CreateWithScriptCode",2,2) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBTypeSynthetic::CreateWithScriptCode",1,"char const *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeSynthetic::CreateWithScriptCode",2,"uint32_t"); + arg1 = (char *)lua_tostring(L, 1); + arg2 = (uint32_t)lua_tointeger(L, 2); + result = lldb::SBTypeSynthetic::CreateWithScriptCode((char const *)arg1,arg2); + { + lldb::SBTypeSynthetic * resultptr = new lldb::SBTypeSynthetic(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSynthetic,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSynthetic_CreateWithScriptCode__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + char *arg1 = (char *) 0 ; + lldb::SBTypeSynthetic result; + + SWIG_check_num_args("lldb::SBTypeSynthetic::CreateWithScriptCode",1,1) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("lldb::SBTypeSynthetic::CreateWithScriptCode",1,"char const *"); + arg1 = (char *)lua_tostring(L, 1); + result = lldb::SBTypeSynthetic::CreateWithScriptCode((char const *)arg1); + { + lldb::SBTypeSynthetic * resultptr = new lldb::SBTypeSynthetic(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSynthetic,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSynthetic_CreateWithScriptCode(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + _v = SWIG_lua_isnilstring(L,argv[0]); + } + if (_v) { + return _wrap_SBTypeSynthetic_CreateWithScriptCode__SWIG_1(L); + } + } + if (argc == 2) { + int _v = 0; + { + _v = SWIG_lua_isnilstring(L,argv[0]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_SBTypeSynthetic_CreateWithScriptCode__SWIG_0(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_new_SBTypeSynthetic__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSynthetic *arg1 = 0 ; + lldb::SBTypeSynthetic *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeSynthetic::SBTypeSynthetic",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBTypeSynthetic::SBTypeSynthetic",1,"lldb::SBTypeSynthetic const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSynthetic,0))){ + SWIG_fail_ptr("new_SBTypeSynthetic",1,SWIGTYPE_p_lldb__SBTypeSynthetic); + } + + result = (lldb::SBTypeSynthetic *)new lldb::SBTypeSynthetic((lldb::SBTypeSynthetic const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBTypeSynthetic,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBTypeSynthetic(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBTypeSynthetic__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBTypeSynthetic, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBTypeSynthetic__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBTypeSynthetic'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBTypeSynthetic::SBTypeSynthetic()\n" + " lldb::SBTypeSynthetic::SBTypeSynthetic(lldb::SBTypeSynthetic const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBTypeSynthetic_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeSynthetic::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSynthetic::IsValid",1,"lldb::SBTypeSynthetic const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSynthetic,0))){ + SWIG_fail_ptr("SBTypeSynthetic_IsValid",1,SWIGTYPE_p_lldb__SBTypeSynthetic); + } + + result = (bool)((lldb::SBTypeSynthetic const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSynthetic_IsClassCode(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeSynthetic::IsClassCode",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSynthetic::IsClassCode",1,"lldb::SBTypeSynthetic *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSynthetic,0))){ + SWIG_fail_ptr("SBTypeSynthetic_IsClassCode",1,SWIGTYPE_p_lldb__SBTypeSynthetic); + } + + result = (bool)(arg1)->IsClassCode(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSynthetic_IsClassName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeSynthetic::IsClassName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSynthetic::IsClassName",1,"lldb::SBTypeSynthetic *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSynthetic,0))){ + SWIG_fail_ptr("SBTypeSynthetic_IsClassName",1,SWIGTYPE_p_lldb__SBTypeSynthetic); + } + + result = (bool)(arg1)->IsClassName(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSynthetic_GetData(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBTypeSynthetic::GetData",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSynthetic::GetData",1,"lldb::SBTypeSynthetic *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSynthetic,0))){ + SWIG_fail_ptr("SBTypeSynthetic_GetData",1,SWIGTYPE_p_lldb__SBTypeSynthetic); + } + + result = (char *)(arg1)->GetData(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSynthetic_SetClassName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBTypeSynthetic::SetClassName",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSynthetic::SetClassName",1,"lldb::SBTypeSynthetic *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTypeSynthetic::SetClassName",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSynthetic,0))){ + SWIG_fail_ptr("SBTypeSynthetic_SetClassName",1,SWIGTYPE_p_lldb__SBTypeSynthetic); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetClassName((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSynthetic_SetClassCode(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBTypeSynthetic::SetClassCode",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSynthetic::SetClassCode",1,"lldb::SBTypeSynthetic *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBTypeSynthetic::SetClassCode",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSynthetic,0))){ + SWIG_fail_ptr("SBTypeSynthetic_SetClassCode",1,SWIGTYPE_p_lldb__SBTypeSynthetic); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetClassCode((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSynthetic_GetOptions(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBTypeSynthetic::GetOptions",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSynthetic::GetOptions",1,"lldb::SBTypeSynthetic *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSynthetic,0))){ + SWIG_fail_ptr("SBTypeSynthetic_GetOptions",1,SWIGTYPE_p_lldb__SBTypeSynthetic); + } + + result = (uint32_t)(arg1)->GetOptions(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSynthetic_SetOptions(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ; + uint32_t arg2 ; + + SWIG_check_num_args("lldb::SBTypeSynthetic::SetOptions",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSynthetic::SetOptions",1,"lldb::SBTypeSynthetic *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBTypeSynthetic::SetOptions",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSynthetic,0))){ + SWIG_fail_ptr("SBTypeSynthetic_SetOptions",1,SWIGTYPE_p_lldb__SBTypeSynthetic); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + (arg1)->SetOptions(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSynthetic_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ; + lldb::SBStream *arg2 = 0 ; + lldb::DescriptionLevel arg3 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeSynthetic::GetDescription",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSynthetic::GetDescription",1,"lldb::SBTypeSynthetic *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeSynthetic::GetDescription",2,"lldb::SBStream &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBTypeSynthetic::GetDescription",3,"lldb::DescriptionLevel"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSynthetic,0))){ + SWIG_fail_ptr("SBTypeSynthetic_GetDescription",1,SWIGTYPE_p_lldb__SBTypeSynthetic); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBTypeSynthetic_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + arg3 = (lldb::DescriptionLevel)lua_tointeger(L, 3); + result = (bool)(arg1)->GetDescription(*arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSynthetic_IsEqualTo(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ; + lldb::SBTypeSynthetic *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeSynthetic::IsEqualTo",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSynthetic::IsEqualTo",1,"lldb::SBTypeSynthetic *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeSynthetic::IsEqualTo",2,"lldb::SBTypeSynthetic &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSynthetic,0))){ + SWIG_fail_ptr("SBTypeSynthetic_IsEqualTo",1,SWIGTYPE_p_lldb__SBTypeSynthetic); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTypeSynthetic,0))){ + SWIG_fail_ptr("SBTypeSynthetic_IsEqualTo",2,SWIGTYPE_p_lldb__SBTypeSynthetic); + } + + result = (bool)(arg1)->IsEqualTo(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSynthetic___eq(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ; + lldb::SBTypeSynthetic *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBTypeSynthetic::operator ==",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSynthetic::operator ==",1,"lldb::SBTypeSynthetic *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBTypeSynthetic::operator ==",2,"lldb::SBTypeSynthetic &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSynthetic,0))){ + SWIG_fail_ptr("SBTypeSynthetic___eq",1,SWIGTYPE_p_lldb__SBTypeSynthetic); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTypeSynthetic,0))){ + SWIG_fail_ptr("SBTypeSynthetic___eq",2,SWIGTYPE_p_lldb__SBTypeSynthetic); + } + + result = (bool)(arg1)->operator ==(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBTypeSynthetic___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBTypeSynthetic::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBTypeSynthetic::__repr__",1,"lldb::SBTypeSynthetic *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBTypeSynthetic,0))){ + SWIG_fail_ptr("SBTypeSynthetic___tostring",1,SWIGTYPE_p_lldb__SBTypeSynthetic); + } + + result = lldb_SBTypeSynthetic___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBTypeSynthetic(void *obj) { +lldb::SBTypeSynthetic *arg1 = (lldb::SBTypeSynthetic *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBTypeSynthetic(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBTypeSynthetic); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBTypeSynthetic_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBTypeSynthetic_methods[]= { + { "IsValid", _wrap_SBTypeSynthetic_IsValid}, + { "IsClassCode", _wrap_SBTypeSynthetic_IsClassCode}, + { "IsClassName", _wrap_SBTypeSynthetic_IsClassName}, + { "GetData", _wrap_SBTypeSynthetic_GetData}, + { "SetClassName", _wrap_SBTypeSynthetic_SetClassName}, + { "SetClassCode", _wrap_SBTypeSynthetic_SetClassCode}, + { "GetOptions", _wrap_SBTypeSynthetic_GetOptions}, + { "SetOptions", _wrap_SBTypeSynthetic_SetOptions}, + { "GetDescription", _wrap_SBTypeSynthetic_GetDescription}, + { "IsEqualTo", _wrap_SBTypeSynthetic_IsEqualTo}, + { "__eq", _wrap_SBTypeSynthetic___eq}, + { "__tostring", _wrap_SBTypeSynthetic___tostring}, + {0,0} +}; +static swig_lua_method swig_SBTypeSynthetic_meta[] = { + { "__eq", _wrap_SBTypeSynthetic___eq}, + { "__tostring", _wrap_SBTypeSynthetic___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBTypeSynthetic_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBTypeSynthetic_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBTypeSynthetic_Sf_SwigStatic_methods[]= { + { "CreateWithClassName", _wrap_SBTypeSynthetic_CreateWithClassName}, + { "CreateWithScriptCode", _wrap_SBTypeSynthetic_CreateWithScriptCode}, + {0,0} +}; +static swig_lua_class* swig_SBTypeSynthetic_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBTypeSynthetic_Sf_SwigStatic = { + "SBTypeSynthetic", + swig_SBTypeSynthetic_Sf_SwigStatic_methods, + swig_SBTypeSynthetic_Sf_SwigStatic_attributes, + swig_SBTypeSynthetic_Sf_SwigStatic_constants, + swig_SBTypeSynthetic_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBTypeSynthetic_bases[] = {0}; +static const char *swig_SBTypeSynthetic_base_names[] = {0}; +static swig_lua_class _wrap_class_SBTypeSynthetic = { "SBTypeSynthetic", "SBTypeSynthetic", &SWIGTYPE_p_lldb__SBTypeSynthetic,_proxy__wrap_new_SBTypeSynthetic, swig_delete_SBTypeSynthetic, swig_SBTypeSynthetic_methods, swig_SBTypeSynthetic_attributes, &swig_SBTypeSynthetic_Sf_SwigStatic, swig_SBTypeSynthetic_meta, swig_SBTypeSynthetic_bases, swig_SBTypeSynthetic_base_names }; + +static int _wrap_new_SBUnixSignals__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBUnixSignals *result = 0 ; + + SWIG_check_num_args("lldb::SBUnixSignals::SBUnixSignals",0,0) + result = (lldb::SBUnixSignals *)new lldb::SBUnixSignals(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBUnixSignals,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBUnixSignals__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBUnixSignals *arg1 = 0 ; + lldb::SBUnixSignals *result = 0 ; + + SWIG_check_num_args("lldb::SBUnixSignals::SBUnixSignals",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBUnixSignals::SBUnixSignals",1,"lldb::SBUnixSignals const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBUnixSignals,0))){ + SWIG_fail_ptr("new_SBUnixSignals",1,SWIGTYPE_p_lldb__SBUnixSignals); + } + + result = (lldb::SBUnixSignals *)new lldb::SBUnixSignals((lldb::SBUnixSignals const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBUnixSignals,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBUnixSignals(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBUnixSignals__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBUnixSignals, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBUnixSignals__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBUnixSignals'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBUnixSignals::SBUnixSignals()\n" + " lldb::SBUnixSignals::SBUnixSignals(lldb::SBUnixSignals const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBUnixSignals_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ; + + SWIG_check_num_args("lldb::SBUnixSignals::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBUnixSignals::Clear",1,"lldb::SBUnixSignals *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBUnixSignals,0))){ + SWIG_fail_ptr("SBUnixSignals_Clear",1,SWIGTYPE_p_lldb__SBUnixSignals); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBUnixSignals_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBUnixSignals::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBUnixSignals::IsValid",1,"lldb::SBUnixSignals const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBUnixSignals,0))){ + SWIG_fail_ptr("SBUnixSignals_IsValid",1,SWIGTYPE_p_lldb__SBUnixSignals); + } + + result = (bool)((lldb::SBUnixSignals const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBUnixSignals_GetSignalAsCString(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ; + int32_t arg2 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBUnixSignals::GetSignalAsCString",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBUnixSignals::GetSignalAsCString",1,"lldb::SBUnixSignals const *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBUnixSignals::GetSignalAsCString",2,"int32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBUnixSignals,0))){ + SWIG_fail_ptr("SBUnixSignals_GetSignalAsCString",1,SWIGTYPE_p_lldb__SBUnixSignals); + } + + arg2 = (int32_t)lua_tointeger(L, 2); + result = (char *)((lldb::SBUnixSignals const *)arg1)->GetSignalAsCString(arg2); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBUnixSignals_GetSignalNumberFromName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ; + char *arg2 = (char *) 0 ; + int32_t result; + + SWIG_check_num_args("lldb::SBUnixSignals::GetSignalNumberFromName",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBUnixSignals::GetSignalNumberFromName",1,"lldb::SBUnixSignals const *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBUnixSignals::GetSignalNumberFromName",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBUnixSignals,0))){ + SWIG_fail_ptr("SBUnixSignals_GetSignalNumberFromName",1,SWIGTYPE_p_lldb__SBUnixSignals); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (int32_t)((lldb::SBUnixSignals const *)arg1)->GetSignalNumberFromName((char const *)arg2); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBUnixSignals_GetShouldSuppress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ; + int32_t arg2 ; + bool result; + + SWIG_check_num_args("lldb::SBUnixSignals::GetShouldSuppress",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBUnixSignals::GetShouldSuppress",1,"lldb::SBUnixSignals const *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBUnixSignals::GetShouldSuppress",2,"int32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBUnixSignals,0))){ + SWIG_fail_ptr("SBUnixSignals_GetShouldSuppress",1,SWIGTYPE_p_lldb__SBUnixSignals); + } + + arg2 = (int32_t)lua_tointeger(L, 2); + result = (bool)((lldb::SBUnixSignals const *)arg1)->GetShouldSuppress(arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBUnixSignals_SetShouldSuppress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ; + int32_t arg2 ; + bool arg3 ; + bool result; + + SWIG_check_num_args("lldb::SBUnixSignals::SetShouldSuppress",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBUnixSignals::SetShouldSuppress",1,"lldb::SBUnixSignals *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBUnixSignals::SetShouldSuppress",2,"int32_t"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBUnixSignals::SetShouldSuppress",3,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBUnixSignals,0))){ + SWIG_fail_ptr("SBUnixSignals_SetShouldSuppress",1,SWIGTYPE_p_lldb__SBUnixSignals); + } + + arg2 = (int32_t)lua_tointeger(L, 2); + arg3 = (lua_toboolean(L, 3)!=0); + result = (bool)(arg1)->SetShouldSuppress(arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBUnixSignals_GetShouldStop(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ; + int32_t arg2 ; + bool result; + + SWIG_check_num_args("lldb::SBUnixSignals::GetShouldStop",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBUnixSignals::GetShouldStop",1,"lldb::SBUnixSignals const *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBUnixSignals::GetShouldStop",2,"int32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBUnixSignals,0))){ + SWIG_fail_ptr("SBUnixSignals_GetShouldStop",1,SWIGTYPE_p_lldb__SBUnixSignals); + } + + arg2 = (int32_t)lua_tointeger(L, 2); + result = (bool)((lldb::SBUnixSignals const *)arg1)->GetShouldStop(arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBUnixSignals_SetShouldStop(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ; + int32_t arg2 ; + bool arg3 ; + bool result; + + SWIG_check_num_args("lldb::SBUnixSignals::SetShouldStop",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBUnixSignals::SetShouldStop",1,"lldb::SBUnixSignals *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBUnixSignals::SetShouldStop",2,"int32_t"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBUnixSignals::SetShouldStop",3,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBUnixSignals,0))){ + SWIG_fail_ptr("SBUnixSignals_SetShouldStop",1,SWIGTYPE_p_lldb__SBUnixSignals); + } + + arg2 = (int32_t)lua_tointeger(L, 2); + arg3 = (lua_toboolean(L, 3)!=0); + result = (bool)(arg1)->SetShouldStop(arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBUnixSignals_GetShouldNotify(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ; + int32_t arg2 ; + bool result; + + SWIG_check_num_args("lldb::SBUnixSignals::GetShouldNotify",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBUnixSignals::GetShouldNotify",1,"lldb::SBUnixSignals const *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBUnixSignals::GetShouldNotify",2,"int32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBUnixSignals,0))){ + SWIG_fail_ptr("SBUnixSignals_GetShouldNotify",1,SWIGTYPE_p_lldb__SBUnixSignals); + } + + arg2 = (int32_t)lua_tointeger(L, 2); + result = (bool)((lldb::SBUnixSignals const *)arg1)->GetShouldNotify(arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBUnixSignals_SetShouldNotify(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ; + int32_t arg2 ; + bool arg3 ; + bool result; + + SWIG_check_num_args("lldb::SBUnixSignals::SetShouldNotify",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBUnixSignals::SetShouldNotify",1,"lldb::SBUnixSignals *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBUnixSignals::SetShouldNotify",2,"int32_t"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBUnixSignals::SetShouldNotify",3,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBUnixSignals,0))){ + SWIG_fail_ptr("SBUnixSignals_SetShouldNotify",1,SWIGTYPE_p_lldb__SBUnixSignals); + } + + arg2 = (int32_t)lua_tointeger(L, 2); + arg3 = (lua_toboolean(L, 3)!=0); + result = (bool)(arg1)->SetShouldNotify(arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBUnixSignals_GetNumSignals(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ; + int32_t result; + + SWIG_check_num_args("lldb::SBUnixSignals::GetNumSignals",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBUnixSignals::GetNumSignals",1,"lldb::SBUnixSignals const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBUnixSignals,0))){ + SWIG_fail_ptr("SBUnixSignals_GetNumSignals",1,SWIGTYPE_p_lldb__SBUnixSignals); + } + + result = (int32_t)((lldb::SBUnixSignals const *)arg1)->GetNumSignals(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBUnixSignals_GetSignalAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) 0 ; + int32_t arg2 ; + int32_t result; + + SWIG_check_num_args("lldb::SBUnixSignals::GetSignalAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBUnixSignals::GetSignalAtIndex",1,"lldb::SBUnixSignals const *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBUnixSignals::GetSignalAtIndex",2,"int32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBUnixSignals,0))){ + SWIG_fail_ptr("SBUnixSignals_GetSignalAtIndex",1,SWIGTYPE_p_lldb__SBUnixSignals); + } + + arg2 = (int32_t)lua_tointeger(L, 2); + result = (int32_t)((lldb::SBUnixSignals const *)arg1)->GetSignalAtIndex(arg2); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBUnixSignals(void *obj) { +lldb::SBUnixSignals *arg1 = (lldb::SBUnixSignals *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBUnixSignals(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBUnixSignals); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBUnixSignals_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBUnixSignals_methods[]= { + { "Clear", _wrap_SBUnixSignals_Clear}, + { "IsValid", _wrap_SBUnixSignals_IsValid}, + { "GetSignalAsCString", _wrap_SBUnixSignals_GetSignalAsCString}, + { "GetSignalNumberFromName", _wrap_SBUnixSignals_GetSignalNumberFromName}, + { "GetShouldSuppress", _wrap_SBUnixSignals_GetShouldSuppress}, + { "SetShouldSuppress", _wrap_SBUnixSignals_SetShouldSuppress}, + { "GetShouldStop", _wrap_SBUnixSignals_GetShouldStop}, + { "SetShouldStop", _wrap_SBUnixSignals_SetShouldStop}, + { "GetShouldNotify", _wrap_SBUnixSignals_GetShouldNotify}, + { "SetShouldNotify", _wrap_SBUnixSignals_SetShouldNotify}, + { "GetNumSignals", _wrap_SBUnixSignals_GetNumSignals}, + { "GetSignalAtIndex", _wrap_SBUnixSignals_GetSignalAtIndex}, + {0,0} +}; +static swig_lua_method swig_SBUnixSignals_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBUnixSignals_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBUnixSignals_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBUnixSignals_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBUnixSignals_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBUnixSignals_Sf_SwigStatic = { + "SBUnixSignals", + swig_SBUnixSignals_Sf_SwigStatic_methods, + swig_SBUnixSignals_Sf_SwigStatic_attributes, + swig_SBUnixSignals_Sf_SwigStatic_constants, + swig_SBUnixSignals_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBUnixSignals_bases[] = {0}; +static const char *swig_SBUnixSignals_base_names[] = {0}; +static swig_lua_class _wrap_class_SBUnixSignals = { "SBUnixSignals", "SBUnixSignals", &SWIGTYPE_p_lldb__SBUnixSignals,_proxy__wrap_new_SBUnixSignals, swig_delete_SBUnixSignals, swig_SBUnixSignals_methods, swig_SBUnixSignals_attributes, &swig_SBUnixSignals_Sf_SwigStatic, swig_SBUnixSignals_meta, swig_SBUnixSignals_bases, swig_SBUnixSignals_base_names }; + +static int _wrap_new_SBValue__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *result = 0 ; + + SWIG_check_num_args("lldb::SBValue::SBValue",0,0) + result = (lldb::SBValue *)new lldb::SBValue(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBValue__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = 0 ; + lldb::SBValue *result = 0 ; + + SWIG_check_num_args("lldb::SBValue::SBValue",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBValue::SBValue",1,"lldb::SBValue const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("new_SBValue",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (lldb::SBValue *)new lldb::SBValue((lldb::SBValue const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBValue(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBValue__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBValue__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBValue'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBValue::SBValue()\n" + " lldb::SBValue::SBValue(lldb::SBValue const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBValue_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBValue::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::IsValid",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_IsValid",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (bool)(arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + + SWIG_check_num_args("lldb::SBValue::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::Clear",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_Clear",1,SWIGTYPE_p_lldb__SBValue); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetError(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBValue::GetError",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetError",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetError",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (arg1)->GetError(); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::user_id_t result; + + SWIG_check_num_args("lldb::SBValue::GetID",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetID",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetID",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (lldb::user_id_t)(arg1)->GetID(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBValue::GetName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetName",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetName",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (char *)(arg1)->GetName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetTypeName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBValue::GetTypeName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetTypeName",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetTypeName",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (char *)(arg1)->GetTypeName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetDisplayTypeName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBValue::GetDisplayTypeName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetDisplayTypeName",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetDisplayTypeName",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (char *)(arg1)->GetDisplayTypeName(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetByteSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + size_t result; + + SWIG_check_num_args("lldb::SBValue::GetByteSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetByteSize",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetByteSize",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (arg1)->GetByteSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_IsInScope(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBValue::IsInScope",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::IsInScope",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_IsInScope",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (bool)(arg1)->IsInScope(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetFormat(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::Format result; + + SWIG_check_num_args("lldb::SBValue::GetFormat",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetFormat",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetFormat",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (lldb::Format)(arg1)->GetFormat(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_SetFormat(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::Format arg2 ; + + SWIG_check_num_args("lldb::SBValue::SetFormat",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::SetFormat",1,"lldb::SBValue *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBValue::SetFormat",2,"lldb::Format"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_SetFormat",1,SWIGTYPE_p_lldb__SBValue); + } + + arg2 = (lldb::Format)lua_tointeger(L, 2); + (arg1)->SetFormat(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetValue(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBValue::GetValue",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetValue",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetValue",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (char *)(arg1)->GetValue(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetValueAsSigned__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBError *arg2 = 0 ; + int64_t arg3 ; + int64_t result; + + SWIG_check_num_args("lldb::SBValue::GetValueAsSigned",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetValueAsSigned",1,"lldb::SBValue *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBValue::GetValueAsSigned",2,"lldb::SBError &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBValue::GetValueAsSigned",3,"int64_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetValueAsSigned",1,SWIGTYPE_p_lldb__SBValue); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBValue_GetValueAsSigned",2,SWIGTYPE_p_lldb__SBError); + } + + arg3 = (int64_t)lua_tointeger(L, 3); + result = (int64_t)(arg1)->GetValueAsSigned(*arg2,arg3); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetValueAsSigned__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBError *arg2 = 0 ; + int64_t result; + + SWIG_check_num_args("lldb::SBValue::GetValueAsSigned",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetValueAsSigned",1,"lldb::SBValue *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBValue::GetValueAsSigned",2,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetValueAsSigned",1,SWIGTYPE_p_lldb__SBValue); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBValue_GetValueAsSigned",2,SWIGTYPE_p_lldb__SBError); + } + + result = (int64_t)(arg1)->GetValueAsSigned(*arg2); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetValueAsUnsigned__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBError *arg2 = 0 ; + uint64_t arg3 ; + uint64_t result; + + SWIG_check_num_args("lldb::SBValue::GetValueAsUnsigned",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetValueAsUnsigned",1,"lldb::SBValue *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBValue::GetValueAsUnsigned",2,"lldb::SBError &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBValue::GetValueAsUnsigned",3,"uint64_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetValueAsUnsigned",1,SWIGTYPE_p_lldb__SBValue); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBValue_GetValueAsUnsigned",2,SWIGTYPE_p_lldb__SBError); + } + + arg3 = (uint64_t)lua_tointeger(L, 3); + result = (uint64_t)(arg1)->GetValueAsUnsigned(*arg2,arg3); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetValueAsUnsigned__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBError *arg2 = 0 ; + uint64_t result; + + SWIG_check_num_args("lldb::SBValue::GetValueAsUnsigned",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetValueAsUnsigned",1,"lldb::SBValue *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBValue::GetValueAsUnsigned",2,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetValueAsUnsigned",1,SWIGTYPE_p_lldb__SBValue); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBValue_GetValueAsUnsigned",2,SWIGTYPE_p_lldb__SBError); + } + + result = (uint64_t)(arg1)->GetValueAsUnsigned(*arg2); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetValueAsSigned__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + int64_t arg2 ; + int64_t result; + + SWIG_check_num_args("lldb::SBValue::GetValueAsSigned",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetValueAsSigned",1,"lldb::SBValue *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBValue::GetValueAsSigned",2,"int64_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetValueAsSigned",1,SWIGTYPE_p_lldb__SBValue); + } + + arg2 = (int64_t)lua_tointeger(L, 2); + result = (int64_t)(arg1)->GetValueAsSigned(arg2); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetValueAsSigned__SWIG_3(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + int64_t result; + + SWIG_check_num_args("lldb::SBValue::GetValueAsSigned",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetValueAsSigned",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetValueAsSigned",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (int64_t)(arg1)->GetValueAsSigned(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetValueAsSigned(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBValue_GetValueAsSigned__SWIG_3(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBValue_GetValueAsSigned__SWIG_1(L); + } + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_SBValue_GetValueAsSigned__SWIG_2(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + return _wrap_SBValue_GetValueAsSigned__SWIG_0(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBValue_GetValueAsUnsigned__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + uint64_t arg2 ; + uint64_t result; + + SWIG_check_num_args("lldb::SBValue::GetValueAsUnsigned",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetValueAsUnsigned",1,"lldb::SBValue *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBValue::GetValueAsUnsigned",2,"uint64_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetValueAsUnsigned",1,SWIGTYPE_p_lldb__SBValue); + } + + arg2 = (uint64_t)lua_tointeger(L, 2); + result = (uint64_t)(arg1)->GetValueAsUnsigned(arg2); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetValueAsUnsigned__SWIG_3(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + uint64_t result; + + SWIG_check_num_args("lldb::SBValue::GetValueAsUnsigned",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetValueAsUnsigned",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetValueAsUnsigned",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (uint64_t)(arg1)->GetValueAsUnsigned(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetValueAsUnsigned(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBValue_GetValueAsUnsigned__SWIG_3(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBValue_GetValueAsUnsigned__SWIG_1(L); + } + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_SBValue_GetValueAsUnsigned__SWIG_2(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + return _wrap_SBValue_GetValueAsUnsigned__SWIG_0(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBValue_GetValueAsAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::addr_t result; + + SWIG_check_num_args("lldb::SBValue::GetValueAsAddress",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetValueAsAddress",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetValueAsAddress",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (lldb::addr_t)(arg1)->GetValueAsAddress(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetValueType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::ValueType result; + + SWIG_check_num_args("lldb::SBValue::GetValueType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetValueType",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetValueType",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (lldb::ValueType)(arg1)->GetValueType(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetValueDidChange(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBValue::GetValueDidChange",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetValueDidChange",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetValueDidChange",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (bool)(arg1)->GetValueDidChange(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetSummary__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBValue::GetSummary",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetSummary",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetSummary",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (char *)(arg1)->GetSummary(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetSummary__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBStream *arg2 = 0 ; + lldb::SBTypeSummaryOptions *arg3 = 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBValue::GetSummary",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetSummary",1,"lldb::SBValue *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBValue::GetSummary",2,"lldb::SBStream &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBValue::GetSummary",3,"lldb::SBTypeSummaryOptions &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetSummary",1,SWIGTYPE_p_lldb__SBValue); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBValue_GetSummary",2,SWIGTYPE_p_lldb__SBStream); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBTypeSummaryOptions,0))){ + SWIG_fail_ptr("SBValue_GetSummary",3,SWIGTYPE_p_lldb__SBTypeSummaryOptions); + } + + result = (char *)(arg1)->GetSummary(*arg2,*arg3); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetSummary(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBValue_GetSummary__SWIG_0(L); + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBTypeSummaryOptions, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBValue_GetSummary__SWIG_1(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBValue_GetObjectDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBValue::GetObjectDescription",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetObjectDescription",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetObjectDescription",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (char *)(arg1)->GetObjectDescription(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetDynamicValue(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::DynamicValueType arg2 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBValue::GetDynamicValue",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetDynamicValue",1,"lldb::SBValue *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBValue::GetDynamicValue",2,"lldb::DynamicValueType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetDynamicValue",1,SWIGTYPE_p_lldb__SBValue); + } + + arg2 = (lldb::DynamicValueType)lua_tointeger(L, 2); + result = (arg1)->GetDynamicValue(arg2); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetStaticValue(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBValue::GetStaticValue",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetStaticValue",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetStaticValue",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (arg1)->GetStaticValue(); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetNonSyntheticValue(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBValue::GetNonSyntheticValue",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetNonSyntheticValue",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetNonSyntheticValue",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (arg1)->GetNonSyntheticValue(); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetSyntheticValue(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBValue::GetSyntheticValue",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetSyntheticValue",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetSyntheticValue",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (arg1)->GetSyntheticValue(); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetPreferDynamicValue(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::DynamicValueType result; + + SWIG_check_num_args("lldb::SBValue::GetPreferDynamicValue",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetPreferDynamicValue",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetPreferDynamicValue",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (lldb::DynamicValueType)(arg1)->GetPreferDynamicValue(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_SetPreferDynamicValue(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::DynamicValueType arg2 ; + + SWIG_check_num_args("lldb::SBValue::SetPreferDynamicValue",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::SetPreferDynamicValue",1,"lldb::SBValue *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBValue::SetPreferDynamicValue",2,"lldb::DynamicValueType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_SetPreferDynamicValue",1,SWIGTYPE_p_lldb__SBValue); + } + + arg2 = (lldb::DynamicValueType)lua_tointeger(L, 2); + (arg1)->SetPreferDynamicValue(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetPreferSyntheticValue(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBValue::GetPreferSyntheticValue",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetPreferSyntheticValue",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetPreferSyntheticValue",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (bool)(arg1)->GetPreferSyntheticValue(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_SetPreferSyntheticValue(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBValue::SetPreferSyntheticValue",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::SetPreferSyntheticValue",1,"lldb::SBValue *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBValue::SetPreferSyntheticValue",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_SetPreferSyntheticValue",1,SWIGTYPE_p_lldb__SBValue); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetPreferSyntheticValue(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_IsDynamic(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBValue::IsDynamic",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::IsDynamic",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_IsDynamic",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (bool)(arg1)->IsDynamic(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_IsSynthetic(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBValue::IsSynthetic",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::IsSynthetic",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_IsSynthetic",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (bool)(arg1)->IsSynthetic(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_IsSyntheticChildrenGenerated(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBValue::IsSyntheticChildrenGenerated",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::IsSyntheticChildrenGenerated",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_IsSyntheticChildrenGenerated",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (bool)(arg1)->IsSyntheticChildrenGenerated(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_SetSyntheticChildrenGenerated(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBValue::SetSyntheticChildrenGenerated",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::SetSyntheticChildrenGenerated",1,"lldb::SBValue *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBValue::SetSyntheticChildrenGenerated",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_SetSyntheticChildrenGenerated",1,SWIGTYPE_p_lldb__SBValue); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetSyntheticChildrenGenerated(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetLocation(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBValue::GetLocation",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetLocation",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetLocation",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (char *)(arg1)->GetLocation(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_SetValueFromCString__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + char *arg2 = (char *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBValue::SetValueFromCString",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::SetValueFromCString",1,"lldb::SBValue *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBValue::SetValueFromCString",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_SetValueFromCString",1,SWIGTYPE_p_lldb__SBValue); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (bool)(arg1)->SetValueFromCString((char const *)arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_SetValueFromCString__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBError *arg3 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBValue::SetValueFromCString",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::SetValueFromCString",1,"lldb::SBValue *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBValue::SetValueFromCString",2,"char const *"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBValue::SetValueFromCString",3,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_SetValueFromCString",1,SWIGTYPE_p_lldb__SBValue); + } + + arg2 = (char *)lua_tostring(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBValue_SetValueFromCString",3,SWIGTYPE_p_lldb__SBError); + } + + result = (bool)(arg1)->SetValueFromCString((char const *)arg2,*arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_SetValueFromCString(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + return _wrap_SBValue_SetValueFromCString__SWIG_0(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBValue_SetValueFromCString__SWIG_1(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBValue_GetTypeFormat(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBTypeFormat result; + + SWIG_check_num_args("lldb::SBValue::GetTypeFormat",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetTypeFormat",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetTypeFormat",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (arg1)->GetTypeFormat(); + { + lldb::SBTypeFormat * resultptr = new lldb::SBTypeFormat(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeFormat,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetTypeSummary(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBTypeSummary result; + + SWIG_check_num_args("lldb::SBValue::GetTypeSummary",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetTypeSummary",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetTypeSummary",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (arg1)->GetTypeSummary(); + { + lldb::SBTypeSummary * resultptr = new lldb::SBTypeSummary(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSummary,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetTypeFilter(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBTypeFilter result; + + SWIG_check_num_args("lldb::SBValue::GetTypeFilter",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetTypeFilter",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetTypeFilter",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (arg1)->GetTypeFilter(); + { + lldb::SBTypeFilter * resultptr = new lldb::SBTypeFilter(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeFilter,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetTypeSynthetic(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBTypeSynthetic result; + + SWIG_check_num_args("lldb::SBValue::GetTypeSynthetic",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetTypeSynthetic",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetTypeSynthetic",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (arg1)->GetTypeSynthetic(); + { + lldb::SBTypeSynthetic * resultptr = new lldb::SBTypeSynthetic(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTypeSynthetic,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetChildAtIndex__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + uint32_t arg2 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBValue::GetChildAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetChildAtIndex",1,"lldb::SBValue *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBValue::GetChildAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetChildAtIndex",1,SWIGTYPE_p_lldb__SBValue); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetChildAtIndex(arg2); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_CreateChildAtOffset(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + char *arg2 = (char *) 0 ; + uint32_t arg3 ; + lldb::SBType arg4 ; + lldb::SBType *argp4 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBValue::CreateChildAtOffset",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::CreateChildAtOffset",1,"lldb::SBValue *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBValue::CreateChildAtOffset",2,"char const *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBValue::CreateChildAtOffset",3,"uint32_t"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBValue::CreateChildAtOffset",4,"lldb::SBType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_CreateChildAtOffset",1,SWIGTYPE_p_lldb__SBValue); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (uint32_t)lua_tointeger(L, 3); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBValue_CreateChildAtOffset",4,SWIGTYPE_p_lldb__SBType); + } + arg4 = *argp4; + + result = (arg1)->CreateChildAtOffset((char const *)arg2,arg3,arg4); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_Cast(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBType arg2 ; + lldb::SBType *argp2 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBValue::Cast",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::Cast",1,"lldb::SBValue *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBValue::Cast",2,"lldb::SBType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_Cast",1,SWIGTYPE_p_lldb__SBValue); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBValue_Cast",2,SWIGTYPE_p_lldb__SBType); + } + arg2 = *argp2; + + result = (arg1)->Cast(arg2); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_CreateValueFromExpression__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBValue::CreateValueFromExpression",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::CreateValueFromExpression",1,"lldb::SBValue *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBValue::CreateValueFromExpression",2,"char const *"); + if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBValue::CreateValueFromExpression",3,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_CreateValueFromExpression",1,SWIGTYPE_p_lldb__SBValue); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (char *)lua_tostring(L, 3); + result = (arg1)->CreateValueFromExpression((char const *)arg2,(char const *)arg3); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_CreateValueFromExpression__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + lldb::SBExpressionOptions *arg4 = 0 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBValue::CreateValueFromExpression",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::CreateValueFromExpression",1,"lldb::SBValue *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBValue::CreateValueFromExpression",2,"char const *"); + if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("lldb::SBValue::CreateValueFromExpression",3,"char const *"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBValue::CreateValueFromExpression",4,"lldb::SBExpressionOptions &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_CreateValueFromExpression",1,SWIGTYPE_p_lldb__SBValue); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (char *)lua_tostring(L, 3); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBValue_CreateValueFromExpression",4,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + result = (arg1)->CreateValueFromExpression((char const *)arg2,(char const *)arg3,*arg4); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_CreateValueFromExpression(lua_State* L) { + int argc; + int argv[5]={ + 1,2,3,4,5 + }; + + argc = lua_gettop(L); + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[2]); + } + if (_v) { + return _wrap_SBValue_CreateValueFromExpression__SWIG_0(L); + } + } + } + } + if (argc == 4) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[2]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBValue_CreateValueFromExpression__SWIG_1(L); + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBValue_CreateValueFromAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + char *arg2 = (char *) 0 ; + lldb::addr_t arg3 ; + lldb::SBType arg4 ; + lldb::SBType *argp4 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBValue::CreateValueFromAddress",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::CreateValueFromAddress",1,"lldb::SBValue *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBValue::CreateValueFromAddress",2,"char const *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBValue::CreateValueFromAddress",3,"lldb::addr_t"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBValue::CreateValueFromAddress",4,"lldb::SBType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_CreateValueFromAddress",1,SWIGTYPE_p_lldb__SBValue); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (lldb::addr_t)lua_tointeger(L, 3); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBValue_CreateValueFromAddress",4,SWIGTYPE_p_lldb__SBType); + } + arg4 = *argp4; + + result = (arg1)->CreateValueFromAddress((char const *)arg2,arg3,arg4); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_CreateValueFromData(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBData arg3 ; + lldb::SBType arg4 ; + lldb::SBData *argp3 ; + lldb::SBType *argp4 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBValue::CreateValueFromData",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::CreateValueFromData",1,"lldb::SBValue *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBValue::CreateValueFromData",2,"char const *"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBValue::CreateValueFromData",3,"lldb::SBData"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("lldb::SBValue::CreateValueFromData",4,"lldb::SBType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_CreateValueFromData",1,SWIGTYPE_p_lldb__SBValue); + } + + arg2 = (char *)lua_tostring(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBValue_CreateValueFromData",3,SWIGTYPE_p_lldb__SBData); + } + arg3 = *argp3; + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_lldb__SBType,0))){ + SWIG_fail_ptr("SBValue_CreateValueFromData",4,SWIGTYPE_p_lldb__SBType); + } + arg4 = *argp4; + + result = (arg1)->CreateValueFromData((char const *)arg2,arg3,arg4); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetChildAtIndex__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + uint32_t arg2 ; + lldb::DynamicValueType arg3 ; + bool arg4 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBValue::GetChildAtIndex",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetChildAtIndex",1,"lldb::SBValue *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBValue::GetChildAtIndex",2,"uint32_t"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBValue::GetChildAtIndex",3,"lldb::DynamicValueType"); + if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBValue::GetChildAtIndex",4,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetChildAtIndex",1,SWIGTYPE_p_lldb__SBValue); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + arg3 = (lldb::DynamicValueType)lua_tointeger(L, 3); + arg4 = (lua_toboolean(L, 4)!=0); + result = (arg1)->GetChildAtIndex(arg2,arg3,arg4); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetChildAtIndex(lua_State* L) { + int argc; + int argv[5]={ + 1,2,3,4,5 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_SBValue_GetChildAtIndex__SWIG_0(L); + } + } + } + if (argc == 4) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[3]); + } + if (_v) { + return _wrap_SBValue_GetChildAtIndex__SWIG_1(L); + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBValue_GetIndexOfChildWithName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + char *arg2 = (char *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBValue::GetIndexOfChildWithName",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetIndexOfChildWithName",1,"lldb::SBValue *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBValue::GetIndexOfChildWithName",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetIndexOfChildWithName",1,SWIGTYPE_p_lldb__SBValue); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (uint32_t)(arg1)->GetIndexOfChildWithName((char const *)arg2); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetChildMemberWithName__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBValue::GetChildMemberWithName",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetChildMemberWithName",1,"lldb::SBValue *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBValue::GetChildMemberWithName",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetChildMemberWithName",1,SWIGTYPE_p_lldb__SBValue); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->GetChildMemberWithName((char const *)arg2); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetChildMemberWithName__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + char *arg2 = (char *) 0 ; + lldb::DynamicValueType arg3 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBValue::GetChildMemberWithName",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetChildMemberWithName",1,"lldb::SBValue *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBValue::GetChildMemberWithName",2,"char const *"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBValue::GetChildMemberWithName",3,"lldb::DynamicValueType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetChildMemberWithName",1,SWIGTYPE_p_lldb__SBValue); + } + + arg2 = (char *)lua_tostring(L, 2); + arg3 = (lldb::DynamicValueType)lua_tointeger(L, 3); + result = (arg1)->GetChildMemberWithName((char const *)arg2,arg3); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetChildMemberWithName(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + return _wrap_SBValue_GetChildMemberWithName__SWIG_0(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + return _wrap_SBValue_GetChildMemberWithName__SWIG_1(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBValue_GetValueForExpressionPath(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBValue::GetValueForExpressionPath",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetValueForExpressionPath",1,"lldb::SBValue *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBValue::GetValueForExpressionPath",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetValueForExpressionPath",1,SWIGTYPE_p_lldb__SBValue); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->GetValueForExpressionPath((char const *)arg2); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_AddressOf(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBValue::AddressOf",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::AddressOf",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_AddressOf",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (arg1)->AddressOf(); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetLoadAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::addr_t result; + + SWIG_check_num_args("lldb::SBValue::GetLoadAddress",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetLoadAddress",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetLoadAddress",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (lldb::addr_t)(arg1)->GetLoadAddress(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBAddress result; + + SWIG_check_num_args("lldb::SBValue::GetAddress",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetAddress",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetAddress",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (arg1)->GetAddress(); + { + lldb::SBAddress * resultptr = new lldb::SBAddress(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBAddress,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetPointeeData__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + uint32_t arg2 ; + uint32_t arg3 ; + lldb::SBData result; + + SWIG_check_num_args("lldb::SBValue::GetPointeeData",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetPointeeData",1,"lldb::SBValue *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBValue::GetPointeeData",2,"uint32_t"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBValue::GetPointeeData",3,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetPointeeData",1,SWIGTYPE_p_lldb__SBValue); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + arg3 = (uint32_t)lua_tointeger(L, 3); + result = (arg1)->GetPointeeData(arg2,arg3); + { + lldb::SBData * resultptr = new lldb::SBData(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBData,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetPointeeData__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + uint32_t arg2 ; + lldb::SBData result; + + SWIG_check_num_args("lldb::SBValue::GetPointeeData",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetPointeeData",1,"lldb::SBValue *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBValue::GetPointeeData",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetPointeeData",1,SWIGTYPE_p_lldb__SBValue); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (arg1)->GetPointeeData(arg2); + { + lldb::SBData * resultptr = new lldb::SBData(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBData,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetPointeeData__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBData result; + + SWIG_check_num_args("lldb::SBValue::GetPointeeData",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetPointeeData",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetPointeeData",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (arg1)->GetPointeeData(); + { + lldb::SBData * resultptr = new lldb::SBData(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBData,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetPointeeData(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBValue_GetPointeeData__SWIG_2(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_SBValue_GetPointeeData__SWIG_1(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + { + _v = lua_isnumber(L,argv[2]); + } + if (_v) { + return _wrap_SBValue_GetPointeeData__SWIG_0(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBValue_GetData(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBData result; + + SWIG_check_num_args("lldb::SBValue::GetData",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetData",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetData",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (arg1)->GetData(); + { + lldb::SBData * resultptr = new lldb::SBData(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBData,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_SetData(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBData *arg2 = 0 ; + lldb::SBError *arg3 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBValue::SetData",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::SetData",1,"lldb::SBValue *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBValue::SetData",2,"lldb::SBData &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBValue::SetData",3,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_SetData",1,SWIGTYPE_p_lldb__SBValue); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBData,0))){ + SWIG_fail_ptr("SBValue_SetData",2,SWIGTYPE_p_lldb__SBData); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBValue_SetData",3,SWIGTYPE_p_lldb__SBError); + } + + result = (bool)(arg1)->SetData(*arg2,*arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_Clone(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBValue::Clone",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::Clone",1,"lldb::SBValue *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBValue::Clone",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_Clone",1,SWIGTYPE_p_lldb__SBValue); + } + + arg2 = (char *)lua_tostring(L, 2); + result = (arg1)->Clone((char const *)arg2); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetDeclaration(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBDeclaration result; + + SWIG_check_num_args("lldb::SBValue::GetDeclaration",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetDeclaration",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetDeclaration",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (arg1)->GetDeclaration(); + { + lldb::SBDeclaration * resultptr = new lldb::SBDeclaration(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBDeclaration,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_MightHaveChildren(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBValue::MightHaveChildren",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::MightHaveChildren",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_MightHaveChildren",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (bool)(arg1)->MightHaveChildren(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_IsRuntimeSupportValue(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBValue::IsRuntimeSupportValue",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::IsRuntimeSupportValue",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_IsRuntimeSupportValue",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (bool)(arg1)->IsRuntimeSupportValue(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetNumChildren__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBValue::GetNumChildren",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetNumChildren",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetNumChildren",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (uint32_t)(arg1)->GetNumChildren(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetNumChildren__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + uint32_t arg2 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBValue::GetNumChildren",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetNumChildren",1,"lldb::SBValue *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBValue::GetNumChildren",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetNumChildren",1,SWIGTYPE_p_lldb__SBValue); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = (uint32_t)(arg1)->GetNumChildren(arg2); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetNumChildren(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBValue_GetNumChildren__SWIG_0(L); + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isnumber(L,argv[1]); + } + if (_v) { + return _wrap_SBValue_GetNumChildren__SWIG_1(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SBValue_GetNumChildren'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBValue::GetNumChildren()\n" + " lldb::SBValue::GetNumChildren(uint32_t)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBValue_GetOpaqueType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + void *result = 0 ; + + SWIG_check_num_args("lldb::SBValue::GetOpaqueType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetOpaqueType",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetOpaqueType",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (void *)(arg1)->GetOpaqueType(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_void,0); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetTarget(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBTarget result; + + SWIG_check_num_args("lldb::SBValue::GetTarget",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetTarget",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetTarget",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (arg1)->GetTarget(); + { + lldb::SBTarget * resultptr = new lldb::SBTarget(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBTarget,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetProcess(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBProcess result; + + SWIG_check_num_args("lldb::SBValue::GetProcess",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetProcess",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetProcess",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (arg1)->GetProcess(); + { + lldb::SBProcess * resultptr = new lldb::SBProcess(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBProcess,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetThread(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBThread result; + + SWIG_check_num_args("lldb::SBValue::GetThread",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetThread",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetThread",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (arg1)->GetThread(); + { + lldb::SBThread * resultptr = new lldb::SBThread(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBThread,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetFrame(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBFrame result; + + SWIG_check_num_args("lldb::SBValue::GetFrame",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetFrame",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetFrame",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (arg1)->GetFrame(); + { + lldb::SBFrame * resultptr = new lldb::SBFrame(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBFrame,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_Dereference(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBValue::Dereference",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::Dereference",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_Dereference",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (arg1)->Dereference(); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_TypeIsPointerType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBValue::TypeIsPointerType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::TypeIsPointerType",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_TypeIsPointerType",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (bool)(arg1)->TypeIsPointerType(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBType result; + + SWIG_check_num_args("lldb::SBValue::GetType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetType",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetType",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (arg1)->GetType(); + { + lldb::SBType * resultptr = new lldb::SBType(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_Persist(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBValue::Persist",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::Persist",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_Persist",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (arg1)->Persist(); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBValue::GetDescription",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetDescription",1,"lldb::SBValue *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBValue::GetDescription",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetDescription",1,SWIGTYPE_p_lldb__SBValue); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBValue_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)(arg1)->GetDescription(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetExpressionPath__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBValue::GetExpressionPath",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetExpressionPath",1,"lldb::SBValue *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBValue::GetExpressionPath",2,"lldb::SBStream &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetExpressionPath",1,SWIGTYPE_p_lldb__SBValue); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBValue_GetExpressionPath",2,SWIGTYPE_p_lldb__SBStream); + } + + result = (bool)(arg1)->GetExpressionPath(*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetExpressionPath__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBStream *arg2 = 0 ; + bool arg3 ; + bool result; + + SWIG_check_num_args("lldb::SBValue::GetExpressionPath",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetExpressionPath",1,"lldb::SBValue *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBValue::GetExpressionPath",2,"lldb::SBStream &"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBValue::GetExpressionPath",3,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetExpressionPath",1,SWIGTYPE_p_lldb__SBValue); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBValue_GetExpressionPath",2,SWIGTYPE_p_lldb__SBStream); + } + + arg3 = (lua_toboolean(L, 3)!=0); + result = (bool)(arg1)->GetExpressionPath(*arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetExpressionPath(lua_State* L) { + int argc; + int argv[4]={ + 1,2,3,4 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBValue_GetExpressionPath__SWIG_0(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBStream, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[2]); + } + if (_v) { + return _wrap_SBValue_GetExpressionPath__SWIG_1(L); + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBValue_EvaluateExpression__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBValue::EvaluateExpression",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::EvaluateExpression",1,"lldb::SBValue const *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBValue::EvaluateExpression",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_EvaluateExpression",1,SWIGTYPE_p_lldb__SBValue); + } + + arg2 = (char *)lua_tostring(L, 2); + result = ((lldb::SBValue const *)arg1)->EvaluateExpression((char const *)arg2); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_EvaluateExpression__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBExpressionOptions *arg3 = 0 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBValue::EvaluateExpression",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::EvaluateExpression",1,"lldb::SBValue const *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBValue::EvaluateExpression",2,"char const *"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBValue::EvaluateExpression",3,"lldb::SBExpressionOptions const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_EvaluateExpression",1,SWIGTYPE_p_lldb__SBValue); + } + + arg2 = (char *)lua_tostring(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBValue_EvaluateExpression",3,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + result = ((lldb::SBValue const *)arg1)->EvaluateExpression((char const *)arg2,(lldb::SBExpressionOptions const &)*arg3); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_EvaluateExpression__SWIG_2(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBExpressionOptions *arg3 = 0 ; + char *arg4 = (char *) 0 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBValue::EvaluateExpression",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::EvaluateExpression",1,"lldb::SBValue const *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBValue::EvaluateExpression",2,"char const *"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("lldb::SBValue::EvaluateExpression",3,"lldb::SBExpressionOptions const &"); + if(!SWIG_lua_isnilstring(L,4)) SWIG_fail_arg("lldb::SBValue::EvaluateExpression",4,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_EvaluateExpression",1,SWIGTYPE_p_lldb__SBValue); + } + + arg2 = (char *)lua_tostring(L, 2); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_lldb__SBExpressionOptions,0))){ + SWIG_fail_ptr("SBValue_EvaluateExpression",3,SWIGTYPE_p_lldb__SBExpressionOptions); + } + + arg4 = (char *)lua_tostring(L, 4); + result = ((lldb::SBValue const *)arg1)->EvaluateExpression((char const *)arg2,(lldb::SBExpressionOptions const &)*arg3,(char const *)arg4); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_EvaluateExpression(lua_State* L) { + int argc; + int argv[5]={ + 1,2,3,4,5 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + return _wrap_SBValue_EvaluateExpression__SWIG_0(L); + } + } + } + if (argc == 3) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBValue_EvaluateExpression__SWIG_1(L); + } + } + } + } + if (argc == 4) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[1]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_lldb__SBExpressionOptions, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = SWIG_lua_isnilstring(L,argv[3]); + } + if (_v) { + return _wrap_SBValue_EvaluateExpression__SWIG_2(L); + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBValue_Watch__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + bool arg2 ; + bool arg3 ; + bool arg4 ; + lldb::SBError *arg5 = 0 ; + lldb::SBWatchpoint result; + + SWIG_check_num_args("lldb::SBValue::Watch",5,5) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::Watch",1,"lldb::SBValue *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBValue::Watch",2,"bool"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBValue::Watch",3,"bool"); + if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBValue::Watch",4,"bool"); + if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBValue::Watch",5,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_Watch",1,SWIGTYPE_p_lldb__SBValue); + } + + arg2 = (lua_toboolean(L, 2)!=0); + arg3 = (lua_toboolean(L, 3)!=0); + arg4 = (lua_toboolean(L, 4)!=0); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBValue_Watch",5,SWIGTYPE_p_lldb__SBError); + } + + result = (arg1)->Watch(arg2,arg3,arg4,*arg5); + { + lldb::SBWatchpoint * resultptr = new lldb::SBWatchpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBWatchpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_Watch__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + bool arg2 ; + bool arg3 ; + bool arg4 ; + lldb::SBWatchpoint result; + + SWIG_check_num_args("lldb::SBValue::Watch",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::Watch",1,"lldb::SBValue *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBValue::Watch",2,"bool"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBValue::Watch",3,"bool"); + if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBValue::Watch",4,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_Watch",1,SWIGTYPE_p_lldb__SBValue); + } + + arg2 = (lua_toboolean(L, 2)!=0); + arg3 = (lua_toboolean(L, 3)!=0); + arg4 = (lua_toboolean(L, 4)!=0); + result = (arg1)->Watch(arg2,arg3,arg4); + { + lldb::SBWatchpoint * resultptr = new lldb::SBWatchpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBWatchpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_Watch(lua_State* L) { + int argc; + int argv[6]={ + 1,2,3,4,5,6 + }; + + argc = lua_gettop(L); + if (argc == 4) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[1]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[2]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[3]); + } + if (_v) { + return _wrap_SBValue_Watch__SWIG_1(L); + } + } + } + } + } + if (argc == 5) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + _v = lua_isboolean(L,argv[1]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[2]); + } + if (_v) { + { + _v = lua_isboolean(L,argv[3]); + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_lldb__SBError, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBValue_Watch__SWIG_0(L); + } + } + } + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBValue_WatchPointee(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + bool arg2 ; + bool arg3 ; + bool arg4 ; + lldb::SBError *arg5 = 0 ; + lldb::SBWatchpoint result; + + SWIG_check_num_args("lldb::SBValue::WatchPointee",5,5) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::WatchPointee",1,"lldb::SBValue *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBValue::WatchPointee",2,"bool"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("lldb::SBValue::WatchPointee",3,"bool"); + if(!lua_isboolean(L,4)) SWIG_fail_arg("lldb::SBValue::WatchPointee",4,"bool"); + if(!lua_isuserdata(L,5)) SWIG_fail_arg("lldb::SBValue::WatchPointee",5,"lldb::SBError &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_WatchPointee",1,SWIGTYPE_p_lldb__SBValue); + } + + arg2 = (lua_toboolean(L, 2)!=0); + arg3 = (lua_toboolean(L, 3)!=0); + arg4 = (lua_toboolean(L, 4)!=0); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_lldb__SBError,0))){ + SWIG_fail_ptr("SBValue_WatchPointee",5,SWIGTYPE_p_lldb__SBError); + } + + result = (arg1)->WatchPointee(arg2,arg3,arg4,*arg5); + { + lldb::SBWatchpoint * resultptr = new lldb::SBWatchpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBWatchpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue_GetVTable(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBValue::GetVTable",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::GetVTable",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue_GetVTable",1,SWIGTYPE_p_lldb__SBValue); + } + + result = (arg1)->GetVTable(); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValue___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValue *arg1 = (lldb::SBValue *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBValue::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValue::__repr__",1,"lldb::SBValue *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValue___tostring",1,SWIGTYPE_p_lldb__SBValue); + } + + result = lldb_SBValue___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBValue(void *obj) { +lldb::SBValue *arg1 = (lldb::SBValue *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBValue(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBValue); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBValue_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBValue_methods[]= { + { "IsValid", _wrap_SBValue_IsValid}, + { "Clear", _wrap_SBValue_Clear}, + { "GetError", _wrap_SBValue_GetError}, + { "GetID", _wrap_SBValue_GetID}, + { "GetName", _wrap_SBValue_GetName}, + { "GetTypeName", _wrap_SBValue_GetTypeName}, + { "GetDisplayTypeName", _wrap_SBValue_GetDisplayTypeName}, + { "GetByteSize", _wrap_SBValue_GetByteSize}, + { "IsInScope", _wrap_SBValue_IsInScope}, + { "GetFormat", _wrap_SBValue_GetFormat}, + { "SetFormat", _wrap_SBValue_SetFormat}, + { "GetValue", _wrap_SBValue_GetValue}, + { "GetValueAsSigned", _wrap_SBValue_GetValueAsSigned}, + { "GetValueAsUnsigned", _wrap_SBValue_GetValueAsUnsigned}, + { "GetValueAsAddress", _wrap_SBValue_GetValueAsAddress}, + { "GetValueType", _wrap_SBValue_GetValueType}, + { "GetValueDidChange", _wrap_SBValue_GetValueDidChange}, + { "GetSummary", _wrap_SBValue_GetSummary}, + { "GetObjectDescription", _wrap_SBValue_GetObjectDescription}, + { "GetDynamicValue", _wrap_SBValue_GetDynamicValue}, + { "GetStaticValue", _wrap_SBValue_GetStaticValue}, + { "GetNonSyntheticValue", _wrap_SBValue_GetNonSyntheticValue}, + { "GetSyntheticValue", _wrap_SBValue_GetSyntheticValue}, + { "GetPreferDynamicValue", _wrap_SBValue_GetPreferDynamicValue}, + { "SetPreferDynamicValue", _wrap_SBValue_SetPreferDynamicValue}, + { "GetPreferSyntheticValue", _wrap_SBValue_GetPreferSyntheticValue}, + { "SetPreferSyntheticValue", _wrap_SBValue_SetPreferSyntheticValue}, + { "IsDynamic", _wrap_SBValue_IsDynamic}, + { "IsSynthetic", _wrap_SBValue_IsSynthetic}, + { "IsSyntheticChildrenGenerated", _wrap_SBValue_IsSyntheticChildrenGenerated}, + { "SetSyntheticChildrenGenerated", _wrap_SBValue_SetSyntheticChildrenGenerated}, + { "GetLocation", _wrap_SBValue_GetLocation}, + { "SetValueFromCString", _wrap_SBValue_SetValueFromCString}, + { "GetTypeFormat", _wrap_SBValue_GetTypeFormat}, + { "GetTypeSummary", _wrap_SBValue_GetTypeSummary}, + { "GetTypeFilter", _wrap_SBValue_GetTypeFilter}, + { "GetTypeSynthetic", _wrap_SBValue_GetTypeSynthetic}, + { "CreateChildAtOffset", _wrap_SBValue_CreateChildAtOffset}, + { "Cast", _wrap_SBValue_Cast}, + { "CreateValueFromExpression", _wrap_SBValue_CreateValueFromExpression}, + { "CreateValueFromAddress", _wrap_SBValue_CreateValueFromAddress}, + { "CreateValueFromData", _wrap_SBValue_CreateValueFromData}, + { "GetChildAtIndex", _wrap_SBValue_GetChildAtIndex}, + { "GetIndexOfChildWithName", _wrap_SBValue_GetIndexOfChildWithName}, + { "GetChildMemberWithName", _wrap_SBValue_GetChildMemberWithName}, + { "GetValueForExpressionPath", _wrap_SBValue_GetValueForExpressionPath}, + { "AddressOf", _wrap_SBValue_AddressOf}, + { "GetLoadAddress", _wrap_SBValue_GetLoadAddress}, + { "GetAddress", _wrap_SBValue_GetAddress}, + { "GetPointeeData", _wrap_SBValue_GetPointeeData}, + { "GetData", _wrap_SBValue_GetData}, + { "SetData", _wrap_SBValue_SetData}, + { "Clone", _wrap_SBValue_Clone}, + { "GetDeclaration", _wrap_SBValue_GetDeclaration}, + { "MightHaveChildren", _wrap_SBValue_MightHaveChildren}, + { "IsRuntimeSupportValue", _wrap_SBValue_IsRuntimeSupportValue}, + { "GetNumChildren", _wrap_SBValue_GetNumChildren}, + { "GetOpaqueType", _wrap_SBValue_GetOpaqueType}, + { "GetTarget", _wrap_SBValue_GetTarget}, + { "GetProcess", _wrap_SBValue_GetProcess}, + { "GetThread", _wrap_SBValue_GetThread}, + { "GetFrame", _wrap_SBValue_GetFrame}, + { "Dereference", _wrap_SBValue_Dereference}, + { "TypeIsPointerType", _wrap_SBValue_TypeIsPointerType}, + { "GetType", _wrap_SBValue_GetType}, + { "Persist", _wrap_SBValue_Persist}, + { "GetDescription", _wrap_SBValue_GetDescription}, + { "GetExpressionPath", _wrap_SBValue_GetExpressionPath}, + { "EvaluateExpression", _wrap_SBValue_EvaluateExpression}, + { "Watch", _wrap_SBValue_Watch}, + { "WatchPointee", _wrap_SBValue_WatchPointee}, + { "GetVTable", _wrap_SBValue_GetVTable}, + { "__tostring", _wrap_SBValue___tostring}, + {0,0} +}; +static swig_lua_method swig_SBValue_meta[] = { + { "__tostring", _wrap_SBValue___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBValue_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBValue_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBValue_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBValue_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBValue_Sf_SwigStatic = { + "SBValue", + swig_SBValue_Sf_SwigStatic_methods, + swig_SBValue_Sf_SwigStatic_attributes, + swig_SBValue_Sf_SwigStatic_constants, + swig_SBValue_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBValue_bases[] = {0}; +static const char *swig_SBValue_base_names[] = {0}; +static swig_lua_class _wrap_class_SBValue = { "SBValue", "SBValue", &SWIGTYPE_p_lldb__SBValue,_proxy__wrap_new_SBValue, swig_delete_SBValue, swig_SBValue_methods, swig_SBValue_attributes, &swig_SBValue_Sf_SwigStatic, swig_SBValue_meta, swig_SBValue_bases, swig_SBValue_base_names }; + +static int _wrap_new_SBValueList__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValueList *result = 0 ; + + SWIG_check_num_args("lldb::SBValueList::SBValueList",0,0) + result = (lldb::SBValueList *)new lldb::SBValueList(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBValueList,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBValueList__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValueList *arg1 = 0 ; + lldb::SBValueList *result = 0 ; + + SWIG_check_num_args("lldb::SBValueList::SBValueList",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBValueList::SBValueList",1,"lldb::SBValueList const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValueList,0))){ + SWIG_fail_ptr("new_SBValueList",1,SWIGTYPE_p_lldb__SBValueList); + } + + result = (lldb::SBValueList *)new lldb::SBValueList((lldb::SBValueList const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBValueList,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBValueList(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBValueList__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValueList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBValueList__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBValueList'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBValueList::SBValueList()\n" + " lldb::SBValueList::SBValueList(lldb::SBValueList const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBValueList_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValueList *arg1 = (lldb::SBValueList *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBValueList::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValueList::IsValid",1,"lldb::SBValueList const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValueList,0))){ + SWIG_fail_ptr("SBValueList_IsValid",1,SWIGTYPE_p_lldb__SBValueList); + } + + result = (bool)((lldb::SBValueList const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValueList_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValueList *arg1 = (lldb::SBValueList *) 0 ; + + SWIG_check_num_args("lldb::SBValueList::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValueList::Clear",1,"lldb::SBValueList *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValueList,0))){ + SWIG_fail_ptr("SBValueList_Clear",1,SWIGTYPE_p_lldb__SBValueList); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValueList_Append__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValueList *arg1 = (lldb::SBValueList *) 0 ; + lldb::SBValue *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBValueList::Append",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValueList::Append",1,"lldb::SBValueList *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBValueList::Append",2,"lldb::SBValue const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValueList,0))){ + SWIG_fail_ptr("SBValueList_Append",1,SWIGTYPE_p_lldb__SBValueList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBValue,0))){ + SWIG_fail_ptr("SBValueList_Append",2,SWIGTYPE_p_lldb__SBValue); + } + + (arg1)->Append((lldb::SBValue const &)*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValueList_Append__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValueList *arg1 = (lldb::SBValueList *) 0 ; + lldb::SBValueList *arg2 = 0 ; + + SWIG_check_num_args("lldb::SBValueList::Append",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValueList::Append",1,"lldb::SBValueList *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBValueList::Append",2,"lldb::SBValueList const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValueList,0))){ + SWIG_fail_ptr("SBValueList_Append",1,SWIGTYPE_p_lldb__SBValueList); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBValueList,0))){ + SWIG_fail_ptr("SBValueList_Append",2,SWIGTYPE_p_lldb__SBValueList); + } + + (arg1)->Append((lldb::SBValueList const &)*arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValueList_Append(lua_State* L) { + int argc; + int argv[3]={ + 1,2,3 + }; + + argc = lua_gettop(L); + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValueList, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBValue, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBValueList_Append__SWIG_0(L); + } + } + } + if (argc == 2) { + int _v = 0; + { + void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBValueList, 0)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + { + void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_lldb__SBValueList, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_SBValueList_Append__SWIG_1(L); + } + } + } + + SWIG_Lua_pusherrstring(L,"Wrong 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"); + lua_error(L);return 0; +} + + +static int _wrap_SBValueList_GetSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValueList *arg1 = (lldb::SBValueList *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBValueList::GetSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValueList::GetSize",1,"lldb::SBValueList const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValueList,0))){ + SWIG_fail_ptr("SBValueList_GetSize",1,SWIGTYPE_p_lldb__SBValueList); + } + + result = (uint32_t)((lldb::SBValueList const *)arg1)->GetSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValueList_GetValueAtIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValueList *arg1 = (lldb::SBValueList *) 0 ; + uint32_t arg2 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBValueList::GetValueAtIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValueList::GetValueAtIndex",1,"lldb::SBValueList const *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBValueList::GetValueAtIndex",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValueList,0))){ + SWIG_fail_ptr("SBValueList_GetValueAtIndex",1,SWIGTYPE_p_lldb__SBValueList); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + result = ((lldb::SBValueList const *)arg1)->GetValueAtIndex(arg2); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValueList_GetFirstValueByName(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValueList *arg1 = (lldb::SBValueList *) 0 ; + char *arg2 = (char *) 0 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBValueList::GetFirstValueByName",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValueList::GetFirstValueByName",1,"lldb::SBValueList const *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBValueList::GetFirstValueByName",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValueList,0))){ + SWIG_fail_ptr("SBValueList_GetFirstValueByName",1,SWIGTYPE_p_lldb__SBValueList); + } + + arg2 = (char *)lua_tostring(L, 2); + result = ((lldb::SBValueList const *)arg1)->GetFirstValueByName((char const *)arg2); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValueList_FindValueObjectByUID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValueList *arg1 = (lldb::SBValueList *) 0 ; + lldb::user_id_t arg2 ; + lldb::SBValue result; + + SWIG_check_num_args("lldb::SBValueList::FindValueObjectByUID",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValueList::FindValueObjectByUID",1,"lldb::SBValueList *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBValueList::FindValueObjectByUID",2,"lldb::user_id_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValueList,0))){ + SWIG_fail_ptr("SBValueList_FindValueObjectByUID",1,SWIGTYPE_p_lldb__SBValueList); + } + + arg2 = (lldb::user_id_t)lua_tointeger(L, 2); + result = (arg1)->FindValueObjectByUID(arg2); + { + lldb::SBValue * resultptr = new lldb::SBValue(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBValue,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValueList_GetError(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValueList *arg1 = (lldb::SBValueList *) 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBValueList::GetError",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValueList::GetError",1,"lldb::SBValueList *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValueList,0))){ + SWIG_fail_ptr("SBValueList_GetError",1,SWIGTYPE_p_lldb__SBValueList); + } + + result = (arg1)->GetError(); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBValueList___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBValueList *arg1 = (lldb::SBValueList *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBValueList::__str__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBValueList::__str__",1,"lldb::SBValueList *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBValueList,0))){ + SWIG_fail_ptr("SBValueList___tostring",1,SWIGTYPE_p_lldb__SBValueList); + } + + result = lldb_SBValueList___str__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBValueList(void *obj) { +lldb::SBValueList *arg1 = (lldb::SBValueList *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBValueList(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBValueList); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBValueList_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBValueList_methods[]= { + { "IsValid", _wrap_SBValueList_IsValid}, + { "Clear", _wrap_SBValueList_Clear}, + { "Append", _wrap_SBValueList_Append}, + { "GetSize", _wrap_SBValueList_GetSize}, + { "GetValueAtIndex", _wrap_SBValueList_GetValueAtIndex}, + { "GetFirstValueByName", _wrap_SBValueList_GetFirstValueByName}, + { "FindValueObjectByUID", _wrap_SBValueList_FindValueObjectByUID}, + { "GetError", _wrap_SBValueList_GetError}, + { "__tostring", _wrap_SBValueList___tostring}, + {0,0} +}; +static swig_lua_method swig_SBValueList_meta[] = { + { "__tostring", _wrap_SBValueList___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBValueList_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBValueList_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBValueList_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBValueList_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBValueList_Sf_SwigStatic = { + "SBValueList", + swig_SBValueList_Sf_SwigStatic_methods, + swig_SBValueList_Sf_SwigStatic_attributes, + swig_SBValueList_Sf_SwigStatic_constants, + swig_SBValueList_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBValueList_bases[] = {0}; +static const char *swig_SBValueList_base_names[] = {0}; +static swig_lua_class _wrap_class_SBValueList = { "SBValueList", "SBValueList", &SWIGTYPE_p_lldb__SBValueList,_proxy__wrap_new_SBValueList, swig_delete_SBValueList, swig_SBValueList_methods, swig_SBValueList_attributes, &swig_SBValueList_Sf_SwigStatic, swig_SBValueList_meta, swig_SBValueList_bases, swig_SBValueList_base_names }; + +static int _wrap_new_SBVariablesOptions__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBVariablesOptions *result = 0 ; + + SWIG_check_num_args("lldb::SBVariablesOptions::SBVariablesOptions",0,0) + result = (lldb::SBVariablesOptions *)new lldb::SBVariablesOptions(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBVariablesOptions,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBVariablesOptions__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBVariablesOptions *arg1 = 0 ; + lldb::SBVariablesOptions *result = 0 ; + + SWIG_check_num_args("lldb::SBVariablesOptions::SBVariablesOptions",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBVariablesOptions::SBVariablesOptions",1,"lldb::SBVariablesOptions const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBVariablesOptions,0))){ + SWIG_fail_ptr("new_SBVariablesOptions",1,SWIGTYPE_p_lldb__SBVariablesOptions); + } + + result = (lldb::SBVariablesOptions *)new lldb::SBVariablesOptions((lldb::SBVariablesOptions const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBVariablesOptions,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBVariablesOptions(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBVariablesOptions__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBVariablesOptions, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBVariablesOptions__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBVariablesOptions'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBVariablesOptions::SBVariablesOptions()\n" + " lldb::SBVariablesOptions::SBVariablesOptions(lldb::SBVariablesOptions const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBVariablesOptions_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBVariablesOptions::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBVariablesOptions::IsValid",1,"lldb::SBVariablesOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBVariablesOptions,0))){ + SWIG_fail_ptr("SBVariablesOptions_IsValid",1,SWIGTYPE_p_lldb__SBVariablesOptions); + } + + result = (bool)((lldb::SBVariablesOptions const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBVariablesOptions_GetIncludeArguments(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBVariablesOptions::GetIncludeArguments",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBVariablesOptions::GetIncludeArguments",1,"lldb::SBVariablesOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBVariablesOptions,0))){ + SWIG_fail_ptr("SBVariablesOptions_GetIncludeArguments",1,SWIGTYPE_p_lldb__SBVariablesOptions); + } + + result = (bool)((lldb::SBVariablesOptions const *)arg1)->GetIncludeArguments(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBVariablesOptions_SetIncludeArguments(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBVariablesOptions::SetIncludeArguments",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBVariablesOptions::SetIncludeArguments",1,"lldb::SBVariablesOptions *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBVariablesOptions::SetIncludeArguments",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBVariablesOptions,0))){ + SWIG_fail_ptr("SBVariablesOptions_SetIncludeArguments",1,SWIGTYPE_p_lldb__SBVariablesOptions); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetIncludeArguments(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBVariablesOptions_GetIncludeRecognizedArguments(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ; + lldb::SBTarget *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBVariablesOptions::GetIncludeRecognizedArguments",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBVariablesOptions::GetIncludeRecognizedArguments",1,"lldb::SBVariablesOptions const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBVariablesOptions::GetIncludeRecognizedArguments",2,"lldb::SBTarget const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBVariablesOptions,0))){ + SWIG_fail_ptr("SBVariablesOptions_GetIncludeRecognizedArguments",1,SWIGTYPE_p_lldb__SBVariablesOptions); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBTarget,0))){ + SWIG_fail_ptr("SBVariablesOptions_GetIncludeRecognizedArguments",2,SWIGTYPE_p_lldb__SBTarget); + } + + result = (bool)((lldb::SBVariablesOptions const *)arg1)->GetIncludeRecognizedArguments((lldb::SBTarget const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBVariablesOptions_SetIncludeRecognizedArguments(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBVariablesOptions::SetIncludeRecognizedArguments",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBVariablesOptions::SetIncludeRecognizedArguments",1,"lldb::SBVariablesOptions *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBVariablesOptions::SetIncludeRecognizedArguments",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBVariablesOptions,0))){ + SWIG_fail_ptr("SBVariablesOptions_SetIncludeRecognizedArguments",1,SWIGTYPE_p_lldb__SBVariablesOptions); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetIncludeRecognizedArguments(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBVariablesOptions_GetIncludeLocals(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBVariablesOptions::GetIncludeLocals",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBVariablesOptions::GetIncludeLocals",1,"lldb::SBVariablesOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBVariablesOptions,0))){ + SWIG_fail_ptr("SBVariablesOptions_GetIncludeLocals",1,SWIGTYPE_p_lldb__SBVariablesOptions); + } + + result = (bool)((lldb::SBVariablesOptions const *)arg1)->GetIncludeLocals(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBVariablesOptions_SetIncludeLocals(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBVariablesOptions::SetIncludeLocals",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBVariablesOptions::SetIncludeLocals",1,"lldb::SBVariablesOptions *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBVariablesOptions::SetIncludeLocals",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBVariablesOptions,0))){ + SWIG_fail_ptr("SBVariablesOptions_SetIncludeLocals",1,SWIGTYPE_p_lldb__SBVariablesOptions); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetIncludeLocals(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBVariablesOptions_GetIncludeStatics(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBVariablesOptions::GetIncludeStatics",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBVariablesOptions::GetIncludeStatics",1,"lldb::SBVariablesOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBVariablesOptions,0))){ + SWIG_fail_ptr("SBVariablesOptions_GetIncludeStatics",1,SWIGTYPE_p_lldb__SBVariablesOptions); + } + + result = (bool)((lldb::SBVariablesOptions const *)arg1)->GetIncludeStatics(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBVariablesOptions_SetIncludeStatics(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBVariablesOptions::SetIncludeStatics",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBVariablesOptions::SetIncludeStatics",1,"lldb::SBVariablesOptions *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBVariablesOptions::SetIncludeStatics",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBVariablesOptions,0))){ + SWIG_fail_ptr("SBVariablesOptions_SetIncludeStatics",1,SWIGTYPE_p_lldb__SBVariablesOptions); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetIncludeStatics(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBVariablesOptions_GetInScopeOnly(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBVariablesOptions::GetInScopeOnly",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBVariablesOptions::GetInScopeOnly",1,"lldb::SBVariablesOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBVariablesOptions,0))){ + SWIG_fail_ptr("SBVariablesOptions_GetInScopeOnly",1,SWIGTYPE_p_lldb__SBVariablesOptions); + } + + result = (bool)((lldb::SBVariablesOptions const *)arg1)->GetInScopeOnly(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBVariablesOptions_SetInScopeOnly(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBVariablesOptions::SetInScopeOnly",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBVariablesOptions::SetInScopeOnly",1,"lldb::SBVariablesOptions *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBVariablesOptions::SetInScopeOnly",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBVariablesOptions,0))){ + SWIG_fail_ptr("SBVariablesOptions_SetInScopeOnly",1,SWIGTYPE_p_lldb__SBVariablesOptions); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetInScopeOnly(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBVariablesOptions_GetIncludeRuntimeSupportValues(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBVariablesOptions::GetIncludeRuntimeSupportValues",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBVariablesOptions::GetIncludeRuntimeSupportValues",1,"lldb::SBVariablesOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBVariablesOptions,0))){ + SWIG_fail_ptr("SBVariablesOptions_GetIncludeRuntimeSupportValues",1,SWIGTYPE_p_lldb__SBVariablesOptions); + } + + result = (bool)((lldb::SBVariablesOptions const *)arg1)->GetIncludeRuntimeSupportValues(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBVariablesOptions_SetIncludeRuntimeSupportValues(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBVariablesOptions::SetIncludeRuntimeSupportValues",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBVariablesOptions::SetIncludeRuntimeSupportValues",1,"lldb::SBVariablesOptions *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBVariablesOptions::SetIncludeRuntimeSupportValues",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBVariablesOptions,0))){ + SWIG_fail_ptr("SBVariablesOptions_SetIncludeRuntimeSupportValues",1,SWIGTYPE_p_lldb__SBVariablesOptions); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetIncludeRuntimeSupportValues(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBVariablesOptions_GetUseDynamic(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ; + lldb::DynamicValueType result; + + SWIG_check_num_args("lldb::SBVariablesOptions::GetUseDynamic",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBVariablesOptions::GetUseDynamic",1,"lldb::SBVariablesOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBVariablesOptions,0))){ + SWIG_fail_ptr("SBVariablesOptions_GetUseDynamic",1,SWIGTYPE_p_lldb__SBVariablesOptions); + } + + result = (lldb::DynamicValueType)((lldb::SBVariablesOptions const *)arg1)->GetUseDynamic(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBVariablesOptions_SetUseDynamic(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) 0 ; + lldb::DynamicValueType arg2 ; + + SWIG_check_num_args("lldb::SBVariablesOptions::SetUseDynamic",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBVariablesOptions::SetUseDynamic",1,"lldb::SBVariablesOptions *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBVariablesOptions::SetUseDynamic",2,"lldb::DynamicValueType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBVariablesOptions,0))){ + SWIG_fail_ptr("SBVariablesOptions_SetUseDynamic",1,SWIGTYPE_p_lldb__SBVariablesOptions); + } + + arg2 = (lldb::DynamicValueType)lua_tointeger(L, 2); + (arg1)->SetUseDynamic(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBVariablesOptions(void *obj) { +lldb::SBVariablesOptions *arg1 = (lldb::SBVariablesOptions *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBVariablesOptions(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBVariablesOptions); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBVariablesOptions_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBVariablesOptions_methods[]= { + { "IsValid", _wrap_SBVariablesOptions_IsValid}, + { "GetIncludeArguments", _wrap_SBVariablesOptions_GetIncludeArguments}, + { "SetIncludeArguments", _wrap_SBVariablesOptions_SetIncludeArguments}, + { "GetIncludeRecognizedArguments", _wrap_SBVariablesOptions_GetIncludeRecognizedArguments}, + { "SetIncludeRecognizedArguments", _wrap_SBVariablesOptions_SetIncludeRecognizedArguments}, + { "GetIncludeLocals", _wrap_SBVariablesOptions_GetIncludeLocals}, + { "SetIncludeLocals", _wrap_SBVariablesOptions_SetIncludeLocals}, + { "GetIncludeStatics", _wrap_SBVariablesOptions_GetIncludeStatics}, + { "SetIncludeStatics", _wrap_SBVariablesOptions_SetIncludeStatics}, + { "GetInScopeOnly", _wrap_SBVariablesOptions_GetInScopeOnly}, + { "SetInScopeOnly", _wrap_SBVariablesOptions_SetInScopeOnly}, + { "GetIncludeRuntimeSupportValues", _wrap_SBVariablesOptions_GetIncludeRuntimeSupportValues}, + { "SetIncludeRuntimeSupportValues", _wrap_SBVariablesOptions_SetIncludeRuntimeSupportValues}, + { "GetUseDynamic", _wrap_SBVariablesOptions_GetUseDynamic}, + { "SetUseDynamic", _wrap_SBVariablesOptions_SetUseDynamic}, + {0,0} +}; +static swig_lua_method swig_SBVariablesOptions_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBVariablesOptions_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBVariablesOptions_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBVariablesOptions_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBVariablesOptions_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBVariablesOptions_Sf_SwigStatic = { + "SBVariablesOptions", + swig_SBVariablesOptions_Sf_SwigStatic_methods, + swig_SBVariablesOptions_Sf_SwigStatic_attributes, + swig_SBVariablesOptions_Sf_SwigStatic_constants, + swig_SBVariablesOptions_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBVariablesOptions_bases[] = {0}; +static const char *swig_SBVariablesOptions_base_names[] = {0}; +static swig_lua_class _wrap_class_SBVariablesOptions = { "SBVariablesOptions", "SBVariablesOptions", &SWIGTYPE_p_lldb__SBVariablesOptions,_proxy__wrap_new_SBVariablesOptions, swig_delete_SBVariablesOptions, swig_SBVariablesOptions_methods, swig_SBVariablesOptions_attributes, &swig_SBVariablesOptions_Sf_SwigStatic, swig_SBVariablesOptions_meta, swig_SBVariablesOptions_bases, swig_SBVariablesOptions_base_names }; + +static int _wrap_new_SBWatchpoint__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBWatchpoint *result = 0 ; + + SWIG_check_num_args("lldb::SBWatchpoint::SBWatchpoint",0,0) + result = (lldb::SBWatchpoint *)new lldb::SBWatchpoint(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBWatchpoint,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBWatchpoint__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBWatchpoint *arg1 = 0 ; + lldb::SBWatchpoint *result = 0 ; + + SWIG_check_num_args("lldb::SBWatchpoint::SBWatchpoint",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::SBWatchpoint",1,"lldb::SBWatchpoint const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){ + SWIG_fail_ptr("new_SBWatchpoint",1,SWIGTYPE_p_lldb__SBWatchpoint); + } + + result = (lldb::SBWatchpoint *)new lldb::SBWatchpoint((lldb::SBWatchpoint const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBWatchpoint,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBWatchpoint(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBWatchpoint__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBWatchpoint, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBWatchpoint__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBWatchpoint'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBWatchpoint::SBWatchpoint()\n" + " lldb::SBWatchpoint::SBWatchpoint(lldb::SBWatchpoint const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBWatchpoint___eq(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + lldb::SBWatchpoint *arg2 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBWatchpoint::operator ==",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::operator ==",1,"lldb::SBWatchpoint const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBWatchpoint::operator ==",2,"lldb::SBWatchpoint const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){ + SWIG_fail_ptr("SBWatchpoint___eq",1,SWIGTYPE_p_lldb__SBWatchpoint); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBWatchpoint,0))){ + SWIG_fail_ptr("SBWatchpoint___eq",2,SWIGTYPE_p_lldb__SBWatchpoint); + } + + result = (bool)((lldb::SBWatchpoint const *)arg1)->operator ==((lldb::SBWatchpoint const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBWatchpoint_IsValid(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBWatchpoint::IsValid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::IsValid",1,"lldb::SBWatchpoint const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){ + SWIG_fail_ptr("SBWatchpoint_IsValid",1,SWIGTYPE_p_lldb__SBWatchpoint); + } + + result = (bool)((lldb::SBWatchpoint const *)arg1)->IsValid(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBWatchpoint_GetError(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + lldb::SBError result; + + SWIG_check_num_args("lldb::SBWatchpoint::GetError",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::GetError",1,"lldb::SBWatchpoint *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){ + SWIG_fail_ptr("SBWatchpoint_GetError",1,SWIGTYPE_p_lldb__SBWatchpoint); + } + + result = (arg1)->GetError(); + { + lldb::SBError * resultptr = new lldb::SBError(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBError,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBWatchpoint_GetID(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + lldb::watch_id_t result; + + SWIG_check_num_args("lldb::SBWatchpoint::GetID",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::GetID",1,"lldb::SBWatchpoint *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){ + SWIG_fail_ptr("SBWatchpoint_GetID",1,SWIGTYPE_p_lldb__SBWatchpoint); + } + + result = (lldb::watch_id_t)(arg1)->GetID(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBWatchpoint_GetHardwareIndex(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + int32_t result; + + SWIG_check_num_args("lldb::SBWatchpoint::GetHardwareIndex",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::GetHardwareIndex",1,"lldb::SBWatchpoint *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){ + SWIG_fail_ptr("SBWatchpoint_GetHardwareIndex",1,SWIGTYPE_p_lldb__SBWatchpoint); + } + + result = (int32_t)(arg1)->GetHardwareIndex(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBWatchpoint_GetWatchAddress(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + lldb::addr_t result; + + SWIG_check_num_args("lldb::SBWatchpoint::GetWatchAddress",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::GetWatchAddress",1,"lldb::SBWatchpoint *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){ + SWIG_fail_ptr("SBWatchpoint_GetWatchAddress",1,SWIGTYPE_p_lldb__SBWatchpoint); + } + + result = (lldb::addr_t)(arg1)->GetWatchAddress(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBWatchpoint_GetWatchSize(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + size_t result; + + SWIG_check_num_args("lldb::SBWatchpoint::GetWatchSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::GetWatchSize",1,"lldb::SBWatchpoint *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){ + SWIG_fail_ptr("SBWatchpoint_GetWatchSize",1,SWIGTYPE_p_lldb__SBWatchpoint); + } + + result = (arg1)->GetWatchSize(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBWatchpoint_SetEnabled(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBWatchpoint::SetEnabled",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::SetEnabled",1,"lldb::SBWatchpoint *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBWatchpoint::SetEnabled",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){ + SWIG_fail_ptr("SBWatchpoint_SetEnabled",1,SWIGTYPE_p_lldb__SBWatchpoint); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetEnabled(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBWatchpoint_IsEnabled(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBWatchpoint::IsEnabled",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::IsEnabled",1,"lldb::SBWatchpoint *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){ + SWIG_fail_ptr("SBWatchpoint_IsEnabled",1,SWIGTYPE_p_lldb__SBWatchpoint); + } + + result = (bool)(arg1)->IsEnabled(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBWatchpoint_GetHitCount(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBWatchpoint::GetHitCount",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::GetHitCount",1,"lldb::SBWatchpoint *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){ + SWIG_fail_ptr("SBWatchpoint_GetHitCount",1,SWIGTYPE_p_lldb__SBWatchpoint); + } + + result = (uint32_t)(arg1)->GetHitCount(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBWatchpoint_GetIgnoreCount(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + uint32_t result; + + SWIG_check_num_args("lldb::SBWatchpoint::GetIgnoreCount",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::GetIgnoreCount",1,"lldb::SBWatchpoint *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){ + SWIG_fail_ptr("SBWatchpoint_GetIgnoreCount",1,SWIGTYPE_p_lldb__SBWatchpoint); + } + + result = (uint32_t)(arg1)->GetIgnoreCount(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBWatchpoint_SetIgnoreCount(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + uint32_t arg2 ; + + SWIG_check_num_args("lldb::SBWatchpoint::SetIgnoreCount",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::SetIgnoreCount",1,"lldb::SBWatchpoint *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBWatchpoint::SetIgnoreCount",2,"uint32_t"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){ + SWIG_fail_ptr("SBWatchpoint_SetIgnoreCount",1,SWIGTYPE_p_lldb__SBWatchpoint); + } + + arg2 = (uint32_t)lua_tointeger(L, 2); + (arg1)->SetIgnoreCount(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBWatchpoint_GetCondition(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBWatchpoint::GetCondition",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::GetCondition",1,"lldb::SBWatchpoint *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){ + SWIG_fail_ptr("SBWatchpoint_GetCondition",1,SWIGTYPE_p_lldb__SBWatchpoint); + } + + result = (char *)(arg1)->GetCondition(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBWatchpoint_SetCondition(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + char *arg2 = (char *) 0 ; + + SWIG_check_num_args("lldb::SBWatchpoint::SetCondition",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::SetCondition",1,"lldb::SBWatchpoint *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("lldb::SBWatchpoint::SetCondition",2,"char const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){ + SWIG_fail_ptr("SBWatchpoint_SetCondition",1,SWIGTYPE_p_lldb__SBWatchpoint); + } + + arg2 = (char *)lua_tostring(L, 2); + (arg1)->SetCondition((char const *)arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBWatchpoint_GetDescription(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + lldb::SBStream *arg2 = 0 ; + lldb::DescriptionLevel arg3 ; + bool result; + + SWIG_check_num_args("lldb::SBWatchpoint::GetDescription",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::GetDescription",1,"lldb::SBWatchpoint *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("lldb::SBWatchpoint::GetDescription",2,"lldb::SBStream &"); + if(!lua_isinteger(L,3)) SWIG_fail_arg("lldb::SBWatchpoint::GetDescription",3,"lldb::DescriptionLevel"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){ + SWIG_fail_ptr("SBWatchpoint_GetDescription",1,SWIGTYPE_p_lldb__SBWatchpoint); + } + + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_lldb__SBStream,0))){ + SWIG_fail_ptr("SBWatchpoint_GetDescription",2,SWIGTYPE_p_lldb__SBStream); + } + + arg3 = (lldb::DescriptionLevel)lua_tointeger(L, 3); + result = (bool)(arg1)->GetDescription(*arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBWatchpoint_Clear(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + + SWIG_check_num_args("lldb::SBWatchpoint::Clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::Clear",1,"lldb::SBWatchpoint *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){ + SWIG_fail_ptr("SBWatchpoint_Clear",1,SWIGTYPE_p_lldb__SBWatchpoint); + } + + (arg1)->Clear(); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBWatchpoint_EventIsWatchpointEvent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = 0 ; + bool result; + + SWIG_check_num_args("lldb::SBWatchpoint::EventIsWatchpointEvent",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::EventIsWatchpointEvent",1,"lldb::SBEvent const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBWatchpoint_EventIsWatchpointEvent",1,SWIGTYPE_p_lldb__SBEvent); + } + + result = (bool)lldb::SBWatchpoint::EventIsWatchpointEvent((lldb::SBEvent const &)*arg1); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBWatchpoint_GetWatchpointEventTypeFromEvent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = 0 ; + lldb::WatchpointEventType result; + + SWIG_check_num_args("lldb::SBWatchpoint::GetWatchpointEventTypeFromEvent",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::GetWatchpointEventTypeFromEvent",1,"lldb::SBEvent const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBWatchpoint_GetWatchpointEventTypeFromEvent",1,SWIGTYPE_p_lldb__SBEvent); + } + + result = (lldb::WatchpointEventType)lldb::SBWatchpoint::GetWatchpointEventTypeFromEvent((lldb::SBEvent const &)*arg1); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBWatchpoint_GetWatchpointFromEvent(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBEvent *arg1 = 0 ; + lldb::SBWatchpoint result; + + SWIG_check_num_args("lldb::SBWatchpoint::GetWatchpointFromEvent",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::GetWatchpointFromEvent",1,"lldb::SBEvent const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBEvent,0))){ + SWIG_fail_ptr("SBWatchpoint_GetWatchpointFromEvent",1,SWIGTYPE_p_lldb__SBEvent); + } + + result = lldb::SBWatchpoint::GetWatchpointFromEvent((lldb::SBEvent const &)*arg1); + { + lldb::SBWatchpoint * resultptr = new lldb::SBWatchpoint(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBWatchpoint,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBWatchpoint_GetType(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + lldb::SBType result; + + SWIG_check_num_args("lldb::SBWatchpoint::GetType",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::GetType",1,"lldb::SBWatchpoint *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){ + SWIG_fail_ptr("SBWatchpoint_GetType",1,SWIGTYPE_p_lldb__SBWatchpoint); + } + + result = (arg1)->GetType(); + { + lldb::SBType * resultptr = new lldb::SBType(result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_lldb__SBType,1); SWIG_arg++; + } + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBWatchpoint_GetWatchValueKind(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + lldb::WatchpointValueKind result; + + SWIG_check_num_args("lldb::SBWatchpoint::GetWatchValueKind",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::GetWatchValueKind",1,"lldb::SBWatchpoint *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){ + SWIG_fail_ptr("SBWatchpoint_GetWatchValueKind",1,SWIGTYPE_p_lldb__SBWatchpoint); + } + + result = (lldb::WatchpointValueKind)(arg1)->GetWatchValueKind(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBWatchpoint_GetWatchSpec(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + char *result = 0 ; + + SWIG_check_num_args("lldb::SBWatchpoint::GetWatchSpec",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::GetWatchSpec",1,"lldb::SBWatchpoint *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){ + SWIG_fail_ptr("SBWatchpoint_GetWatchSpec",1,SWIGTYPE_p_lldb__SBWatchpoint); + } + + result = (char *)(arg1)->GetWatchSpec(); + lua_pushstring(L,(const char *)result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBWatchpoint_IsWatchingReads(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBWatchpoint::IsWatchingReads",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::IsWatchingReads",1,"lldb::SBWatchpoint *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){ + SWIG_fail_ptr("SBWatchpoint_IsWatchingReads",1,SWIGTYPE_p_lldb__SBWatchpoint); + } + + result = (bool)(arg1)->IsWatchingReads(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBWatchpoint_IsWatchingWrites(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBWatchpoint::IsWatchingWrites",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::IsWatchingWrites",1,"lldb::SBWatchpoint *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){ + SWIG_fail_ptr("SBWatchpoint_IsWatchingWrites",1,SWIGTYPE_p_lldb__SBWatchpoint); + } + + result = (bool)(arg1)->IsWatchingWrites(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBWatchpoint___tostring(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) 0 ; + std::string result; + + SWIG_check_num_args("lldb::SBWatchpoint::__repr__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpoint::__repr__",1,"lldb::SBWatchpoint *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpoint,0))){ + SWIG_fail_ptr("SBWatchpoint___tostring",1,SWIGTYPE_p_lldb__SBWatchpoint); + } + + result = lldb_SBWatchpoint___repr__(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBWatchpoint(void *obj) { +lldb::SBWatchpoint *arg1 = (lldb::SBWatchpoint *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBWatchpoint(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBWatchpoint); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBWatchpoint_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBWatchpoint_methods[]= { + { "__eq", _wrap_SBWatchpoint___eq}, + { "IsValid", _wrap_SBWatchpoint_IsValid}, + { "GetError", _wrap_SBWatchpoint_GetError}, + { "GetID", _wrap_SBWatchpoint_GetID}, + { "GetHardwareIndex", _wrap_SBWatchpoint_GetHardwareIndex}, + { "GetWatchAddress", _wrap_SBWatchpoint_GetWatchAddress}, + { "GetWatchSize", _wrap_SBWatchpoint_GetWatchSize}, + { "SetEnabled", _wrap_SBWatchpoint_SetEnabled}, + { "IsEnabled", _wrap_SBWatchpoint_IsEnabled}, + { "GetHitCount", _wrap_SBWatchpoint_GetHitCount}, + { "GetIgnoreCount", _wrap_SBWatchpoint_GetIgnoreCount}, + { "SetIgnoreCount", _wrap_SBWatchpoint_SetIgnoreCount}, + { "GetCondition", _wrap_SBWatchpoint_GetCondition}, + { "SetCondition", _wrap_SBWatchpoint_SetCondition}, + { "GetDescription", _wrap_SBWatchpoint_GetDescription}, + { "Clear", _wrap_SBWatchpoint_Clear}, + { "GetType", _wrap_SBWatchpoint_GetType}, + { "GetWatchValueKind", _wrap_SBWatchpoint_GetWatchValueKind}, + { "GetWatchSpec", _wrap_SBWatchpoint_GetWatchSpec}, + { "IsWatchingReads", _wrap_SBWatchpoint_IsWatchingReads}, + { "IsWatchingWrites", _wrap_SBWatchpoint_IsWatchingWrites}, + { "__tostring", _wrap_SBWatchpoint___tostring}, + {0,0} +}; +static swig_lua_method swig_SBWatchpoint_meta[] = { + { "__eq", _wrap_SBWatchpoint___eq}, + { "__tostring", _wrap_SBWatchpoint___tostring}, + {0,0} +}; + +static swig_lua_attribute swig_SBWatchpoint_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBWatchpoint_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBWatchpoint_Sf_SwigStatic_methods[]= { + { "EventIsWatchpointEvent", _wrap_SBWatchpoint_EventIsWatchpointEvent}, + { "GetWatchpointEventTypeFromEvent", _wrap_SBWatchpoint_GetWatchpointEventTypeFromEvent}, + { "GetWatchpointFromEvent", _wrap_SBWatchpoint_GetWatchpointFromEvent}, + {0,0} +}; +static swig_lua_class* swig_SBWatchpoint_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBWatchpoint_Sf_SwigStatic = { + "SBWatchpoint", + swig_SBWatchpoint_Sf_SwigStatic_methods, + swig_SBWatchpoint_Sf_SwigStatic_attributes, + swig_SBWatchpoint_Sf_SwigStatic_constants, + swig_SBWatchpoint_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBWatchpoint_bases[] = {0}; +static const char *swig_SBWatchpoint_base_names[] = {0}; +static swig_lua_class _wrap_class_SBWatchpoint = { "SBWatchpoint", "SBWatchpoint", &SWIGTYPE_p_lldb__SBWatchpoint,_proxy__wrap_new_SBWatchpoint, swig_delete_SBWatchpoint, swig_SBWatchpoint_methods, swig_SBWatchpoint_attributes, &swig_SBWatchpoint_Sf_SwigStatic, swig_SBWatchpoint_meta, swig_SBWatchpoint_bases, swig_SBWatchpoint_base_names }; + +static int _wrap_new_SBWatchpointOptions__SWIG_0(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBWatchpointOptions *result = 0 ; + + SWIG_check_num_args("lldb::SBWatchpointOptions::SBWatchpointOptions",0,0) + result = (lldb::SBWatchpointOptions *)new lldb::SBWatchpointOptions(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBWatchpointOptions,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBWatchpointOptions__SWIG_1(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBWatchpointOptions *arg1 = 0 ; + lldb::SBWatchpointOptions *result = 0 ; + + SWIG_check_num_args("lldb::SBWatchpointOptions::SBWatchpointOptions",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("lldb::SBWatchpointOptions::SBWatchpointOptions",1,"lldb::SBWatchpointOptions const &"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpointOptions,0))){ + SWIG_fail_ptr("new_SBWatchpointOptions",1,SWIGTYPE_p_lldb__SBWatchpointOptions); + } + + result = (lldb::SBWatchpointOptions *)new lldb::SBWatchpointOptions((lldb::SBWatchpointOptions const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_lldb__SBWatchpointOptions,1); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_new_SBWatchpointOptions(lua_State* L) { + int argc; + int argv[2]={ + 1,2 + }; + + argc = lua_gettop(L); + if (argc == 0) { + return _wrap_new_SBWatchpointOptions__SWIG_0(L); + } + if (argc == 1) { + int _v = 0; + { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_lldb__SBWatchpointOptions, SWIG_POINTER_NO_NULL)) { + _v = 0; + } else { + _v = 1; + } + } + if (_v) { + return _wrap_new_SBWatchpointOptions__SWIG_1(L); + } + } + + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SBWatchpointOptions'\n" + " Possible C/C++ prototypes are:\n" + " lldb::SBWatchpointOptions::SBWatchpointOptions()\n" + " lldb::SBWatchpointOptions::SBWatchpointOptions(lldb::SBWatchpointOptions const &)\n"); + lua_error(L);return 0; +} + + +static int _wrap_SBWatchpointOptions_SetWatchpointTypeRead(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBWatchpointOptions *arg1 = (lldb::SBWatchpointOptions *) 0 ; + bool arg2 ; + + SWIG_check_num_args("lldb::SBWatchpointOptions::SetWatchpointTypeRead",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpointOptions::SetWatchpointTypeRead",1,"lldb::SBWatchpointOptions *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("lldb::SBWatchpointOptions::SetWatchpointTypeRead",2,"bool"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpointOptions,0))){ + SWIG_fail_ptr("SBWatchpointOptions_SetWatchpointTypeRead",1,SWIGTYPE_p_lldb__SBWatchpointOptions); + } + + arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->SetWatchpointTypeRead(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBWatchpointOptions_GetWatchpointTypeRead(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBWatchpointOptions *arg1 = (lldb::SBWatchpointOptions *) 0 ; + bool result; + + SWIG_check_num_args("lldb::SBWatchpointOptions::GetWatchpointTypeRead",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpointOptions::GetWatchpointTypeRead",1,"lldb::SBWatchpointOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpointOptions,0))){ + SWIG_fail_ptr("SBWatchpointOptions_GetWatchpointTypeRead",1,SWIGTYPE_p_lldb__SBWatchpointOptions); + } + + result = (bool)((lldb::SBWatchpointOptions const *)arg1)->GetWatchpointTypeRead(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBWatchpointOptions_SetWatchpointTypeWrite(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBWatchpointOptions *arg1 = (lldb::SBWatchpointOptions *) 0 ; + lldb::WatchpointWriteType arg2 ; + + SWIG_check_num_args("lldb::SBWatchpointOptions::SetWatchpointTypeWrite",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpointOptions::SetWatchpointTypeWrite",1,"lldb::SBWatchpointOptions *"); + if(!lua_isinteger(L,2)) SWIG_fail_arg("lldb::SBWatchpointOptions::SetWatchpointTypeWrite",2,"lldb::WatchpointWriteType"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpointOptions,0))){ + SWIG_fail_ptr("SBWatchpointOptions_SetWatchpointTypeWrite",1,SWIGTYPE_p_lldb__SBWatchpointOptions); + } + + arg2 = (lldb::WatchpointWriteType)lua_tointeger(L, 2); + (arg1)->SetWatchpointTypeWrite(arg2); + + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static int _wrap_SBWatchpointOptions_GetWatchpointTypeWrite(lua_State* L) { + { + int SWIG_arg = 0; + lldb::SBWatchpointOptions *arg1 = (lldb::SBWatchpointOptions *) 0 ; + lldb::WatchpointWriteType result; + + SWIG_check_num_args("lldb::SBWatchpointOptions::GetWatchpointTypeWrite",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("lldb::SBWatchpointOptions::GetWatchpointTypeWrite",1,"lldb::SBWatchpointOptions const *"); + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_lldb__SBWatchpointOptions,0))){ + SWIG_fail_ptr("SBWatchpointOptions_GetWatchpointTypeWrite",1,SWIGTYPE_p_lldb__SBWatchpointOptions); + } + + result = (lldb::WatchpointWriteType)((lldb::SBWatchpointOptions const *)arg1)->GetWatchpointTypeWrite(); + lua_pushinteger(L, (lua_Integer) result); SWIG_arg++; + return SWIG_arg; + + fail: SWIGUNUSED; + } + lua_error(L); + return 0; +} + + +static void swig_delete_SBWatchpointOptions(void *obj) { +lldb::SBWatchpointOptions *arg1 = (lldb::SBWatchpointOptions *) obj; +delete arg1; +} +static int _proxy__wrap_new_SBWatchpointOptions(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SBWatchpointOptions); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SBWatchpointOptions_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_SBWatchpointOptions_methods[]= { + { "SetWatchpointTypeRead", _wrap_SBWatchpointOptions_SetWatchpointTypeRead}, + { "GetWatchpointTypeRead", _wrap_SBWatchpointOptions_GetWatchpointTypeRead}, + { "SetWatchpointTypeWrite", _wrap_SBWatchpointOptions_SetWatchpointTypeWrite}, + { "GetWatchpointTypeWrite", _wrap_SBWatchpointOptions_GetWatchpointTypeWrite}, + {0,0} +}; +static swig_lua_method swig_SBWatchpointOptions_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SBWatchpointOptions_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SBWatchpointOptions_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SBWatchpointOptions_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SBWatchpointOptions_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SBWatchpointOptions_Sf_SwigStatic = { + "SBWatchpointOptions", + swig_SBWatchpointOptions_Sf_SwigStatic_methods, + swig_SBWatchpointOptions_Sf_SwigStatic_attributes, + swig_SBWatchpointOptions_Sf_SwigStatic_constants, + swig_SBWatchpointOptions_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SBWatchpointOptions_bases[] = {0}; +static const char *swig_SBWatchpointOptions_base_names[] = {0}; +static swig_lua_class _wrap_class_SBWatchpointOptions = { "SBWatchpointOptions", "SBWatchpointOptions", &SWIGTYPE_p_lldb__SBWatchpointOptions,_proxy__wrap_new_SBWatchpointOptions, swig_delete_SBWatchpointOptions, swig_SBWatchpointOptions_methods, swig_SBWatchpointOptions_attributes, &swig_SBWatchpointOptions_Sf_SwigStatic, swig_SBWatchpointOptions_meta, swig_SBWatchpointOptions_bases, swig_SBWatchpointOptions_base_names }; + +static swig_lua_attribute swig_SwigModule_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SwigModule_constants[]= { + {SWIG_LUA_CONSTTAB_INT("INT32_MAX", (2147483647))}, + {SWIG_LUA_CONSTTAB_INT("UINT32_MAX", (4294967295U))}, + {SWIG_LUA_CONSTTAB_STRING("UINT64_MAX", "18446744073709551615ULL")}, + {SWIG_LUA_CONSTTAB_INT("LLDB_GENERIC_ERROR", (4294967295U))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_INVALID_BREAK_ID", (0))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_DEFAULT_BREAK_SIZE", (0))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_INVALID_WATCH_ID", (0))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_WATCH_TYPE_READ", ((1u << 0)))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_WATCH_TYPE_WRITE", ((1u << 1)))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_WATCH_TYPE_MODIFY", ((1u << 2)))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_INVALID_SITE_ID", (4294967295U))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_REGNUM_GENERIC_PC", (0))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_REGNUM_GENERIC_SP", (1))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_REGNUM_GENERIC_FP", (2))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_REGNUM_GENERIC_RA", (3))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_REGNUM_GENERIC_FLAGS", (4))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_REGNUM_GENERIC_ARG1", (5))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_REGNUM_GENERIC_ARG2", (6))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_REGNUM_GENERIC_ARG3", (7))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_REGNUM_GENERIC_ARG4", (8))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_REGNUM_GENERIC_ARG5", (9))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_REGNUM_GENERIC_ARG6", (10))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_REGNUM_GENERIC_ARG7", (11))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_REGNUM_GENERIC_ARG8", (12))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_REGNUM_GENERIC_TP", (13))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_INVALID_STOP_ID", (0))}, + {SWIG_LUA_CONSTTAB_STRING("LLDB_INVALID_ADDRESS", "18446744073709551615ULL")}, + {SWIG_LUA_CONSTTAB_INT("LLDB_INVALID_INDEX32", (4294967295U))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_INVALID_IVAR_OFFSET", (4294967295U))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_INVALID_IMAGE_TOKEN", (4294967295U))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_INVALID_MODULE_VERSION", (4294967295U))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_INVALID_REGNUM", (4294967295U))}, + {SWIG_LUA_CONSTTAB_STRING("LLDB_INVALID_UID", "18446744073709551615ULL")}, + {SWIG_LUA_CONSTTAB_INT("LLDB_INVALID_PROCESS_ID", (0))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_INVALID_THREAD_ID", (0))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_INVALID_FRAME_ID", (4294967295U))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_INVALID_SIGNAL_NUMBER", (2147483647))}, + {SWIG_LUA_CONSTTAB_STRING("LLDB_INVALID_OFFSET", "18446744073709551615ULL")}, + {SWIG_LUA_CONSTTAB_INT("LLDB_INVALID_LINE_NUMBER", (4294967295U))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_INVALID_COLUMN_NUMBER", (0))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_INVALID_QUEUE_ID", (0))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_INVALID_CPU_ID", (4294967295U))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_INVALID_WATCHPOINT_RESOURCE_ID", (4294967295U))}, + {SWIG_LUA_CONSTTAB_STRING("LLDB_ARCH_DEFAULT", "systemArch")}, + {SWIG_LUA_CONSTTAB_STRING("LLDB_ARCH_DEFAULT_32BIT", "systemArch32")}, + {SWIG_LUA_CONSTTAB_STRING("LLDB_ARCH_DEFAULT_64BIT", "systemArch64")}, + {SWIG_LUA_CONSTTAB_INT("LLDB_INVALID_CPUTYPE", ((0xFFFFFFFEu)))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_MAX_NUM_OPTION_SETS", (32))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_OPT_SET_ALL", (0xFFFFFFFFU))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_OPT_SET_1", ((1U << 0)))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_OPT_SET_2", ((1U << 1)))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_OPT_SET_3", ((1U << 2)))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_OPT_SET_4", ((1U << 3)))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_OPT_SET_5", ((1U << 4)))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_OPT_SET_6", ((1U << 5)))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_OPT_SET_7", ((1U << 6)))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_OPT_SET_8", ((1U << 7)))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_OPT_SET_9", ((1U << 8)))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_OPT_SET_10", ((1U << 9)))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_OPT_SET_11", ((1U << 10)))}, + {SWIG_LUA_CONSTTAB_INT("LLDB_OPT_SET_12", ((1U << 11)))}, + {SWIG_LUA_CONSTTAB_STRING("LLDB_INVALID_ADDRESS_MASK", "18446744073709551615ULL")}, + {SWIG_LUA_CONSTTAB_INT("eStateInvalid", (lldb::eStateInvalid))}, + {SWIG_LUA_CONSTTAB_INT("eStateUnloaded", (lldb::eStateUnloaded))}, + {SWIG_LUA_CONSTTAB_INT("eStateConnected", (lldb::eStateConnected))}, + {SWIG_LUA_CONSTTAB_INT("eStateAttaching", (lldb::eStateAttaching))}, + {SWIG_LUA_CONSTTAB_INT("eStateLaunching", (lldb::eStateLaunching))}, + {SWIG_LUA_CONSTTAB_INT("eStateStopped", (lldb::eStateStopped))}, + {SWIG_LUA_CONSTTAB_INT("eStateRunning", (lldb::eStateRunning))}, + {SWIG_LUA_CONSTTAB_INT("eStateStepping", (lldb::eStateStepping))}, + {SWIG_LUA_CONSTTAB_INT("eStateCrashed", (lldb::eStateCrashed))}, + {SWIG_LUA_CONSTTAB_INT("eStateDetached", (lldb::eStateDetached))}, + {SWIG_LUA_CONSTTAB_INT("eStateExited", (lldb::eStateExited))}, + {SWIG_LUA_CONSTTAB_INT("eStateSuspended", (lldb::eStateSuspended))}, + {SWIG_LUA_CONSTTAB_INT("kLastStateType", (lldb::kLastStateType))}, + {SWIG_LUA_CONSTTAB_INT("eLaunchFlagNone", (lldb::eLaunchFlagNone))}, + {SWIG_LUA_CONSTTAB_INT("eLaunchFlagExec", (lldb::eLaunchFlagExec))}, + {SWIG_LUA_CONSTTAB_INT("eLaunchFlagDebug", (lldb::eLaunchFlagDebug))}, + {SWIG_LUA_CONSTTAB_INT("eLaunchFlagStopAtEntry", (lldb::eLaunchFlagStopAtEntry))}, + {SWIG_LUA_CONSTTAB_INT("eLaunchFlagDisableASLR", (lldb::eLaunchFlagDisableASLR))}, + {SWIG_LUA_CONSTTAB_INT("eLaunchFlagDisableSTDIO", (lldb::eLaunchFlagDisableSTDIO))}, + {SWIG_LUA_CONSTTAB_INT("eLaunchFlagLaunchInTTY", (lldb::eLaunchFlagLaunchInTTY))}, + {SWIG_LUA_CONSTTAB_INT("eLaunchFlagLaunchInShell", (lldb::eLaunchFlagLaunchInShell))}, + {SWIG_LUA_CONSTTAB_INT("eLaunchFlagLaunchInSeparateProcessGroup", (lldb::eLaunchFlagLaunchInSeparateProcessGroup))}, + {SWIG_LUA_CONSTTAB_INT("eLaunchFlagDontSetExitStatus", (lldb::eLaunchFlagDontSetExitStatus))}, + {SWIG_LUA_CONSTTAB_INT("eLaunchFlagDetachOnError", (lldb::eLaunchFlagDetachOnError))}, + {SWIG_LUA_CONSTTAB_INT("eLaunchFlagShellExpandArguments", (lldb::eLaunchFlagShellExpandArguments))}, + {SWIG_LUA_CONSTTAB_INT("eLaunchFlagCloseTTYOnExit", (lldb::eLaunchFlagCloseTTYOnExit))}, + {SWIG_LUA_CONSTTAB_INT("eLaunchFlagInheritTCCFromParent", (lldb::eLaunchFlagInheritTCCFromParent))}, + {SWIG_LUA_CONSTTAB_INT("eOnlyThisThread", (lldb::eOnlyThisThread))}, + {SWIG_LUA_CONSTTAB_INT("eAllThreads", (lldb::eAllThreads))}, + {SWIG_LUA_CONSTTAB_INT("eOnlyDuringStepping", (lldb::eOnlyDuringStepping))}, + {SWIG_LUA_CONSTTAB_INT("eByteOrderInvalid", (lldb::eByteOrderInvalid))}, + {SWIG_LUA_CONSTTAB_INT("eByteOrderBig", (lldb::eByteOrderBig))}, + {SWIG_LUA_CONSTTAB_INT("eByteOrderPDP", (lldb::eByteOrderPDP))}, + {SWIG_LUA_CONSTTAB_INT("eByteOrderLittle", (lldb::eByteOrderLittle))}, + {SWIG_LUA_CONSTTAB_INT("eEncodingInvalid", (lldb::eEncodingInvalid))}, + {SWIG_LUA_CONSTTAB_INT("eEncodingUint", (lldb::eEncodingUint))}, + {SWIG_LUA_CONSTTAB_INT("eEncodingSint", (lldb::eEncodingSint))}, + {SWIG_LUA_CONSTTAB_INT("eEncodingIEEE754", (lldb::eEncodingIEEE754))}, + {SWIG_LUA_CONSTTAB_INT("eEncodingVector", (lldb::eEncodingVector))}, + {SWIG_LUA_CONSTTAB_INT("eFormatDefault", (lldb::eFormatDefault))}, + {SWIG_LUA_CONSTTAB_INT("eFormatInvalid", (lldb::eFormatInvalid))}, + {SWIG_LUA_CONSTTAB_INT("eFormatBoolean", (lldb::eFormatBoolean))}, + {SWIG_LUA_CONSTTAB_INT("eFormatBinary", (lldb::eFormatBinary))}, + {SWIG_LUA_CONSTTAB_INT("eFormatBytes", (lldb::eFormatBytes))}, + {SWIG_LUA_CONSTTAB_INT("eFormatBytesWithASCII", (lldb::eFormatBytesWithASCII))}, + {SWIG_LUA_CONSTTAB_INT("eFormatChar", (lldb::eFormatChar))}, + {SWIG_LUA_CONSTTAB_INT("eFormatCharPrintable", (lldb::eFormatCharPrintable))}, + {SWIG_LUA_CONSTTAB_INT("eFormatComplex", (lldb::eFormatComplex))}, + {SWIG_LUA_CONSTTAB_INT("eFormatComplexFloat", (lldb::eFormatComplexFloat))}, + {SWIG_LUA_CONSTTAB_INT("eFormatCString", (lldb::eFormatCString))}, + {SWIG_LUA_CONSTTAB_INT("eFormatDecimal", (lldb::eFormatDecimal))}, + {SWIG_LUA_CONSTTAB_INT("eFormatEnum", (lldb::eFormatEnum))}, + {SWIG_LUA_CONSTTAB_INT("eFormatHex", (lldb::eFormatHex))}, + {SWIG_LUA_CONSTTAB_INT("eFormatHexUppercase", (lldb::eFormatHexUppercase))}, + {SWIG_LUA_CONSTTAB_INT("eFormatFloat", (lldb::eFormatFloat))}, + {SWIG_LUA_CONSTTAB_INT("eFormatOctal", (lldb::eFormatOctal))}, + {SWIG_LUA_CONSTTAB_INT("eFormatOSType", (lldb::eFormatOSType))}, + {SWIG_LUA_CONSTTAB_INT("eFormatUnicode16", (lldb::eFormatUnicode16))}, + {SWIG_LUA_CONSTTAB_INT("eFormatUnicode32", (lldb::eFormatUnicode32))}, + {SWIG_LUA_CONSTTAB_INT("eFormatUnsigned", (lldb::eFormatUnsigned))}, + {SWIG_LUA_CONSTTAB_INT("eFormatPointer", (lldb::eFormatPointer))}, + {SWIG_LUA_CONSTTAB_INT("eFormatVectorOfChar", (lldb::eFormatVectorOfChar))}, + {SWIG_LUA_CONSTTAB_INT("eFormatVectorOfSInt8", (lldb::eFormatVectorOfSInt8))}, + {SWIG_LUA_CONSTTAB_INT("eFormatVectorOfUInt8", (lldb::eFormatVectorOfUInt8))}, + {SWIG_LUA_CONSTTAB_INT("eFormatVectorOfSInt16", (lldb::eFormatVectorOfSInt16))}, + {SWIG_LUA_CONSTTAB_INT("eFormatVectorOfUInt16", (lldb::eFormatVectorOfUInt16))}, + {SWIG_LUA_CONSTTAB_INT("eFormatVectorOfSInt32", (lldb::eFormatVectorOfSInt32))}, + {SWIG_LUA_CONSTTAB_INT("eFormatVectorOfUInt32", (lldb::eFormatVectorOfUInt32))}, + {SWIG_LUA_CONSTTAB_INT("eFormatVectorOfSInt64", (lldb::eFormatVectorOfSInt64))}, + {SWIG_LUA_CONSTTAB_INT("eFormatVectorOfUInt64", (lldb::eFormatVectorOfUInt64))}, + {SWIG_LUA_CONSTTAB_INT("eFormatVectorOfFloat16", (lldb::eFormatVectorOfFloat16))}, + {SWIG_LUA_CONSTTAB_INT("eFormatVectorOfFloat32", (lldb::eFormatVectorOfFloat32))}, + {SWIG_LUA_CONSTTAB_INT("eFormatVectorOfFloat64", (lldb::eFormatVectorOfFloat64))}, + {SWIG_LUA_CONSTTAB_INT("eFormatVectorOfUInt128", (lldb::eFormatVectorOfUInt128))}, + {SWIG_LUA_CONSTTAB_INT("eFormatComplexInteger", (lldb::eFormatComplexInteger))}, + {SWIG_LUA_CONSTTAB_INT("eFormatCharArray", (lldb::eFormatCharArray))}, + {SWIG_LUA_CONSTTAB_INT("eFormatAddressInfo", (lldb::eFormatAddressInfo))}, + {SWIG_LUA_CONSTTAB_INT("eFormatHexFloat", (lldb::eFormatHexFloat))}, + {SWIG_LUA_CONSTTAB_INT("eFormatInstruction", (lldb::eFormatInstruction))}, + {SWIG_LUA_CONSTTAB_INT("eFormatVoid", (lldb::eFormatVoid))}, + {SWIG_LUA_CONSTTAB_INT("eFormatUnicode8", (lldb::eFormatUnicode8))}, + {SWIG_LUA_CONSTTAB_INT("kNumFormats", (lldb::kNumFormats))}, + {SWIG_LUA_CONSTTAB_INT("eDescriptionLevelBrief", (lldb::eDescriptionLevelBrief))}, + {SWIG_LUA_CONSTTAB_INT("eDescriptionLevelFull", (lldb::eDescriptionLevelFull))}, + {SWIG_LUA_CONSTTAB_INT("eDescriptionLevelVerbose", (lldb::eDescriptionLevelVerbose))}, + {SWIG_LUA_CONSTTAB_INT("eDescriptionLevelInitial", (lldb::eDescriptionLevelInitial))}, + {SWIG_LUA_CONSTTAB_INT("kNumDescriptionLevels", (lldb::kNumDescriptionLevels))}, + {SWIG_LUA_CONSTTAB_INT("eScriptLanguageNone", (lldb::eScriptLanguageNone))}, + {SWIG_LUA_CONSTTAB_INT("eScriptLanguagePython", (lldb::eScriptLanguagePython))}, + {SWIG_LUA_CONSTTAB_INT("eScriptLanguageLua", (lldb::eScriptLanguageLua))}, + {SWIG_LUA_CONSTTAB_INT("eScriptLanguageUnknown", (lldb::eScriptLanguageUnknown))}, + {SWIG_LUA_CONSTTAB_INT("eScriptLanguageDefault", (lldb::eScriptLanguageDefault))}, + {SWIG_LUA_CONSTTAB_INT("eRegisterKindEHFrame", (lldb::eRegisterKindEHFrame))}, + {SWIG_LUA_CONSTTAB_INT("eRegisterKindDWARF", (lldb::eRegisterKindDWARF))}, + {SWIG_LUA_CONSTTAB_INT("eRegisterKindGeneric", (lldb::eRegisterKindGeneric))}, + {SWIG_LUA_CONSTTAB_INT("eRegisterKindProcessPlugin", (lldb::eRegisterKindProcessPlugin))}, + {SWIG_LUA_CONSTTAB_INT("eRegisterKindLLDB", (lldb::eRegisterKindLLDB))}, + {SWIG_LUA_CONSTTAB_INT("kNumRegisterKinds", (lldb::kNumRegisterKinds))}, + {SWIG_LUA_CONSTTAB_INT("eStopReasonInvalid", (lldb::eStopReasonInvalid))}, + {SWIG_LUA_CONSTTAB_INT("eStopReasonNone", (lldb::eStopReasonNone))}, + {SWIG_LUA_CONSTTAB_INT("eStopReasonTrace", (lldb::eStopReasonTrace))}, + {SWIG_LUA_CONSTTAB_INT("eStopReasonBreakpoint", (lldb::eStopReasonBreakpoint))}, + {SWIG_LUA_CONSTTAB_INT("eStopReasonWatchpoint", (lldb::eStopReasonWatchpoint))}, + {SWIG_LUA_CONSTTAB_INT("eStopReasonSignal", (lldb::eStopReasonSignal))}, + {SWIG_LUA_CONSTTAB_INT("eStopReasonException", (lldb::eStopReasonException))}, + {SWIG_LUA_CONSTTAB_INT("eStopReasonExec", (lldb::eStopReasonExec))}, + {SWIG_LUA_CONSTTAB_INT("eStopReasonPlanComplete", (lldb::eStopReasonPlanComplete))}, + {SWIG_LUA_CONSTTAB_INT("eStopReasonThreadExiting", (lldb::eStopReasonThreadExiting))}, + {SWIG_LUA_CONSTTAB_INT("eStopReasonInstrumentation", (lldb::eStopReasonInstrumentation))}, + {SWIG_LUA_CONSTTAB_INT("eStopReasonProcessorTrace", (lldb::eStopReasonProcessorTrace))}, + {SWIG_LUA_CONSTTAB_INT("eStopReasonFork", (lldb::eStopReasonFork))}, + {SWIG_LUA_CONSTTAB_INT("eStopReasonVFork", (lldb::eStopReasonVFork))}, + {SWIG_LUA_CONSTTAB_INT("eStopReasonVForkDone", (lldb::eStopReasonVForkDone))}, + {SWIG_LUA_CONSTTAB_INT("eReturnStatusInvalid", (lldb::eReturnStatusInvalid))}, + {SWIG_LUA_CONSTTAB_INT("eReturnStatusSuccessFinishNoResult", (lldb::eReturnStatusSuccessFinishNoResult))}, + {SWIG_LUA_CONSTTAB_INT("eReturnStatusSuccessFinishResult", (lldb::eReturnStatusSuccessFinishResult))}, + {SWIG_LUA_CONSTTAB_INT("eReturnStatusSuccessContinuingNoResult", (lldb::eReturnStatusSuccessContinuingNoResult))}, + {SWIG_LUA_CONSTTAB_INT("eReturnStatusSuccessContinuingResult", (lldb::eReturnStatusSuccessContinuingResult))}, + {SWIG_LUA_CONSTTAB_INT("eReturnStatusStarted", (lldb::eReturnStatusStarted))}, + {SWIG_LUA_CONSTTAB_INT("eReturnStatusFailed", (lldb::eReturnStatusFailed))}, + {SWIG_LUA_CONSTTAB_INT("eReturnStatusQuit", (lldb::eReturnStatusQuit))}, + {SWIG_LUA_CONSTTAB_INT("eExpressionCompleted", (lldb::eExpressionCompleted))}, + {SWIG_LUA_CONSTTAB_INT("eExpressionSetupError", (lldb::eExpressionSetupError))}, + {SWIG_LUA_CONSTTAB_INT("eExpressionParseError", (lldb::eExpressionParseError))}, + {SWIG_LUA_CONSTTAB_INT("eExpressionDiscarded", (lldb::eExpressionDiscarded))}, + {SWIG_LUA_CONSTTAB_INT("eExpressionInterrupted", (lldb::eExpressionInterrupted))}, + {SWIG_LUA_CONSTTAB_INT("eExpressionHitBreakpoint", (lldb::eExpressionHitBreakpoint))}, + {SWIG_LUA_CONSTTAB_INT("eExpressionTimedOut", (lldb::eExpressionTimedOut))}, + {SWIG_LUA_CONSTTAB_INT("eExpressionResultUnavailable", (lldb::eExpressionResultUnavailable))}, + {SWIG_LUA_CONSTTAB_INT("eExpressionStoppedForDebug", (lldb::eExpressionStoppedForDebug))}, + {SWIG_LUA_CONSTTAB_INT("eExpressionThreadVanished", (lldb::eExpressionThreadVanished))}, + {SWIG_LUA_CONSTTAB_INT("eSearchDepthInvalid", (lldb::eSearchDepthInvalid))}, + {SWIG_LUA_CONSTTAB_INT("eSearchDepthTarget", (lldb::eSearchDepthTarget))}, + {SWIG_LUA_CONSTTAB_INT("eSearchDepthModule", (lldb::eSearchDepthModule))}, + {SWIG_LUA_CONSTTAB_INT("eSearchDepthCompUnit", (lldb::eSearchDepthCompUnit))}, + {SWIG_LUA_CONSTTAB_INT("eSearchDepthFunction", (lldb::eSearchDepthFunction))}, + {SWIG_LUA_CONSTTAB_INT("eSearchDepthBlock", (lldb::eSearchDepthBlock))}, + {SWIG_LUA_CONSTTAB_INT("eSearchDepthAddress", (lldb::eSearchDepthAddress))}, + {SWIG_LUA_CONSTTAB_INT("kLastSearchDepthKind", (lldb::kLastSearchDepthKind))}, + {SWIG_LUA_CONSTTAB_INT("eConnectionStatusSuccess", (lldb::eConnectionStatusSuccess))}, + {SWIG_LUA_CONSTTAB_INT("eConnectionStatusEndOfFile", (lldb::eConnectionStatusEndOfFile))}, + {SWIG_LUA_CONSTTAB_INT("eConnectionStatusError", (lldb::eConnectionStatusError))}, + {SWIG_LUA_CONSTTAB_INT("eConnectionStatusTimedOut", (lldb::eConnectionStatusTimedOut))}, + {SWIG_LUA_CONSTTAB_INT("eConnectionStatusNoConnection", (lldb::eConnectionStatusNoConnection))}, + {SWIG_LUA_CONSTTAB_INT("eConnectionStatusLostConnection", (lldb::eConnectionStatusLostConnection))}, + {SWIG_LUA_CONSTTAB_INT("eConnectionStatusInterrupted", (lldb::eConnectionStatusInterrupted))}, + {SWIG_LUA_CONSTTAB_INT("eErrorTypeInvalid", (lldb::eErrorTypeInvalid))}, + {SWIG_LUA_CONSTTAB_INT("eErrorTypeGeneric", (lldb::eErrorTypeGeneric))}, + {SWIG_LUA_CONSTTAB_INT("eErrorTypeMachKernel", (lldb::eErrorTypeMachKernel))}, + {SWIG_LUA_CONSTTAB_INT("eErrorTypePOSIX", (lldb::eErrorTypePOSIX))}, + {SWIG_LUA_CONSTTAB_INT("eErrorTypeExpression", (lldb::eErrorTypeExpression))}, + {SWIG_LUA_CONSTTAB_INT("eErrorTypeWin32", (lldb::eErrorTypeWin32))}, + {SWIG_LUA_CONSTTAB_INT("eValueTypeInvalid", (lldb::eValueTypeInvalid))}, + {SWIG_LUA_CONSTTAB_INT("eValueTypeVariableGlobal", (lldb::eValueTypeVariableGlobal))}, + {SWIG_LUA_CONSTTAB_INT("eValueTypeVariableStatic", (lldb::eValueTypeVariableStatic))}, + {SWIG_LUA_CONSTTAB_INT("eValueTypeVariableArgument", (lldb::eValueTypeVariableArgument))}, + {SWIG_LUA_CONSTTAB_INT("eValueTypeVariableLocal", (lldb::eValueTypeVariableLocal))}, + {SWIG_LUA_CONSTTAB_INT("eValueTypeRegister", (lldb::eValueTypeRegister))}, + {SWIG_LUA_CONSTTAB_INT("eValueTypeRegisterSet", (lldb::eValueTypeRegisterSet))}, + {SWIG_LUA_CONSTTAB_INT("eValueTypeConstResult", (lldb::eValueTypeConstResult))}, + {SWIG_LUA_CONSTTAB_INT("eValueTypeVariableThreadLocal", (lldb::eValueTypeVariableThreadLocal))}, + {SWIG_LUA_CONSTTAB_INT("eValueTypeVTable", (lldb::eValueTypeVTable))}, + {SWIG_LUA_CONSTTAB_INT("eValueTypeVTableEntry", (lldb::eValueTypeVTableEntry))}, + {SWIG_LUA_CONSTTAB_INT("eInputReaderGranularityInvalid", (lldb::eInputReaderGranularityInvalid))}, + {SWIG_LUA_CONSTTAB_INT("eInputReaderGranularityByte", (lldb::eInputReaderGranularityByte))}, + {SWIG_LUA_CONSTTAB_INT("eInputReaderGranularityWord", (lldb::eInputReaderGranularityWord))}, + {SWIG_LUA_CONSTTAB_INT("eInputReaderGranularityLine", (lldb::eInputReaderGranularityLine))}, + {SWIG_LUA_CONSTTAB_INT("eInputReaderGranularityAll", (lldb::eInputReaderGranularityAll))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolContextTarget", (lldb::eSymbolContextTarget))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolContextModule", (lldb::eSymbolContextModule))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolContextCompUnit", (lldb::eSymbolContextCompUnit))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolContextFunction", (lldb::eSymbolContextFunction))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolContextBlock", (lldb::eSymbolContextBlock))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolContextLineEntry", (lldb::eSymbolContextLineEntry))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolContextSymbol", (lldb::eSymbolContextSymbol))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolContextEverything", (lldb::eSymbolContextEverything))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolContextVariable", (lldb::eSymbolContextVariable))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolContextLastItem", (lldb::eSymbolContextLastItem))}, + {SWIG_LUA_CONSTTAB_INT("ePermissionsWritable", (lldb::ePermissionsWritable))}, + {SWIG_LUA_CONSTTAB_INT("ePermissionsReadable", (lldb::ePermissionsReadable))}, + {SWIG_LUA_CONSTTAB_INT("ePermissionsExecutable", (lldb::ePermissionsExecutable))}, + {SWIG_LUA_CONSTTAB_INT("eInputReaderActivate", (lldb::eInputReaderActivate))}, + {SWIG_LUA_CONSTTAB_INT("eInputReaderAsynchronousOutputWritten", (lldb::eInputReaderAsynchronousOutputWritten))}, + {SWIG_LUA_CONSTTAB_INT("eInputReaderReactivate", (lldb::eInputReaderReactivate))}, + {SWIG_LUA_CONSTTAB_INT("eInputReaderDeactivate", (lldb::eInputReaderDeactivate))}, + {SWIG_LUA_CONSTTAB_INT("eInputReaderGotToken", (lldb::eInputReaderGotToken))}, + {SWIG_LUA_CONSTTAB_INT("eInputReaderInterrupt", (lldb::eInputReaderInterrupt))}, + {SWIG_LUA_CONSTTAB_INT("eInputReaderEndOfFile", (lldb::eInputReaderEndOfFile))}, + {SWIG_LUA_CONSTTAB_INT("eInputReaderDone", (lldb::eInputReaderDone))}, + {SWIG_LUA_CONSTTAB_INT("eBreakpointEventTypeInvalidType", (lldb::eBreakpointEventTypeInvalidType))}, + {SWIG_LUA_CONSTTAB_INT("eBreakpointEventTypeAdded", (lldb::eBreakpointEventTypeAdded))}, + {SWIG_LUA_CONSTTAB_INT("eBreakpointEventTypeRemoved", (lldb::eBreakpointEventTypeRemoved))}, + {SWIG_LUA_CONSTTAB_INT("eBreakpointEventTypeLocationsAdded", (lldb::eBreakpointEventTypeLocationsAdded))}, + {SWIG_LUA_CONSTTAB_INT("eBreakpointEventTypeLocationsRemoved", (lldb::eBreakpointEventTypeLocationsRemoved))}, + {SWIG_LUA_CONSTTAB_INT("eBreakpointEventTypeLocationsResolved", (lldb::eBreakpointEventTypeLocationsResolved))}, + {SWIG_LUA_CONSTTAB_INT("eBreakpointEventTypeEnabled", (lldb::eBreakpointEventTypeEnabled))}, + {SWIG_LUA_CONSTTAB_INT("eBreakpointEventTypeDisabled", (lldb::eBreakpointEventTypeDisabled))}, + {SWIG_LUA_CONSTTAB_INT("eBreakpointEventTypeCommandChanged", (lldb::eBreakpointEventTypeCommandChanged))}, + {SWIG_LUA_CONSTTAB_INT("eBreakpointEventTypeConditionChanged", (lldb::eBreakpointEventTypeConditionChanged))}, + {SWIG_LUA_CONSTTAB_INT("eBreakpointEventTypeIgnoreChanged", (lldb::eBreakpointEventTypeIgnoreChanged))}, + {SWIG_LUA_CONSTTAB_INT("eBreakpointEventTypeThreadChanged", (lldb::eBreakpointEventTypeThreadChanged))}, + {SWIG_LUA_CONSTTAB_INT("eBreakpointEventTypeAutoContinueChanged", (lldb::eBreakpointEventTypeAutoContinueChanged))}, + {SWIG_LUA_CONSTTAB_INT("eWatchpointEventTypeInvalidType", (lldb::eWatchpointEventTypeInvalidType))}, + {SWIG_LUA_CONSTTAB_INT("eWatchpointEventTypeAdded", (lldb::eWatchpointEventTypeAdded))}, + {SWIG_LUA_CONSTTAB_INT("eWatchpointEventTypeRemoved", (lldb::eWatchpointEventTypeRemoved))}, + {SWIG_LUA_CONSTTAB_INT("eWatchpointEventTypeEnabled", (lldb::eWatchpointEventTypeEnabled))}, + {SWIG_LUA_CONSTTAB_INT("eWatchpointEventTypeDisabled", (lldb::eWatchpointEventTypeDisabled))}, + {SWIG_LUA_CONSTTAB_INT("eWatchpointEventTypeCommandChanged", (lldb::eWatchpointEventTypeCommandChanged))}, + {SWIG_LUA_CONSTTAB_INT("eWatchpointEventTypeConditionChanged", (lldb::eWatchpointEventTypeConditionChanged))}, + {SWIG_LUA_CONSTTAB_INT("eWatchpointEventTypeIgnoreChanged", (lldb::eWatchpointEventTypeIgnoreChanged))}, + {SWIG_LUA_CONSTTAB_INT("eWatchpointEventTypeThreadChanged", (lldb::eWatchpointEventTypeThreadChanged))}, + {SWIG_LUA_CONSTTAB_INT("eWatchpointEventTypeTypeChanged", (lldb::eWatchpointEventTypeTypeChanged))}, + {SWIG_LUA_CONSTTAB_INT("eWatchpointWriteTypeDisabled", (lldb::eWatchpointWriteTypeDisabled))}, + {SWIG_LUA_CONSTTAB_INT("eWatchpointWriteTypeAlways", (lldb::eWatchpointWriteTypeAlways))}, + {SWIG_LUA_CONSTTAB_INT("eWatchpointWriteTypeOnModify", (lldb::eWatchpointWriteTypeOnModify))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeUnknown", (lldb::eLanguageTypeUnknown))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeC89", (lldb::eLanguageTypeC89))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeC", (lldb::eLanguageTypeC))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeAda83", (lldb::eLanguageTypeAda83))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeC_plus_plus", (lldb::eLanguageTypeC_plus_plus))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeCobol74", (lldb::eLanguageTypeCobol74))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeCobol85", (lldb::eLanguageTypeCobol85))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeFortran77", (lldb::eLanguageTypeFortran77))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeFortran90", (lldb::eLanguageTypeFortran90))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypePascal83", (lldb::eLanguageTypePascal83))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeModula2", (lldb::eLanguageTypeModula2))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeJava", (lldb::eLanguageTypeJava))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeC99", (lldb::eLanguageTypeC99))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeAda95", (lldb::eLanguageTypeAda95))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeFortran95", (lldb::eLanguageTypeFortran95))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypePLI", (lldb::eLanguageTypePLI))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeObjC", (lldb::eLanguageTypeObjC))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeObjC_plus_plus", (lldb::eLanguageTypeObjC_plus_plus))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeUPC", (lldb::eLanguageTypeUPC))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeD", (lldb::eLanguageTypeD))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypePython", (lldb::eLanguageTypePython))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeOpenCL", (lldb::eLanguageTypeOpenCL))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeGo", (lldb::eLanguageTypeGo))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeModula3", (lldb::eLanguageTypeModula3))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeHaskell", (lldb::eLanguageTypeHaskell))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeC_plus_plus_03", (lldb::eLanguageTypeC_plus_plus_03))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeC_plus_plus_11", (lldb::eLanguageTypeC_plus_plus_11))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeOCaml", (lldb::eLanguageTypeOCaml))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeRust", (lldb::eLanguageTypeRust))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeC11", (lldb::eLanguageTypeC11))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeSwift", (lldb::eLanguageTypeSwift))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeJulia", (lldb::eLanguageTypeJulia))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeDylan", (lldb::eLanguageTypeDylan))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeC_plus_plus_14", (lldb::eLanguageTypeC_plus_plus_14))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeFortran03", (lldb::eLanguageTypeFortran03))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeFortran08", (lldb::eLanguageTypeFortran08))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeRenderScript", (lldb::eLanguageTypeRenderScript))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeBLISS", (lldb::eLanguageTypeBLISS))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeKotlin", (lldb::eLanguageTypeKotlin))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeZig", (lldb::eLanguageTypeZig))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeCrystal", (lldb::eLanguageTypeCrystal))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeC_plus_plus_17", (lldb::eLanguageTypeC_plus_plus_17))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeC_plus_plus_20", (lldb::eLanguageTypeC_plus_plus_20))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeC17", (lldb::eLanguageTypeC17))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeFortran18", (lldb::eLanguageTypeFortran18))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeAda2005", (lldb::eLanguageTypeAda2005))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeAda2012", (lldb::eLanguageTypeAda2012))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeHIP", (lldb::eLanguageTypeHIP))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeAssembly", (lldb::eLanguageTypeAssembly))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeC_sharp", (lldb::eLanguageTypeC_sharp))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeMojo", (lldb::eLanguageTypeMojo))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageTypeMipsAssembler", (lldb::eLanguageTypeMipsAssembler))}, + {SWIG_LUA_CONSTTAB_INT("eNumLanguageTypes", (lldb::eNumLanguageTypes))}, + {SWIG_LUA_CONSTTAB_INT("eInstrumentationRuntimeTypeAddressSanitizer", (lldb::eInstrumentationRuntimeTypeAddressSanitizer))}, + {SWIG_LUA_CONSTTAB_INT("eInstrumentationRuntimeTypeThreadSanitizer", (lldb::eInstrumentationRuntimeTypeThreadSanitizer))}, + {SWIG_LUA_CONSTTAB_INT("eInstrumentationRuntimeTypeUndefinedBehaviorSanitizer", (lldb::eInstrumentationRuntimeTypeUndefinedBehaviorSanitizer))}, + {SWIG_LUA_CONSTTAB_INT("eInstrumentationRuntimeTypeMainThreadChecker", (lldb::eInstrumentationRuntimeTypeMainThreadChecker))}, + {SWIG_LUA_CONSTTAB_INT("eInstrumentationRuntimeTypeSwiftRuntimeReporting", (lldb::eInstrumentationRuntimeTypeSwiftRuntimeReporting))}, + {SWIG_LUA_CONSTTAB_INT("eInstrumentationRuntimeTypeLibsanitizersAsan", (lldb::eInstrumentationRuntimeTypeLibsanitizersAsan))}, + {SWIG_LUA_CONSTTAB_INT("eNumInstrumentationRuntimeTypes", (lldb::eNumInstrumentationRuntimeTypes))}, + {SWIG_LUA_CONSTTAB_INT("eNoDynamicValues", (lldb::eNoDynamicValues))}, + {SWIG_LUA_CONSTTAB_INT("eDynamicCanRunTarget", (lldb::eDynamicCanRunTarget))}, + {SWIG_LUA_CONSTTAB_INT("eDynamicDontRunTarget", (lldb::eDynamicDontRunTarget))}, + {SWIG_LUA_CONSTTAB_INT("eStopShowColumnAnsiOrCaret", (lldb::eStopShowColumnAnsiOrCaret))}, + {SWIG_LUA_CONSTTAB_INT("eStopShowColumnAnsi", (lldb::eStopShowColumnAnsi))}, + {SWIG_LUA_CONSTTAB_INT("eStopShowColumnCaret", (lldb::eStopShowColumnCaret))}, + {SWIG_LUA_CONSTTAB_INT("eStopShowColumnNone", (lldb::eStopShowColumnNone))}, + {SWIG_LUA_CONSTTAB_INT("eAccessNone", (lldb::eAccessNone))}, + {SWIG_LUA_CONSTTAB_INT("eAccessPublic", (lldb::eAccessPublic))}, + {SWIG_LUA_CONSTTAB_INT("eAccessPrivate", (lldb::eAccessPrivate))}, + {SWIG_LUA_CONSTTAB_INT("eAccessProtected", (lldb::eAccessProtected))}, + {SWIG_LUA_CONSTTAB_INT("eAccessPackage", (lldb::eAccessPackage))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeAddress", (lldb::eArgTypeAddress))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeAddressOrExpression", (lldb::eArgTypeAddressOrExpression))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeAliasName", (lldb::eArgTypeAliasName))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeAliasOptions", (lldb::eArgTypeAliasOptions))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeArchitecture", (lldb::eArgTypeArchitecture))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeBoolean", (lldb::eArgTypeBoolean))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeBreakpointID", (lldb::eArgTypeBreakpointID))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeBreakpointIDRange", (lldb::eArgTypeBreakpointIDRange))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeBreakpointName", (lldb::eArgTypeBreakpointName))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeByteSize", (lldb::eArgTypeByteSize))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeClassName", (lldb::eArgTypeClassName))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeCommandName", (lldb::eArgTypeCommandName))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeCount", (lldb::eArgTypeCount))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeDescriptionVerbosity", (lldb::eArgTypeDescriptionVerbosity))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeDirectoryName", (lldb::eArgTypeDirectoryName))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeDisassemblyFlavor", (lldb::eArgTypeDisassemblyFlavor))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeEndAddress", (lldb::eArgTypeEndAddress))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeExpression", (lldb::eArgTypeExpression))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeExpressionPath", (lldb::eArgTypeExpressionPath))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeExprFormat", (lldb::eArgTypeExprFormat))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeFileLineColumn", (lldb::eArgTypeFileLineColumn))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeFilename", (lldb::eArgTypeFilename))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeFormat", (lldb::eArgTypeFormat))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeFrameIndex", (lldb::eArgTypeFrameIndex))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeFullName", (lldb::eArgTypeFullName))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeFunctionName", (lldb::eArgTypeFunctionName))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeFunctionOrSymbol", (lldb::eArgTypeFunctionOrSymbol))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeGDBFormat", (lldb::eArgTypeGDBFormat))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeHelpText", (lldb::eArgTypeHelpText))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeIndex", (lldb::eArgTypeIndex))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeLanguage", (lldb::eArgTypeLanguage))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeLineNum", (lldb::eArgTypeLineNum))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeLogCategory", (lldb::eArgTypeLogCategory))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeLogChannel", (lldb::eArgTypeLogChannel))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeMethod", (lldb::eArgTypeMethod))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeName", (lldb::eArgTypeName))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeNewPathPrefix", (lldb::eArgTypeNewPathPrefix))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeNumLines", (lldb::eArgTypeNumLines))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeNumberPerLine", (lldb::eArgTypeNumberPerLine))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeOffset", (lldb::eArgTypeOffset))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeOldPathPrefix", (lldb::eArgTypeOldPathPrefix))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeOneLiner", (lldb::eArgTypeOneLiner))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypePath", (lldb::eArgTypePath))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypePermissionsNumber", (lldb::eArgTypePermissionsNumber))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypePermissionsString", (lldb::eArgTypePermissionsString))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypePid", (lldb::eArgTypePid))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypePlugin", (lldb::eArgTypePlugin))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeProcessName", (lldb::eArgTypeProcessName))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypePythonClass", (lldb::eArgTypePythonClass))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypePythonFunction", (lldb::eArgTypePythonFunction))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypePythonScript", (lldb::eArgTypePythonScript))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeQueueName", (lldb::eArgTypeQueueName))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeRegisterName", (lldb::eArgTypeRegisterName))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeRegularExpression", (lldb::eArgTypeRegularExpression))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeRunArgs", (lldb::eArgTypeRunArgs))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeRunMode", (lldb::eArgTypeRunMode))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeScriptedCommandSynchronicity", (lldb::eArgTypeScriptedCommandSynchronicity))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeScriptLang", (lldb::eArgTypeScriptLang))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeSearchWord", (lldb::eArgTypeSearchWord))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeSelector", (lldb::eArgTypeSelector))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeSettingIndex", (lldb::eArgTypeSettingIndex))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeSettingKey", (lldb::eArgTypeSettingKey))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeSettingPrefix", (lldb::eArgTypeSettingPrefix))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeSettingVariableName", (lldb::eArgTypeSettingVariableName))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeShlibName", (lldb::eArgTypeShlibName))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeSourceFile", (lldb::eArgTypeSourceFile))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeSortOrder", (lldb::eArgTypeSortOrder))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeStartAddress", (lldb::eArgTypeStartAddress))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeSummaryString", (lldb::eArgTypeSummaryString))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeSymbol", (lldb::eArgTypeSymbol))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeThreadID", (lldb::eArgTypeThreadID))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeThreadIndex", (lldb::eArgTypeThreadIndex))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeThreadName", (lldb::eArgTypeThreadName))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeTypeName", (lldb::eArgTypeTypeName))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeUnsignedInteger", (lldb::eArgTypeUnsignedInteger))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeUnixSignal", (lldb::eArgTypeUnixSignal))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeVarName", (lldb::eArgTypeVarName))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeValue", (lldb::eArgTypeValue))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeWidth", (lldb::eArgTypeWidth))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeNone", (lldb::eArgTypeNone))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypePlatform", (lldb::eArgTypePlatform))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeWatchpointID", (lldb::eArgTypeWatchpointID))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeWatchpointIDRange", (lldb::eArgTypeWatchpointIDRange))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeWatchType", (lldb::eArgTypeWatchType))}, + {SWIG_LUA_CONSTTAB_INT("eArgRawInput", (lldb::eArgRawInput))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeCommand", (lldb::eArgTypeCommand))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeColumnNum", (lldb::eArgTypeColumnNum))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeModuleUUID", (lldb::eArgTypeModuleUUID))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeSaveCoreStyle", (lldb::eArgTypeSaveCoreStyle))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeLogHandler", (lldb::eArgTypeLogHandler))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeSEDStylePair", (lldb::eArgTypeSEDStylePair))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeRecognizerID", (lldb::eArgTypeRecognizerID))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeConnectURL", (lldb::eArgTypeConnectURL))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeTargetID", (lldb::eArgTypeTargetID))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeStopHookID", (lldb::eArgTypeStopHookID))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeCompletionType", (lldb::eArgTypeCompletionType))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeRemotePath", (lldb::eArgTypeRemotePath))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeRemoteFilename", (lldb::eArgTypeRemoteFilename))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeModule", (lldb::eArgTypeModule))}, + {SWIG_LUA_CONSTTAB_INT("eArgTypeLastArg", (lldb::eArgTypeLastArg))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolTypeAny", (lldb::eSymbolTypeAny))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolTypeInvalid", (lldb::eSymbolTypeInvalid))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolTypeAbsolute", (lldb::eSymbolTypeAbsolute))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolTypeCode", (lldb::eSymbolTypeCode))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolTypeResolver", (lldb::eSymbolTypeResolver))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolTypeData", (lldb::eSymbolTypeData))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolTypeTrampoline", (lldb::eSymbolTypeTrampoline))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolTypeRuntime", (lldb::eSymbolTypeRuntime))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolTypeException", (lldb::eSymbolTypeException))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolTypeSourceFile", (lldb::eSymbolTypeSourceFile))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolTypeHeaderFile", (lldb::eSymbolTypeHeaderFile))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolTypeObjectFile", (lldb::eSymbolTypeObjectFile))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolTypeCommonBlock", (lldb::eSymbolTypeCommonBlock))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolTypeBlock", (lldb::eSymbolTypeBlock))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolTypeLocal", (lldb::eSymbolTypeLocal))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolTypeParam", (lldb::eSymbolTypeParam))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolTypeVariable", (lldb::eSymbolTypeVariable))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolTypeVariableType", (lldb::eSymbolTypeVariableType))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolTypeLineEntry", (lldb::eSymbolTypeLineEntry))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolTypeLineHeader", (lldb::eSymbolTypeLineHeader))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolTypeScopeBegin", (lldb::eSymbolTypeScopeBegin))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolTypeScopeEnd", (lldb::eSymbolTypeScopeEnd))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolTypeAdditional", (lldb::eSymbolTypeAdditional))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolTypeCompiler", (lldb::eSymbolTypeCompiler))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolTypeInstrumentation", (lldb::eSymbolTypeInstrumentation))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolTypeUndefined", (lldb::eSymbolTypeUndefined))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolTypeObjCClass", (lldb::eSymbolTypeObjCClass))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolTypeObjCMetaClass", (lldb::eSymbolTypeObjCMetaClass))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolTypeObjCIVar", (lldb::eSymbolTypeObjCIVar))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolTypeReExported", (lldb::eSymbolTypeReExported))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeInvalid", (lldb::eSectionTypeInvalid))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeCode", (lldb::eSectionTypeCode))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeContainer", (lldb::eSectionTypeContainer))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeData", (lldb::eSectionTypeData))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDataCString", (lldb::eSectionTypeDataCString))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDataCStringPointers", (lldb::eSectionTypeDataCStringPointers))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDataSymbolAddress", (lldb::eSectionTypeDataSymbolAddress))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeData4", (lldb::eSectionTypeData4))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeData8", (lldb::eSectionTypeData8))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeData16", (lldb::eSectionTypeData16))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDataPointers", (lldb::eSectionTypeDataPointers))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDebug", (lldb::eSectionTypeDebug))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeZeroFill", (lldb::eSectionTypeZeroFill))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDataObjCMessageRefs", (lldb::eSectionTypeDataObjCMessageRefs))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDataObjCCFStrings", (lldb::eSectionTypeDataObjCCFStrings))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugAbbrev", (lldb::eSectionTypeDWARFDebugAbbrev))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugAddr", (lldb::eSectionTypeDWARFDebugAddr))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugAranges", (lldb::eSectionTypeDWARFDebugAranges))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugCuIndex", (lldb::eSectionTypeDWARFDebugCuIndex))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugFrame", (lldb::eSectionTypeDWARFDebugFrame))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugInfo", (lldb::eSectionTypeDWARFDebugInfo))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugLine", (lldb::eSectionTypeDWARFDebugLine))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugLoc", (lldb::eSectionTypeDWARFDebugLoc))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugMacInfo", (lldb::eSectionTypeDWARFDebugMacInfo))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugMacro", (lldb::eSectionTypeDWARFDebugMacro))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugPubNames", (lldb::eSectionTypeDWARFDebugPubNames))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugPubTypes", (lldb::eSectionTypeDWARFDebugPubTypes))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugRanges", (lldb::eSectionTypeDWARFDebugRanges))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugStr", (lldb::eSectionTypeDWARFDebugStr))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugStrOffsets", (lldb::eSectionTypeDWARFDebugStrOffsets))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFAppleNames", (lldb::eSectionTypeDWARFAppleNames))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFAppleTypes", (lldb::eSectionTypeDWARFAppleTypes))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFAppleNamespaces", (lldb::eSectionTypeDWARFAppleNamespaces))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFAppleObjC", (lldb::eSectionTypeDWARFAppleObjC))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeELFSymbolTable", (lldb::eSectionTypeELFSymbolTable))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeELFDynamicSymbols", (lldb::eSectionTypeELFDynamicSymbols))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeELFRelocationEntries", (lldb::eSectionTypeELFRelocationEntries))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeELFDynamicLinkInfo", (lldb::eSectionTypeELFDynamicLinkInfo))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeEHFrame", (lldb::eSectionTypeEHFrame))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeARMexidx", (lldb::eSectionTypeARMexidx))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeARMextab", (lldb::eSectionTypeARMextab))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeCompactUnwind", (lldb::eSectionTypeCompactUnwind))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeGoSymtab", (lldb::eSectionTypeGoSymtab))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeAbsoluteAddress", (lldb::eSectionTypeAbsoluteAddress))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFGNUDebugAltLink", (lldb::eSectionTypeDWARFGNUDebugAltLink))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugTypes", (lldb::eSectionTypeDWARFDebugTypes))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugNames", (lldb::eSectionTypeDWARFDebugNames))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeOther", (lldb::eSectionTypeOther))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugLineStr", (lldb::eSectionTypeDWARFDebugLineStr))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugRngLists", (lldb::eSectionTypeDWARFDebugRngLists))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugLocLists", (lldb::eSectionTypeDWARFDebugLocLists))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugAbbrevDwo", (lldb::eSectionTypeDWARFDebugAbbrevDwo))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugInfoDwo", (lldb::eSectionTypeDWARFDebugInfoDwo))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugStrDwo", (lldb::eSectionTypeDWARFDebugStrDwo))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugStrOffsetsDwo", (lldb::eSectionTypeDWARFDebugStrOffsetsDwo))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugTypesDwo", (lldb::eSectionTypeDWARFDebugTypesDwo))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugRngListsDwo", (lldb::eSectionTypeDWARFDebugRngListsDwo))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugLocDwo", (lldb::eSectionTypeDWARFDebugLocDwo))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugLocListsDwo", (lldb::eSectionTypeDWARFDebugLocListsDwo))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeDWARFDebugTuIndex", (lldb::eSectionTypeDWARFDebugTuIndex))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeCTF", (lldb::eSectionTypeCTF))}, + {SWIG_LUA_CONSTTAB_INT("eSectionTypeSwiftModules", (lldb::eSectionTypeSwiftModules))}, + {SWIG_LUA_CONSTTAB_INT("eEmulateInstructionOptionNone", (lldb::eEmulateInstructionOptionNone))}, + {SWIG_LUA_CONSTTAB_INT("eEmulateInstructionOptionAutoAdvancePC", (lldb::eEmulateInstructionOptionAutoAdvancePC))}, + {SWIG_LUA_CONSTTAB_INT("eEmulateInstructionOptionIgnoreConditions", (lldb::eEmulateInstructionOptionIgnoreConditions))}, + {SWIG_LUA_CONSTTAB_INT("eFunctionNameTypeNone", (lldb::eFunctionNameTypeNone))}, + {SWIG_LUA_CONSTTAB_INT("eFunctionNameTypeAuto", (lldb::eFunctionNameTypeAuto))}, + {SWIG_LUA_CONSTTAB_INT("eFunctionNameTypeFull", (lldb::eFunctionNameTypeFull))}, + {SWIG_LUA_CONSTTAB_INT("eFunctionNameTypeBase", (lldb::eFunctionNameTypeBase))}, + {SWIG_LUA_CONSTTAB_INT("eFunctionNameTypeMethod", (lldb::eFunctionNameTypeMethod))}, + {SWIG_LUA_CONSTTAB_INT("eFunctionNameTypeSelector", (lldb::eFunctionNameTypeSelector))}, + {SWIG_LUA_CONSTTAB_INT("eFunctionNameTypeAny", (lldb::eFunctionNameTypeAny))}, + {SWIG_LUA_CONSTTAB_INT("eBasicTypeInvalid", (lldb::eBasicTypeInvalid))}, + {SWIG_LUA_CONSTTAB_INT("eBasicTypeVoid", (lldb::eBasicTypeVoid))}, + {SWIG_LUA_CONSTTAB_INT("eBasicTypeChar", (lldb::eBasicTypeChar))}, + {SWIG_LUA_CONSTTAB_INT("eBasicTypeSignedChar", (lldb::eBasicTypeSignedChar))}, + {SWIG_LUA_CONSTTAB_INT("eBasicTypeUnsignedChar", (lldb::eBasicTypeUnsignedChar))}, + {SWIG_LUA_CONSTTAB_INT("eBasicTypeWChar", (lldb::eBasicTypeWChar))}, + {SWIG_LUA_CONSTTAB_INT("eBasicTypeSignedWChar", (lldb::eBasicTypeSignedWChar))}, + {SWIG_LUA_CONSTTAB_INT("eBasicTypeUnsignedWChar", (lldb::eBasicTypeUnsignedWChar))}, + {SWIG_LUA_CONSTTAB_INT("eBasicTypeChar16", (lldb::eBasicTypeChar16))}, + {SWIG_LUA_CONSTTAB_INT("eBasicTypeChar32", (lldb::eBasicTypeChar32))}, + {SWIG_LUA_CONSTTAB_INT("eBasicTypeChar8", (lldb::eBasicTypeChar8))}, + {SWIG_LUA_CONSTTAB_INT("eBasicTypeShort", (lldb::eBasicTypeShort))}, + {SWIG_LUA_CONSTTAB_INT("eBasicTypeUnsignedShort", (lldb::eBasicTypeUnsignedShort))}, + {SWIG_LUA_CONSTTAB_INT("eBasicTypeInt", (lldb::eBasicTypeInt))}, + {SWIG_LUA_CONSTTAB_INT("eBasicTypeUnsignedInt", (lldb::eBasicTypeUnsignedInt))}, + {SWIG_LUA_CONSTTAB_INT("eBasicTypeLong", (lldb::eBasicTypeLong))}, + {SWIG_LUA_CONSTTAB_INT("eBasicTypeUnsignedLong", (lldb::eBasicTypeUnsignedLong))}, + {SWIG_LUA_CONSTTAB_INT("eBasicTypeLongLong", (lldb::eBasicTypeLongLong))}, + {SWIG_LUA_CONSTTAB_INT("eBasicTypeUnsignedLongLong", (lldb::eBasicTypeUnsignedLongLong))}, + {SWIG_LUA_CONSTTAB_INT("eBasicTypeInt128", (lldb::eBasicTypeInt128))}, + {SWIG_LUA_CONSTTAB_INT("eBasicTypeUnsignedInt128", (lldb::eBasicTypeUnsignedInt128))}, + {SWIG_LUA_CONSTTAB_INT("eBasicTypeBool", (lldb::eBasicTypeBool))}, + {SWIG_LUA_CONSTTAB_INT("eBasicTypeHalf", (lldb::eBasicTypeHalf))}, + {SWIG_LUA_CONSTTAB_INT("eBasicTypeFloat", (lldb::eBasicTypeFloat))}, + {SWIG_LUA_CONSTTAB_INT("eBasicTypeDouble", (lldb::eBasicTypeDouble))}, + {SWIG_LUA_CONSTTAB_INT("eBasicTypeLongDouble", (lldb::eBasicTypeLongDouble))}, + {SWIG_LUA_CONSTTAB_INT("eBasicTypeFloatComplex", (lldb::eBasicTypeFloatComplex))}, + {SWIG_LUA_CONSTTAB_INT("eBasicTypeDoubleComplex", (lldb::eBasicTypeDoubleComplex))}, + {SWIG_LUA_CONSTTAB_INT("eBasicTypeLongDoubleComplex", (lldb::eBasicTypeLongDoubleComplex))}, + {SWIG_LUA_CONSTTAB_INT("eBasicTypeObjCID", (lldb::eBasicTypeObjCID))}, + {SWIG_LUA_CONSTTAB_INT("eBasicTypeObjCClass", (lldb::eBasicTypeObjCClass))}, + {SWIG_LUA_CONSTTAB_INT("eBasicTypeObjCSel", (lldb::eBasicTypeObjCSel))}, + {SWIG_LUA_CONSTTAB_INT("eBasicTypeNullPtr", (lldb::eBasicTypeNullPtr))}, + {SWIG_LUA_CONSTTAB_INT("eBasicTypeOther", (lldb::eBasicTypeOther))}, + {SWIG_LUA_CONSTTAB_INT("eTraceTypeNone", (lldb::eTraceTypeNone))}, + {SWIG_LUA_CONSTTAB_INT("eTraceTypeProcessorTrace", (lldb::eTraceTypeProcessorTrace))}, + {SWIG_LUA_CONSTTAB_INT("eStructuredDataTypeInvalid", (lldb::eStructuredDataTypeInvalid))}, + {SWIG_LUA_CONSTTAB_INT("eStructuredDataTypeNull", (lldb::eStructuredDataTypeNull))}, + {SWIG_LUA_CONSTTAB_INT("eStructuredDataTypeGeneric", (lldb::eStructuredDataTypeGeneric))}, + {SWIG_LUA_CONSTTAB_INT("eStructuredDataTypeArray", (lldb::eStructuredDataTypeArray))}, + {SWIG_LUA_CONSTTAB_INT("eStructuredDataTypeInteger", (lldb::eStructuredDataTypeInteger))}, + {SWIG_LUA_CONSTTAB_INT("eStructuredDataTypeFloat", (lldb::eStructuredDataTypeFloat))}, + {SWIG_LUA_CONSTTAB_INT("eStructuredDataTypeBoolean", (lldb::eStructuredDataTypeBoolean))}, + {SWIG_LUA_CONSTTAB_INT("eStructuredDataTypeString", (lldb::eStructuredDataTypeString))}, + {SWIG_LUA_CONSTTAB_INT("eStructuredDataTypeDictionary", (lldb::eStructuredDataTypeDictionary))}, + {SWIG_LUA_CONSTTAB_INT("eStructuredDataTypeSignedInteger", (lldb::eStructuredDataTypeSignedInteger))}, + {SWIG_LUA_CONSTTAB_INT("eStructuredDataTypeUnsignedInteger", (lldb::eStructuredDataTypeUnsignedInteger))}, + {SWIG_LUA_CONSTTAB_INT("eTypeClassInvalid", (lldb::eTypeClassInvalid))}, + {SWIG_LUA_CONSTTAB_INT("eTypeClassArray", (lldb::eTypeClassArray))}, + {SWIG_LUA_CONSTTAB_INT("eTypeClassBlockPointer", (lldb::eTypeClassBlockPointer))}, + {SWIG_LUA_CONSTTAB_INT("eTypeClassBuiltin", (lldb::eTypeClassBuiltin))}, + {SWIG_LUA_CONSTTAB_INT("eTypeClassClass", (lldb::eTypeClassClass))}, + {SWIG_LUA_CONSTTAB_INT("eTypeClassComplexFloat", (lldb::eTypeClassComplexFloat))}, + {SWIG_LUA_CONSTTAB_INT("eTypeClassComplexInteger", (lldb::eTypeClassComplexInteger))}, + {SWIG_LUA_CONSTTAB_INT("eTypeClassEnumeration", (lldb::eTypeClassEnumeration))}, + {SWIG_LUA_CONSTTAB_INT("eTypeClassFunction", (lldb::eTypeClassFunction))}, + {SWIG_LUA_CONSTTAB_INT("eTypeClassMemberPointer", (lldb::eTypeClassMemberPointer))}, + {SWIG_LUA_CONSTTAB_INT("eTypeClassObjCObject", (lldb::eTypeClassObjCObject))}, + {SWIG_LUA_CONSTTAB_INT("eTypeClassObjCInterface", (lldb::eTypeClassObjCInterface))}, + {SWIG_LUA_CONSTTAB_INT("eTypeClassObjCObjectPointer", (lldb::eTypeClassObjCObjectPointer))}, + {SWIG_LUA_CONSTTAB_INT("eTypeClassPointer", (lldb::eTypeClassPointer))}, + {SWIG_LUA_CONSTTAB_INT("eTypeClassReference", (lldb::eTypeClassReference))}, + {SWIG_LUA_CONSTTAB_INT("eTypeClassStruct", (lldb::eTypeClassStruct))}, + {SWIG_LUA_CONSTTAB_INT("eTypeClassTypedef", (lldb::eTypeClassTypedef))}, + {SWIG_LUA_CONSTTAB_INT("eTypeClassUnion", (lldb::eTypeClassUnion))}, + {SWIG_LUA_CONSTTAB_INT("eTypeClassVector", (lldb::eTypeClassVector))}, + {SWIG_LUA_CONSTTAB_INT("eTypeClassOther", (lldb::eTypeClassOther))}, + {SWIG_LUA_CONSTTAB_INT("eTypeClassAny", (lldb::eTypeClassAny))}, + {SWIG_LUA_CONSTTAB_INT("eTemplateArgumentKindNull", (lldb::eTemplateArgumentKindNull))}, + {SWIG_LUA_CONSTTAB_INT("eTemplateArgumentKindType", (lldb::eTemplateArgumentKindType))}, + {SWIG_LUA_CONSTTAB_INT("eTemplateArgumentKindDeclaration", (lldb::eTemplateArgumentKindDeclaration))}, + {SWIG_LUA_CONSTTAB_INT("eTemplateArgumentKindIntegral", (lldb::eTemplateArgumentKindIntegral))}, + {SWIG_LUA_CONSTTAB_INT("eTemplateArgumentKindTemplate", (lldb::eTemplateArgumentKindTemplate))}, + {SWIG_LUA_CONSTTAB_INT("eTemplateArgumentKindTemplateExpansion", (lldb::eTemplateArgumentKindTemplateExpansion))}, + {SWIG_LUA_CONSTTAB_INT("eTemplateArgumentKindExpression", (lldb::eTemplateArgumentKindExpression))}, + {SWIG_LUA_CONSTTAB_INT("eTemplateArgumentKindPack", (lldb::eTemplateArgumentKindPack))}, + {SWIG_LUA_CONSTTAB_INT("eTemplateArgumentKindNullPtr", (lldb::eTemplateArgumentKindNullPtr))}, + {SWIG_LUA_CONSTTAB_INT("eTemplateArgumentKindStructuralValue", (lldb::eTemplateArgumentKindStructuralValue))}, + {SWIG_LUA_CONSTTAB_INT("eFormatterMatchExact", (lldb::eFormatterMatchExact))}, + {SWIG_LUA_CONSTTAB_INT("eFormatterMatchRegex", (lldb::eFormatterMatchRegex))}, + {SWIG_LUA_CONSTTAB_INT("eFormatterMatchCallback", (lldb::eFormatterMatchCallback))}, + {SWIG_LUA_CONSTTAB_INT("eLastFormatterMatchType", (lldb::eLastFormatterMatchType))}, + {SWIG_LUA_CONSTTAB_INT("eTypeOptionNone", (lldb::eTypeOptionNone))}, + {SWIG_LUA_CONSTTAB_INT("eTypeOptionCascade", (lldb::eTypeOptionCascade))}, + {SWIG_LUA_CONSTTAB_INT("eTypeOptionSkipPointers", (lldb::eTypeOptionSkipPointers))}, + {SWIG_LUA_CONSTTAB_INT("eTypeOptionSkipReferences", (lldb::eTypeOptionSkipReferences))}, + {SWIG_LUA_CONSTTAB_INT("eTypeOptionHideChildren", (lldb::eTypeOptionHideChildren))}, + {SWIG_LUA_CONSTTAB_INT("eTypeOptionHideValue", (lldb::eTypeOptionHideValue))}, + {SWIG_LUA_CONSTTAB_INT("eTypeOptionShowOneLiner", (lldb::eTypeOptionShowOneLiner))}, + {SWIG_LUA_CONSTTAB_INT("eTypeOptionHideNames", (lldb::eTypeOptionHideNames))}, + {SWIG_LUA_CONSTTAB_INT("eTypeOptionNonCacheable", (lldb::eTypeOptionNonCacheable))}, + {SWIG_LUA_CONSTTAB_INT("eTypeOptionHideEmptyAggregates", (lldb::eTypeOptionHideEmptyAggregates))}, + {SWIG_LUA_CONSTTAB_INT("eTypeOptionFrontEndWantsDereference", (lldb::eTypeOptionFrontEndWantsDereference))}, + {SWIG_LUA_CONSTTAB_INT("eFrameCompareInvalid", (lldb::eFrameCompareInvalid))}, + {SWIG_LUA_CONSTTAB_INT("eFrameCompareUnknown", (lldb::eFrameCompareUnknown))}, + {SWIG_LUA_CONSTTAB_INT("eFrameCompareEqual", (lldb::eFrameCompareEqual))}, + {SWIG_LUA_CONSTTAB_INT("eFrameCompareSameParent", (lldb::eFrameCompareSameParent))}, + {SWIG_LUA_CONSTTAB_INT("eFrameCompareYounger", (lldb::eFrameCompareYounger))}, + {SWIG_LUA_CONSTTAB_INT("eFrameCompareOlder", (lldb::eFrameCompareOlder))}, + {SWIG_LUA_CONSTTAB_INT("eFilePermissionsUserRead", (lldb::eFilePermissionsUserRead))}, + {SWIG_LUA_CONSTTAB_INT("eFilePermissionsUserWrite", (lldb::eFilePermissionsUserWrite))}, + {SWIG_LUA_CONSTTAB_INT("eFilePermissionsUserExecute", (lldb::eFilePermissionsUserExecute))}, + {SWIG_LUA_CONSTTAB_INT("eFilePermissionsGroupRead", (lldb::eFilePermissionsGroupRead))}, + {SWIG_LUA_CONSTTAB_INT("eFilePermissionsGroupWrite", (lldb::eFilePermissionsGroupWrite))}, + {SWIG_LUA_CONSTTAB_INT("eFilePermissionsGroupExecute", (lldb::eFilePermissionsGroupExecute))}, + {SWIG_LUA_CONSTTAB_INT("eFilePermissionsWorldRead", (lldb::eFilePermissionsWorldRead))}, + {SWIG_LUA_CONSTTAB_INT("eFilePermissionsWorldWrite", (lldb::eFilePermissionsWorldWrite))}, + {SWIG_LUA_CONSTTAB_INT("eFilePermissionsWorldExecute", (lldb::eFilePermissionsWorldExecute))}, + {SWIG_LUA_CONSTTAB_INT("eFilePermissionsUserRW", (lldb::eFilePermissionsUserRW))}, + {SWIG_LUA_CONSTTAB_INT("eFileFilePermissionsUserRX", (lldb::eFileFilePermissionsUserRX))}, + {SWIG_LUA_CONSTTAB_INT("eFilePermissionsUserRWX", (lldb::eFilePermissionsUserRWX))}, + {SWIG_LUA_CONSTTAB_INT("eFilePermissionsGroupRW", (lldb::eFilePermissionsGroupRW))}, + {SWIG_LUA_CONSTTAB_INT("eFilePermissionsGroupRX", (lldb::eFilePermissionsGroupRX))}, + {SWIG_LUA_CONSTTAB_INT("eFilePermissionsGroupRWX", (lldb::eFilePermissionsGroupRWX))}, + {SWIG_LUA_CONSTTAB_INT("eFilePermissionsWorldRW", (lldb::eFilePermissionsWorldRW))}, + {SWIG_LUA_CONSTTAB_INT("eFilePermissionsWorldRX", (lldb::eFilePermissionsWorldRX))}, + {SWIG_LUA_CONSTTAB_INT("eFilePermissionsWorldRWX", (lldb::eFilePermissionsWorldRWX))}, + {SWIG_LUA_CONSTTAB_INT("eFilePermissionsEveryoneR", (lldb::eFilePermissionsEveryoneR))}, + {SWIG_LUA_CONSTTAB_INT("eFilePermissionsEveryoneW", (lldb::eFilePermissionsEveryoneW))}, + {SWIG_LUA_CONSTTAB_INT("eFilePermissionsEveryoneX", (lldb::eFilePermissionsEveryoneX))}, + {SWIG_LUA_CONSTTAB_INT("eFilePermissionsEveryoneRW", (lldb::eFilePermissionsEveryoneRW))}, + {SWIG_LUA_CONSTTAB_INT("eFilePermissionsEveryoneRX", (lldb::eFilePermissionsEveryoneRX))}, + {SWIG_LUA_CONSTTAB_INT("eFilePermissionsEveryoneRWX", (lldb::eFilePermissionsEveryoneRWX))}, + {SWIG_LUA_CONSTTAB_INT("eFilePermissionsFileDefault", (lldb::eFilePermissionsFileDefault))}, + {SWIG_LUA_CONSTTAB_INT("eFilePermissionsDirectoryDefault", (lldb::eFilePermissionsDirectoryDefault))}, + {SWIG_LUA_CONSTTAB_INT("eQueueItemKindUnknown", (lldb::eQueueItemKindUnknown))}, + {SWIG_LUA_CONSTTAB_INT("eQueueItemKindFunction", (lldb::eQueueItemKindFunction))}, + {SWIG_LUA_CONSTTAB_INT("eQueueItemKindBlock", (lldb::eQueueItemKindBlock))}, + {SWIG_LUA_CONSTTAB_INT("eQueueKindUnknown", (lldb::eQueueKindUnknown))}, + {SWIG_LUA_CONSTTAB_INT("eQueueKindSerial", (lldb::eQueueKindSerial))}, + {SWIG_LUA_CONSTTAB_INT("eQueueKindConcurrent", (lldb::eQueueKindConcurrent))}, + {SWIG_LUA_CONSTTAB_INT("eExpressionEvaluationParse", (lldb::eExpressionEvaluationParse))}, + {SWIG_LUA_CONSTTAB_INT("eExpressionEvaluationIRGen", (lldb::eExpressionEvaluationIRGen))}, + {SWIG_LUA_CONSTTAB_INT("eExpressionEvaluationExecution", (lldb::eExpressionEvaluationExecution))}, + {SWIG_LUA_CONSTTAB_INT("eExpressionEvaluationComplete", (lldb::eExpressionEvaluationComplete))}, + {SWIG_LUA_CONSTTAB_INT("eInstructionControlFlowKindUnknown", (lldb::eInstructionControlFlowKindUnknown))}, + {SWIG_LUA_CONSTTAB_INT("eInstructionControlFlowKindOther", (lldb::eInstructionControlFlowKindOther))}, + {SWIG_LUA_CONSTTAB_INT("eInstructionControlFlowKindCall", (lldb::eInstructionControlFlowKindCall))}, + {SWIG_LUA_CONSTTAB_INT("eInstructionControlFlowKindReturn", (lldb::eInstructionControlFlowKindReturn))}, + {SWIG_LUA_CONSTTAB_INT("eInstructionControlFlowKindJump", (lldb::eInstructionControlFlowKindJump))}, + {SWIG_LUA_CONSTTAB_INT("eInstructionControlFlowKindCondJump", (lldb::eInstructionControlFlowKindCondJump))}, + {SWIG_LUA_CONSTTAB_INT("eInstructionControlFlowKindFarCall", (lldb::eInstructionControlFlowKindFarCall))}, + {SWIG_LUA_CONSTTAB_INT("eInstructionControlFlowKindFarReturn", (lldb::eInstructionControlFlowKindFarReturn))}, + {SWIG_LUA_CONSTTAB_INT("eInstructionControlFlowKindFarJump", (lldb::eInstructionControlFlowKindFarJump))}, + {SWIG_LUA_CONSTTAB_INT("eWatchpointKindWrite", (lldb::eWatchpointKindWrite))}, + {SWIG_LUA_CONSTTAB_INT("eWatchpointKindRead", (lldb::eWatchpointKindRead))}, + {SWIG_LUA_CONSTTAB_INT("eGdbSignalBadAccess", (lldb::eGdbSignalBadAccess))}, + {SWIG_LUA_CONSTTAB_INT("eGdbSignalBadInstruction", (lldb::eGdbSignalBadInstruction))}, + {SWIG_LUA_CONSTTAB_INT("eGdbSignalArithmetic", (lldb::eGdbSignalArithmetic))}, + {SWIG_LUA_CONSTTAB_INT("eGdbSignalEmulation", (lldb::eGdbSignalEmulation))}, + {SWIG_LUA_CONSTTAB_INT("eGdbSignalSoftware", (lldb::eGdbSignalSoftware))}, + {SWIG_LUA_CONSTTAB_INT("eGdbSignalBreakpoint", (lldb::eGdbSignalBreakpoint))}, + {SWIG_LUA_CONSTTAB_INT("ePathTypeLLDBShlibDir", (lldb::ePathTypeLLDBShlibDir))}, + {SWIG_LUA_CONSTTAB_INT("ePathTypeSupportExecutableDir", (lldb::ePathTypeSupportExecutableDir))}, + {SWIG_LUA_CONSTTAB_INT("ePathTypeHeaderDir", (lldb::ePathTypeHeaderDir))}, + {SWIG_LUA_CONSTTAB_INT("ePathTypePythonDir", (lldb::ePathTypePythonDir))}, + {SWIG_LUA_CONSTTAB_INT("ePathTypeLLDBSystemPlugins", (lldb::ePathTypeLLDBSystemPlugins))}, + {SWIG_LUA_CONSTTAB_INT("ePathTypeLLDBUserPlugins", (lldb::ePathTypeLLDBUserPlugins))}, + {SWIG_LUA_CONSTTAB_INT("ePathTypeLLDBTempSystemDir", (lldb::ePathTypeLLDBTempSystemDir))}, + {SWIG_LUA_CONSTTAB_INT("ePathTypeGlobalLLDBTempSystemDir", (lldb::ePathTypeGlobalLLDBTempSystemDir))}, + {SWIG_LUA_CONSTTAB_INT("ePathTypeClangDir", (lldb::ePathTypeClangDir))}, + {SWIG_LUA_CONSTTAB_INT("eMemberFunctionKindUnknown", (lldb::eMemberFunctionKindUnknown))}, + {SWIG_LUA_CONSTTAB_INT("eMemberFunctionKindConstructor", (lldb::eMemberFunctionKindConstructor))}, + {SWIG_LUA_CONSTTAB_INT("eMemberFunctionKindDestructor", (lldb::eMemberFunctionKindDestructor))}, + {SWIG_LUA_CONSTTAB_INT("eMemberFunctionKindInstanceMethod", (lldb::eMemberFunctionKindInstanceMethod))}, + {SWIG_LUA_CONSTTAB_INT("eMemberFunctionKindStaticMethod", (lldb::eMemberFunctionKindStaticMethod))}, + {SWIG_LUA_CONSTTAB_INT("eMatchTypeNormal", (lldb::eMatchTypeNormal))}, + {SWIG_LUA_CONSTTAB_INT("eMatchTypeRegex", (lldb::eMatchTypeRegex))}, + {SWIG_LUA_CONSTTAB_INT("eMatchTypeStartsWith", (lldb::eMatchTypeStartsWith))}, + {SWIG_LUA_CONSTTAB_INT("eMatchTypeRegexInsensitive", (lldb::eMatchTypeRegexInsensitive))}, + {SWIG_LUA_CONSTTAB_INT("eTypeHasChildren", (lldb::eTypeHasChildren))}, + {SWIG_LUA_CONSTTAB_INT("eTypeHasValue", (lldb::eTypeHasValue))}, + {SWIG_LUA_CONSTTAB_INT("eTypeIsArray", (lldb::eTypeIsArray))}, + {SWIG_LUA_CONSTTAB_INT("eTypeIsBlock", (lldb::eTypeIsBlock))}, + {SWIG_LUA_CONSTTAB_INT("eTypeIsBuiltIn", (lldb::eTypeIsBuiltIn))}, + {SWIG_LUA_CONSTTAB_INT("eTypeIsClass", (lldb::eTypeIsClass))}, + {SWIG_LUA_CONSTTAB_INT("eTypeIsCPlusPlus", (lldb::eTypeIsCPlusPlus))}, + {SWIG_LUA_CONSTTAB_INT("eTypeIsEnumeration", (lldb::eTypeIsEnumeration))}, + {SWIG_LUA_CONSTTAB_INT("eTypeIsFuncPrototype", (lldb::eTypeIsFuncPrototype))}, + {SWIG_LUA_CONSTTAB_INT("eTypeIsMember", (lldb::eTypeIsMember))}, + {SWIG_LUA_CONSTTAB_INT("eTypeIsObjC", (lldb::eTypeIsObjC))}, + {SWIG_LUA_CONSTTAB_INT("eTypeIsPointer", (lldb::eTypeIsPointer))}, + {SWIG_LUA_CONSTTAB_INT("eTypeIsReference", (lldb::eTypeIsReference))}, + {SWIG_LUA_CONSTTAB_INT("eTypeIsStructUnion", (lldb::eTypeIsStructUnion))}, + {SWIG_LUA_CONSTTAB_INT("eTypeIsTemplate", (lldb::eTypeIsTemplate))}, + {SWIG_LUA_CONSTTAB_INT("eTypeIsTypedef", (lldb::eTypeIsTypedef))}, + {SWIG_LUA_CONSTTAB_INT("eTypeIsVector", (lldb::eTypeIsVector))}, + {SWIG_LUA_CONSTTAB_INT("eTypeIsScalar", (lldb::eTypeIsScalar))}, + {SWIG_LUA_CONSTTAB_INT("eTypeIsInteger", (lldb::eTypeIsInteger))}, + {SWIG_LUA_CONSTTAB_INT("eTypeIsFloat", (lldb::eTypeIsFloat))}, + {SWIG_LUA_CONSTTAB_INT("eTypeIsComplex", (lldb::eTypeIsComplex))}, + {SWIG_LUA_CONSTTAB_INT("eTypeIsSigned", (lldb::eTypeIsSigned))}, + {SWIG_LUA_CONSTTAB_INT("eTypeInstanceIsPointer", (lldb::eTypeInstanceIsPointer))}, + {SWIG_LUA_CONSTTAB_INT("eCommandRequiresTarget", (lldb::eCommandRequiresTarget))}, + {SWIG_LUA_CONSTTAB_INT("eCommandRequiresProcess", (lldb::eCommandRequiresProcess))}, + {SWIG_LUA_CONSTTAB_INT("eCommandRequiresThread", (lldb::eCommandRequiresThread))}, + {SWIG_LUA_CONSTTAB_INT("eCommandRequiresFrame", (lldb::eCommandRequiresFrame))}, + {SWIG_LUA_CONSTTAB_INT("eCommandRequiresRegContext", (lldb::eCommandRequiresRegContext))}, + {SWIG_LUA_CONSTTAB_INT("eCommandTryTargetAPILock", (lldb::eCommandTryTargetAPILock))}, + {SWIG_LUA_CONSTTAB_INT("eCommandProcessMustBeLaunched", (lldb::eCommandProcessMustBeLaunched))}, + {SWIG_LUA_CONSTTAB_INT("eCommandProcessMustBePaused", (lldb::eCommandProcessMustBePaused))}, + {SWIG_LUA_CONSTTAB_INT("eCommandProcessMustBeTraced", (lldb::eCommandProcessMustBeTraced))}, + {SWIG_LUA_CONSTTAB_INT("eTypeSummaryCapped", (lldb::eTypeSummaryCapped))}, + {SWIG_LUA_CONSTTAB_INT("eTypeSummaryUncapped", (lldb::eTypeSummaryUncapped))}, + {SWIG_LUA_CONSTTAB_INT("eCommandInterpreterResultSuccess", (lldb::eCommandInterpreterResultSuccess))}, + {SWIG_LUA_CONSTTAB_INT("eCommandInterpreterResultInferiorCrash", (lldb::eCommandInterpreterResultInferiorCrash))}, + {SWIG_LUA_CONSTTAB_INT("eCommandInterpreterResultCommandError", (lldb::eCommandInterpreterResultCommandError))}, + {SWIG_LUA_CONSTTAB_INT("eCommandInterpreterResultQuitRequested", (lldb::eCommandInterpreterResultQuitRequested))}, + {SWIG_LUA_CONSTTAB_INT("eSaveCoreUnspecified", (lldb::eSaveCoreUnspecified))}, + {SWIG_LUA_CONSTTAB_INT("eSaveCoreFull", (lldb::eSaveCoreFull))}, + {SWIG_LUA_CONSTTAB_INT("eSaveCoreDirtyOnly", (lldb::eSaveCoreDirtyOnly))}, + {SWIG_LUA_CONSTTAB_INT("eSaveCoreStackOnly", (lldb::eSaveCoreStackOnly))}, + {SWIG_LUA_CONSTTAB_INT("eTraceEventDisabledSW", (lldb::eTraceEventDisabledSW))}, + {SWIG_LUA_CONSTTAB_INT("eTraceEventDisabledHW", (lldb::eTraceEventDisabledHW))}, + {SWIG_LUA_CONSTTAB_INT("eTraceEventCPUChanged", (lldb::eTraceEventCPUChanged))}, + {SWIG_LUA_CONSTTAB_INT("eTraceEventHWClockTick", (lldb::eTraceEventHWClockTick))}, + {SWIG_LUA_CONSTTAB_INT("eTraceEventSyncPoint", (lldb::eTraceEventSyncPoint))}, + {SWIG_LUA_CONSTTAB_INT("eTraceItemKindError", (lldb::eTraceItemKindError))}, + {SWIG_LUA_CONSTTAB_INT("eTraceItemKindEvent", (lldb::eTraceItemKindEvent))}, + {SWIG_LUA_CONSTTAB_INT("eTraceItemKindInstruction", (lldb::eTraceItemKindInstruction))}, + {SWIG_LUA_CONSTTAB_INT("eTraceCursorSeekTypeBeginning", (lldb::eTraceCursorSeekTypeBeginning))}, + {SWIG_LUA_CONSTTAB_INT("eTraceCursorSeekTypeCurrent", (lldb::eTraceCursorSeekTypeCurrent))}, + {SWIG_LUA_CONSTTAB_INT("eTraceCursorSeekTypeEnd", (lldb::eTraceCursorSeekTypeEnd))}, + {SWIG_LUA_CONSTTAB_INT("eDWIMPrintVerbosityNone", (lldb::eDWIMPrintVerbosityNone))}, + {SWIG_LUA_CONSTTAB_INT("eDWIMPrintVerbosityExpression", (lldb::eDWIMPrintVerbosityExpression))}, + {SWIG_LUA_CONSTTAB_INT("eDWIMPrintVerbosityFull", (lldb::eDWIMPrintVerbosityFull))}, + {SWIG_LUA_CONSTTAB_INT("eWatchPointValueKindInvalid", (lldb::eWatchPointValueKindInvalid))}, + {SWIG_LUA_CONSTTAB_INT("eWatchPointValueKindVariable", (lldb::eWatchPointValueKindVariable))}, + {SWIG_LUA_CONSTTAB_INT("eWatchPointValueKindExpression", (lldb::eWatchPointValueKindExpression))}, + {SWIG_LUA_CONSTTAB_INT("eNoCompletion", (lldb::eNoCompletion))}, + {SWIG_LUA_CONSTTAB_INT("eSourceFileCompletion", (lldb::eSourceFileCompletion))}, + {SWIG_LUA_CONSTTAB_INT("eDiskFileCompletion", (lldb::eDiskFileCompletion))}, + {SWIG_LUA_CONSTTAB_INT("eDiskDirectoryCompletion", (lldb::eDiskDirectoryCompletion))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolCompletion", (lldb::eSymbolCompletion))}, + {SWIG_LUA_CONSTTAB_INT("eModuleCompletion", (lldb::eModuleCompletion))}, + {SWIG_LUA_CONSTTAB_INT("eSettingsNameCompletion", (lldb::eSettingsNameCompletion))}, + {SWIG_LUA_CONSTTAB_INT("ePlatformPluginCompletion", (lldb::ePlatformPluginCompletion))}, + {SWIG_LUA_CONSTTAB_INT("eArchitectureCompletion", (lldb::eArchitectureCompletion))}, + {SWIG_LUA_CONSTTAB_INT("eVariablePathCompletion", (lldb::eVariablePathCompletion))}, + {SWIG_LUA_CONSTTAB_INT("eRegisterCompletion", (lldb::eRegisterCompletion))}, + {SWIG_LUA_CONSTTAB_INT("eBreakpointCompletion", (lldb::eBreakpointCompletion))}, + {SWIG_LUA_CONSTTAB_INT("eProcessPluginCompletion", (lldb::eProcessPluginCompletion))}, + {SWIG_LUA_CONSTTAB_INT("eDisassemblyFlavorCompletion", (lldb::eDisassemblyFlavorCompletion))}, + {SWIG_LUA_CONSTTAB_INT("eTypeLanguageCompletion", (lldb::eTypeLanguageCompletion))}, + {SWIG_LUA_CONSTTAB_INT("eFrameIndexCompletion", (lldb::eFrameIndexCompletion))}, + {SWIG_LUA_CONSTTAB_INT("eModuleUUIDCompletion", (lldb::eModuleUUIDCompletion))}, + {SWIG_LUA_CONSTTAB_INT("eStopHookIDCompletion", (lldb::eStopHookIDCompletion))}, + {SWIG_LUA_CONSTTAB_INT("eThreadIndexCompletion", (lldb::eThreadIndexCompletion))}, + {SWIG_LUA_CONSTTAB_INT("eWatchpointIDCompletion", (lldb::eWatchpointIDCompletion))}, + {SWIG_LUA_CONSTTAB_INT("eBreakpointNameCompletion", (lldb::eBreakpointNameCompletion))}, + {SWIG_LUA_CONSTTAB_INT("eProcessIDCompletion", (lldb::eProcessIDCompletion))}, + {SWIG_LUA_CONSTTAB_INT("eProcessNameCompletion", (lldb::eProcessNameCompletion))}, + {SWIG_LUA_CONSTTAB_INT("eRemoteDiskFileCompletion", (lldb::eRemoteDiskFileCompletion))}, + {SWIG_LUA_CONSTTAB_INT("eRemoteDiskDirectoryCompletion", (lldb::eRemoteDiskDirectoryCompletion))}, + {SWIG_LUA_CONSTTAB_INT("eTypeCategoryNameCompletion", (lldb::eTypeCategoryNameCompletion))}, + {SWIG_LUA_CONSTTAB_INT("eCustomCompletion", (lldb::eCustomCompletion))}, + {SWIG_LUA_CONSTTAB_INT("eThreadIDCompletion", (lldb::eThreadIDCompletion))}, + {SWIG_LUA_CONSTTAB_INT("eTerminatorCompletion", (lldb::eTerminatorCompletion))}, + {SWIG_LUA_CONSTTAB_INT("eRefetch", (lldb::eRefetch))}, + {SWIG_LUA_CONSTTAB_INT("eReuse", (lldb::eReuse))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolDownloadOff", (lldb::eSymbolDownloadOff))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolDownloadBackground", (lldb::eSymbolDownloadBackground))}, + {SWIG_LUA_CONSTTAB_INT("eSymbolDownloadForeground", (lldb::eSymbolDownloadForeground))}, + {SWIG_LUA_CONSTTAB_INT("eAddressMaskTypeCode", (lldb::eAddressMaskTypeCode))}, + {SWIG_LUA_CONSTTAB_INT("eAddressMaskTypeData", (lldb::eAddressMaskTypeData))}, + {SWIG_LUA_CONSTTAB_INT("eAddressMaskTypeAny", (lldb::eAddressMaskTypeAny))}, + {SWIG_LUA_CONSTTAB_INT("eAddressMaskTypeAll", (lldb::eAddressMaskTypeAll))}, + {SWIG_LUA_CONSTTAB_INT("eAddressMaskRangeLow", (lldb::eAddressMaskRangeLow))}, + {SWIG_LUA_CONSTTAB_INT("eAddressMaskRangeHigh", (lldb::eAddressMaskRangeHigh))}, + {SWIG_LUA_CONSTTAB_INT("eAddressMaskRangeAny", (lldb::eAddressMaskRangeAny))}, + {SWIG_LUA_CONSTTAB_INT("eAddressMaskRangeAll", (lldb::eAddressMaskRangeAll))}, + {SWIG_LUA_CONSTTAB_INT("eBroadcastBitProgress", (lldb::eBroadcastBitProgress))}, + {SWIG_LUA_CONSTTAB_INT("eBroadcastBitWarning", (lldb::eBroadcastBitWarning))}, + {SWIG_LUA_CONSTTAB_INT("eBroadcastBitError", (lldb::eBroadcastBitError))}, + {SWIG_LUA_CONSTTAB_INT("eBroadcastSymbolChange", (lldb::eBroadcastSymbolChange))}, + {SWIG_LUA_CONSTTAB_INT("eBroadcastBitProgressCategory", (lldb::eBroadcastBitProgressCategory))}, + {SWIG_LUA_CONSTTAB_INT("eSeverityError", (lldb::eSeverityError))}, + {SWIG_LUA_CONSTTAB_INT("eSeverityWarning", (lldb::eSeverityWarning))}, + {SWIG_LUA_CONSTTAB_INT("eSeverityInfo", (lldb::eSeverityInfo))}, + {SWIG_LUA_CONSTTAB_INT("SBCommandInterpreter_eBroadcastBitThreadShouldExit", (lldb::SBCommandInterpreter::eBroadcastBitThreadShouldExit))}, + {SWIG_LUA_CONSTTAB_INT("SBCommandInterpreter_eBroadcastBitResetPrompt", (lldb::SBCommandInterpreter::eBroadcastBitResetPrompt))}, + {SWIG_LUA_CONSTTAB_INT("SBCommandInterpreter_eBroadcastBitQuitCommandReceived", (lldb::SBCommandInterpreter::eBroadcastBitQuitCommandReceived))}, + {SWIG_LUA_CONSTTAB_INT("SBCommandInterpreter_eBroadcastBitAsynchronousOutputData", (lldb::SBCommandInterpreter::eBroadcastBitAsynchronousOutputData))}, + {SWIG_LUA_CONSTTAB_INT("SBCommandInterpreter_eBroadcastBitAsynchronousErrorData", (lldb::SBCommandInterpreter::eBroadcastBitAsynchronousErrorData))}, + {SWIG_LUA_CONSTTAB_INT("SBCommunication_eBroadcastBitDisconnected", (lldb::SBCommunication::eBroadcastBitDisconnected))}, + {SWIG_LUA_CONSTTAB_INT("SBCommunication_eBroadcastBitReadThreadGotBytes", (lldb::SBCommunication::eBroadcastBitReadThreadGotBytes))}, + {SWIG_LUA_CONSTTAB_INT("SBCommunication_eBroadcastBitReadThreadDidExit", (lldb::SBCommunication::eBroadcastBitReadThreadDidExit))}, + {SWIG_LUA_CONSTTAB_INT("SBCommunication_eBroadcastBitReadThreadShouldExit", (lldb::SBCommunication::eBroadcastBitReadThreadShouldExit))}, + {SWIG_LUA_CONSTTAB_INT("SBCommunication_eBroadcastBitPacketAvailable", (lldb::SBCommunication::eBroadcastBitPacketAvailable))}, + {SWIG_LUA_CONSTTAB_INT("SBCommunication_eAllEventBits", (lldb::SBCommunication::eAllEventBits))}, + {SWIG_LUA_CONSTTAB_INT("SBDebugger_eBroadcastBitProgress", (lldb::SBDebugger::eBroadcastBitProgress))}, + {SWIG_LUA_CONSTTAB_INT("SBDebugger_eBroadcastBitWarning", (lldb::SBDebugger::eBroadcastBitWarning))}, + {SWIG_LUA_CONSTTAB_INT("SBDebugger_eBroadcastBitError", (lldb::SBDebugger::eBroadcastBitError))}, + {SWIG_LUA_CONSTTAB_INT("SBDebugger_eBroadcastBitProgressCategory", (lldb::SBDebugger::eBroadcastBitProgressCategory))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameAda", (lldb::eLanguageNameAda))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameBLISS", (lldb::eLanguageNameBLISS))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameC", (lldb::eLanguageNameC))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameC_plus_plus", (lldb::eLanguageNameC_plus_plus))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameCobol", (lldb::eLanguageNameCobol))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameCrystal", (lldb::eLanguageNameCrystal))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameD", (lldb::eLanguageNameD))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameDylan", (lldb::eLanguageNameDylan))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameFortran", (lldb::eLanguageNameFortran))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameGo", (lldb::eLanguageNameGo))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameHaskell", (lldb::eLanguageNameHaskell))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameJava", (lldb::eLanguageNameJava))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameJulia", (lldb::eLanguageNameJulia))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameKotlin", (lldb::eLanguageNameKotlin))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameModula2", (lldb::eLanguageNameModula2))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameModula3", (lldb::eLanguageNameModula3))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameObjC", (lldb::eLanguageNameObjC))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameObjC_plus_plus", (lldb::eLanguageNameObjC_plus_plus))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameOCaml", (lldb::eLanguageNameOCaml))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameOpenCL_C", (lldb::eLanguageNameOpenCL_C))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNamePascal", (lldb::eLanguageNamePascal))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNamePLI", (lldb::eLanguageNamePLI))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNamePython", (lldb::eLanguageNamePython))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameRenderScript", (lldb::eLanguageNameRenderScript))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameRust", (lldb::eLanguageNameRust))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameSwift", (lldb::eLanguageNameSwift))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameUPC", (lldb::eLanguageNameUPC))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameZig", (lldb::eLanguageNameZig))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameAssembly", (lldb::eLanguageNameAssembly))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameC_sharp", (lldb::eLanguageNameC_sharp))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameMojo", (lldb::eLanguageNameMojo))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameGLSL", (lldb::eLanguageNameGLSL))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameGLSL_ES", (lldb::eLanguageNameGLSL_ES))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameHLSL", (lldb::eLanguageNameHLSL))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameOpenCL_CPP", (lldb::eLanguageNameOpenCL_CPP))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameCPP_for_OpenCL", (lldb::eLanguageNameCPP_for_OpenCL))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameSYCL", (lldb::eLanguageNameSYCL))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameRuby", (lldb::eLanguageNameRuby))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameMove", (lldb::eLanguageNameMove))}, + {SWIG_LUA_CONSTTAB_INT("eLanguageNameHylo", (lldb::eLanguageNameHylo))}, + {SWIG_LUA_CONSTTAB_INT("SBProcess_eBroadcastBitStateChanged", (lldb::SBProcess::eBroadcastBitStateChanged))}, + {SWIG_LUA_CONSTTAB_INT("SBProcess_eBroadcastBitInterrupt", (lldb::SBProcess::eBroadcastBitInterrupt))}, + {SWIG_LUA_CONSTTAB_INT("SBProcess_eBroadcastBitSTDOUT", (lldb::SBProcess::eBroadcastBitSTDOUT))}, + {SWIG_LUA_CONSTTAB_INT("SBProcess_eBroadcastBitSTDERR", (lldb::SBProcess::eBroadcastBitSTDERR))}, + {SWIG_LUA_CONSTTAB_INT("SBProcess_eBroadcastBitProfileData", (lldb::SBProcess::eBroadcastBitProfileData))}, + {SWIG_LUA_CONSTTAB_INT("SBProcess_eBroadcastBitStructuredData", (lldb::SBProcess::eBroadcastBitStructuredData))}, + {SWIG_LUA_CONSTTAB_INT("SBTarget_eBroadcastBitBreakpointChanged", (lldb::SBTarget::eBroadcastBitBreakpointChanged))}, + {SWIG_LUA_CONSTTAB_INT("SBTarget_eBroadcastBitModulesLoaded", (lldb::SBTarget::eBroadcastBitModulesLoaded))}, + {SWIG_LUA_CONSTTAB_INT("SBTarget_eBroadcastBitModulesUnloaded", (lldb::SBTarget::eBroadcastBitModulesUnloaded))}, + {SWIG_LUA_CONSTTAB_INT("SBTarget_eBroadcastBitWatchpointChanged", (lldb::SBTarget::eBroadcastBitWatchpointChanged))}, + {SWIG_LUA_CONSTTAB_INT("SBTarget_eBroadcastBitSymbolsLoaded", (lldb::SBTarget::eBroadcastBitSymbolsLoaded))}, + {SWIG_LUA_CONSTTAB_INT("SBTarget_eBroadcastBitSymbolsChanged", (lldb::SBTarget::eBroadcastBitSymbolsChanged))}, + {SWIG_LUA_CONSTTAB_INT("SBThread_eBroadcastBitStackChanged", (lldb::SBThread::eBroadcastBitStackChanged))}, + {SWIG_LUA_CONSTTAB_INT("SBThread_eBroadcastBitThreadSuspended", (lldb::SBThread::eBroadcastBitThreadSuspended))}, + {SWIG_LUA_CONSTTAB_INT("SBThread_eBroadcastBitThreadResumed", (lldb::SBThread::eBroadcastBitThreadResumed))}, + {SWIG_LUA_CONSTTAB_INT("SBThread_eBroadcastBitSelectedFrameChanged", (lldb::SBThread::eBroadcastBitSelectedFrameChanged))}, + {SWIG_LUA_CONSTTAB_INT("SBThread_eBroadcastBitThreadSelected", (lldb::SBThread::eBroadcastBitThreadSelected))}, + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SwigModule_methods[]= { + { "SBBreakpoint_EventIsBreakpointEvent", _wrap_SBBreakpoint_EventIsBreakpointEvent}, + { "SBBreakpoint_GetBreakpointEventTypeFromEvent", _wrap_SBBreakpoint_GetBreakpointEventTypeFromEvent}, + { "SBBreakpoint_GetBreakpointFromEvent", _wrap_SBBreakpoint_GetBreakpointFromEvent}, + { "SBBreakpoint_GetBreakpointLocationAtIndexFromEvent", _wrap_SBBreakpoint_GetBreakpointLocationAtIndexFromEvent}, + { "SBBreakpoint_GetNumBreakpointLocationsFromEvent", _wrap_SBBreakpoint_GetNumBreakpointLocationsFromEvent}, + { "SBCommandInterpreter_GetArgumentTypeAsCString", _wrap_SBCommandInterpreter_GetArgumentTypeAsCString}, + { "SBCommandInterpreter_GetArgumentDescriptionAsCString", _wrap_SBCommandInterpreter_GetArgumentDescriptionAsCString}, + { "SBCommandInterpreter_EventIsCommandInterpreterEvent", _wrap_SBCommandInterpreter_EventIsCommandInterpreterEvent}, + { "SBCommandInterpreter_GetBroadcasterClass", _wrap_SBCommandInterpreter_GetBroadcasterClass}, + { "SBCommunication_GetBroadcasterClass", _wrap_SBCommunication_GetBroadcasterClass}, + { "SBData_CreateDataFromCString", _wrap_SBData_CreateDataFromCString}, + { "SBData_CreateDataFromUInt64Array", _wrap_SBData_CreateDataFromUInt64Array}, + { "SBData_CreateDataFromUInt32Array", _wrap_SBData_CreateDataFromUInt32Array}, + { "SBData_CreateDataFromSInt64Array", _wrap_SBData_CreateDataFromSInt64Array}, + { "SBData_CreateDataFromSInt32Array", _wrap_SBData_CreateDataFromSInt32Array}, + { "SBData_CreateDataFromDoubleArray", _wrap_SBData_CreateDataFromDoubleArray}, + { "SBDebugger_GetBroadcasterClass", _wrap_SBDebugger_GetBroadcasterClass}, + { "SBDebugger_SupportsLanguage", _wrap_SBDebugger_SupportsLanguage}, + { "SBDebugger_GetProgressFromEvent", _wrap_SBDebugger_GetProgressFromEvent}, + { "SBDebugger_GetProgressDataFromEvent", _wrap_SBDebugger_GetProgressDataFromEvent}, + { "SBDebugger_GetDiagnosticFromEvent", _wrap_SBDebugger_GetDiagnosticFromEvent}, + { "SBDebugger_Initialize", _wrap_SBDebugger_Initialize}, + { "SBDebugger_InitializeWithErrorHandling", _wrap_SBDebugger_InitializeWithErrorHandling}, + { "SBDebugger_PrintStackTraceOnError", _wrap_SBDebugger_PrintStackTraceOnError}, + { "SBDebugger_PrintDiagnosticsOnError", _wrap_SBDebugger_PrintDiagnosticsOnError}, + { "SBDebugger_Terminate", _wrap_SBDebugger_Terminate}, + { "SBDebugger_Create", _wrap_SBDebugger_Create}, + { "SBDebugger_Destroy", _wrap_SBDebugger_Destroy}, + { "SBDebugger_MemoryPressureDetected", _wrap_SBDebugger_MemoryPressureDetected}, + { "SBDebugger_GetDefaultArchitecture", _wrap_SBDebugger_GetDefaultArchitecture}, + { "SBDebugger_SetDefaultArchitecture", _wrap_SBDebugger_SetDefaultArchitecture}, + { "SBDebugger_GetVersionString", _wrap_SBDebugger_GetVersionString}, + { "SBDebugger_StateAsCString", _wrap_SBDebugger_StateAsCString}, + { "SBDebugger_GetBuildConfiguration", _wrap_SBDebugger_GetBuildConfiguration}, + { "SBDebugger_StateIsRunningState", _wrap_SBDebugger_StateIsRunningState}, + { "SBDebugger_StateIsStoppedState", _wrap_SBDebugger_StateIsStoppedState}, + { "SBDebugger_FindDebuggerWithID", _wrap_SBDebugger_FindDebuggerWithID}, + { "SBDebugger_SetInternalVariable", _wrap_SBDebugger_SetInternalVariable}, + { "SBDebugger_GetInternalVariableValue", _wrap_SBDebugger_GetInternalVariableValue}, + { "SBEvent_GetCStringFromEvent", _wrap_SBEvent_GetCStringFromEvent}, + { "SBFile_MakeBorrowed", _wrap_SBFile_MakeBorrowed}, + { "SBFile_MakeForcingIOMethods", _wrap_SBFile_MakeForcingIOMethods}, + { "SBFile_MakeBorrowedForcingIOMethods", _wrap_SBFile_MakeBorrowedForcingIOMethods}, + { "SBFileSpec_ResolvePath", _wrap_SBFileSpec_ResolvePath}, + { "SBHostOS_GetProgramFileSpec", _wrap_SBHostOS_GetProgramFileSpec}, + { "SBHostOS_GetLLDBPythonPath", _wrap_SBHostOS_GetLLDBPythonPath}, + { "SBHostOS_GetLLDBPath", _wrap_SBHostOS_GetLLDBPath}, + { "SBHostOS_GetUserHomeDirectory", _wrap_SBHostOS_GetUserHomeDirectory}, + { "SBHostOS_ThreadCreated", _wrap_SBHostOS_ThreadCreated}, + { "SBHostOS_ThreadCreate", _wrap_SBHostOS_ThreadCreate}, + { "SBHostOS_ThreadCancel", _wrap_SBHostOS_ThreadCancel}, + { "SBHostOS_ThreadDetach", _wrap_SBHostOS_ThreadDetach}, + { "SBHostOS_ThreadJoin", _wrap_SBHostOS_ThreadJoin}, + { "SBLanguageRuntime_GetLanguageTypeFromString", _wrap_SBLanguageRuntime_GetLanguageTypeFromString}, + { "SBLanguageRuntime_GetNameForLanguageType", _wrap_SBLanguageRuntime_GetNameForLanguageType}, + { "SBLanguageRuntime_LanguageIsCPlusPlus", _wrap_SBLanguageRuntime_LanguageIsCPlusPlus}, + { "SBLanguageRuntime_LanguageIsObjC", _wrap_SBLanguageRuntime_LanguageIsObjC}, + { "SBLanguageRuntime_LanguageIsCFamily", _wrap_SBLanguageRuntime_LanguageIsCFamily}, + { "SBLanguageRuntime_SupportsExceptionBreakpointsOnThrow", _wrap_SBLanguageRuntime_SupportsExceptionBreakpointsOnThrow}, + { "SBLanguageRuntime_SupportsExceptionBreakpointsOnCatch", _wrap_SBLanguageRuntime_SupportsExceptionBreakpointsOnCatch}, + { "SBLanguageRuntime_GetThrowKeywordForLanguage", _wrap_SBLanguageRuntime_GetThrowKeywordForLanguage}, + { "SBLanguageRuntime_GetCatchKeywordForLanguage", _wrap_SBLanguageRuntime_GetCatchKeywordForLanguage}, + { "SBModule_GetNumberAllocatedModules", _wrap_SBModule_GetNumberAllocatedModules}, + { "SBModule_GarbageCollectAllocatedModules", _wrap_SBModule_GarbageCollectAllocatedModules}, + { "SBModuleSpecList_GetModuleSpecifications", _wrap_SBModuleSpecList_GetModuleSpecifications}, + { "SBPlatform_GetHostPlatform", _wrap_SBPlatform_GetHostPlatform}, + { "SBProcess_GetBroadcasterClassName", _wrap_SBProcess_GetBroadcasterClassName}, + { "SBProcess_GetStateFromEvent", _wrap_SBProcess_GetStateFromEvent}, + { "SBProcess_GetRestartedFromEvent", _wrap_SBProcess_GetRestartedFromEvent}, + { "SBProcess_GetNumRestartedReasonsFromEvent", _wrap_SBProcess_GetNumRestartedReasonsFromEvent}, + { "SBProcess_GetRestartedReasonAtIndexFromEvent", _wrap_SBProcess_GetRestartedReasonAtIndexFromEvent}, + { "SBProcess_GetProcessFromEvent", _wrap_SBProcess_GetProcessFromEvent}, + { "SBProcess_GetInterruptedFromEvent", _wrap_SBProcess_GetInterruptedFromEvent}, + { "SBProcess_GetStructuredDataFromEvent", _wrap_SBProcess_GetStructuredDataFromEvent}, + { "SBProcess_EventIsProcessEvent", _wrap_SBProcess_EventIsProcessEvent}, + { "SBProcess_EventIsStructuredDataEvent", _wrap_SBProcess_EventIsStructuredDataEvent}, + { "SBProcess_GetBroadcasterClass", _wrap_SBProcess_GetBroadcasterClass}, + { "SBReproducer_Capture", _wrap_SBReproducer_Capture}, + { "SBReproducer_PassiveReplay", _wrap_SBReproducer_PassiveReplay}, + { "SBReproducer_SetAutoGenerate", _wrap_SBReproducer_SetAutoGenerate}, + { "SBReproducer_SetWorkingDirectory", _wrap_SBReproducer_SetWorkingDirectory}, + { "SBTarget_EventIsTargetEvent", _wrap_SBTarget_EventIsTargetEvent}, + { "SBTarget_GetTargetFromEvent", _wrap_SBTarget_GetTargetFromEvent}, + { "SBTarget_GetNumModulesFromEvent", _wrap_SBTarget_GetNumModulesFromEvent}, + { "SBTarget_GetModuleAtIndexFromEvent", _wrap_SBTarget_GetModuleAtIndexFromEvent}, + { "SBTarget_GetBroadcasterClassName", _wrap_SBTarget_GetBroadcasterClassName}, + { "SBThread_GetBroadcasterClassName", _wrap_SBThread_GetBroadcasterClassName}, + { "SBThread_EventIsThreadEvent", _wrap_SBThread_EventIsThreadEvent}, + { "SBThread_GetStackFrameFromEvent", _wrap_SBThread_GetStackFrameFromEvent}, + { "SBThread_GetThreadFromEvent", _wrap_SBThread_GetThreadFromEvent}, + { "SBTrace_LoadTraceFromFile", _wrap_SBTrace_LoadTraceFromFile}, + { "SBTypeSummary_CreateWithSummaryString", _wrap_SBTypeSummary_CreateWithSummaryString}, + { "SBTypeSummary_CreateWithFunctionName", _wrap_SBTypeSummary_CreateWithFunctionName}, + { "SBTypeSummary_CreateWithScriptCode", _wrap_SBTypeSummary_CreateWithScriptCode}, + { "SBTypeSynthetic_CreateWithClassName", _wrap_SBTypeSynthetic_CreateWithClassName}, + { "SBTypeSynthetic_CreateWithScriptCode", _wrap_SBTypeSynthetic_CreateWithScriptCode}, + { "SBWatchpoint_EventIsWatchpointEvent", _wrap_SBWatchpoint_EventIsWatchpointEvent}, + { "SBWatchpoint_GetWatchpointEventTypeFromEvent", _wrap_SBWatchpoint_GetWatchpointEventTypeFromEvent}, + { "SBWatchpoint_GetWatchpointFromEvent", _wrap_SBWatchpoint_GetWatchpointFromEvent}, + {0,0} +}; +static swig_lua_class* swig_SwigModule_classes[]= { +&_wrap_class_string, +&_wrap_class_SBAddress, +&_wrap_class_SBAddressRange, +&_wrap_class_SBAddressRangeList, +&_wrap_class_SBAttachInfo, +&_wrap_class_SBBlock, +&_wrap_class_SBBreakpoint, +&_wrap_class_SBBreakpointList, +&_wrap_class_SBBreakpointLocation, +&_wrap_class_SBBreakpointName, +&_wrap_class_SBBroadcaster, +&_wrap_class_SBCommandInterpreter, +&_wrap_class_SBCommandInterpreterRunOptions, +&_wrap_class_SBCommandReturnObject, +&_wrap_class_SBCommunication, +&_wrap_class_SBCompileUnit, +&_wrap_class_SBSaveCoreOptions, +&_wrap_class_SBData, +&_wrap_class_SBDebugger, +&_wrap_class_SBDeclaration, +&_wrap_class_SBError, +&_wrap_class_SBEnvironment, +&_wrap_class_SBEvent, +&_wrap_class_SBExecutionContext, +&_wrap_class_SBExpressionOptions, +&_wrap_class_SBFile, +&_wrap_class_SBFileSpec, +&_wrap_class_SBFileSpecList, +&_wrap_class_SBFormat, +&_wrap_class_SBFrame, +&_wrap_class_SBFunction, +&_wrap_class_SBHostOS, +&_wrap_class_SBInstruction, +&_wrap_class_SBInstructionList, +&_wrap_class_SBLanguageRuntime, +&_wrap_class_SBLaunchInfo, +&_wrap_class_SBLineEntry, +&_wrap_class_SBListener, +&_wrap_class_SBMemoryRegionInfo, +&_wrap_class_SBMemoryRegionInfoList, +&_wrap_class_SBModule, +&_wrap_class_SBModuleSpec, +&_wrap_class_SBModuleSpecList, +&_wrap_class_SBPlatformConnectOptions, +&_wrap_class_SBPlatformShellCommand, +&_wrap_class_SBPlatform, +&_wrap_class_SBProcess, +&_wrap_class_SBProcessInfo, +&_wrap_class_SBProcessInfoList, +&_wrap_class_SBQueue, +&_wrap_class_SBQueueItem, +&_wrap_class_SBReproducer, +&_wrap_class_SBScriptObject, +&_wrap_class_SBSection, +&_wrap_class_SBSourceManager, +&_wrap_class_SBStatisticsOptions, +&_wrap_class_SBStream, +&_wrap_class_SBStringList, +&_wrap_class_SBStructuredData, +&_wrap_class_SBSymbol, +&_wrap_class_SBSymbolContext, +&_wrap_class_SBSymbolContextList, +&_wrap_class_SBTarget, +&_wrap_class_SBThread, +&_wrap_class_SBThreadCollection, +&_wrap_class_SBThreadPlan, +&_wrap_class_SBTrace, +&_wrap_class_SBTraceCursor, +&_wrap_class_SBTypeMember, +&_wrap_class_SBTypeMemberFunction, +&_wrap_class_SBTypeStaticField, +&_wrap_class_SBType, +&_wrap_class_SBTypeList, +&_wrap_class_SBTypeCategory, +&_wrap_class_SBTypeEnumMember, +&_wrap_class_SBTypeEnumMemberList, +&_wrap_class_SBTypeFilter, +&_wrap_class_SBTypeFormat, +&_wrap_class_SBTypeNameSpecifier, +&_wrap_class_SBTypeSummaryOptions, +&_wrap_class_SBTypeSummary, +&_wrap_class_SBTypeSynthetic, +&_wrap_class_SBUnixSignals, +&_wrap_class_SBValue, +&_wrap_class_SBValueList, +&_wrap_class_SBVariablesOptions, +&_wrap_class_SBWatchpoint, +&_wrap_class_SBWatchpointOptions, + 0 +}; +static swig_lua_namespace* swig_SwigModule_namespaces[] = { + 0 +}; + +static swig_lua_namespace swig_SwigModule = { + "lldb", + swig_SwigModule_methods, + swig_SwigModule_attributes, + swig_SwigModule_constants, + swig_SwigModule_classes, + swig_SwigModule_namespaces +}; +#ifdef __cplusplus +} +#endif + +/* -------- 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_double = {"_p_double", "double *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_f_p_q_const__char_p_void__void = {"_p_f_p_q_const__char_p_void__void", "lldb::LogOutputCallback|void (*)(char const *,void *)", 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_p_q_const__char__bool = {"_p_f_p_void_p_p_q_const__char__bool", "lldb::CommandOverrideCallback|bool (*)(void *,char const **)", 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_f_p_void_r_q_const__lldb__SBModuleSpec_r_lldb__SBFileSpec_r_lldb__SBFileSpec__lldb__SBError = {"_p_f_p_void_r_q_const__lldb__SBModuleSpec_r_lldb__SBFileSpec_r_lldb__SBFileSpec__lldb__SBError", "lldb::SBPlatformLocateModuleCallback|lldb::SBError (*)(void *,lldb::SBModuleSpec const &,lldb::SBFileSpec &,lldb::SBFileSpec &)", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_f_unsigned_long_long_p_void__void = {"_p_f_unsigned_long_long_p_void__void", "lldb::SBDebuggerDestroyCallback|void (*)(unsigned long long,void *)", 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*)&_wrap_class_SBAddress, 0}; +static swig_type_info _swigt__p_lldb__SBAddressRange = {"_p_lldb__SBAddressRange", "lldb::SBAddressRange *", 0, 0, (void*)&_wrap_class_SBAddressRange, 0}; +static swig_type_info _swigt__p_lldb__SBAddressRangeList = {"_p_lldb__SBAddressRangeList", "lldb::SBAddressRangeList *", 0, 0, (void*)&_wrap_class_SBAddressRangeList, 0}; +static swig_type_info _swigt__p_lldb__SBAttachInfo = {"_p_lldb__SBAttachInfo", "lldb::SBAttachInfo *", 0, 0, (void*)&_wrap_class_SBAttachInfo, 0}; +static swig_type_info _swigt__p_lldb__SBBlock = {"_p_lldb__SBBlock", "lldb::SBBlock *", 0, 0, (void*)&_wrap_class_SBBlock, 0}; +static swig_type_info _swigt__p_lldb__SBBreakpoint = {"_p_lldb__SBBreakpoint", "lldb::SBBreakpoint *", 0, 0, (void*)&_wrap_class_SBBreakpoint, 0}; +static swig_type_info _swigt__p_lldb__SBBreakpointList = {"_p_lldb__SBBreakpointList", "lldb::SBBreakpointList *", 0, 0, (void*)&_wrap_class_SBBreakpointList, 0}; +static swig_type_info _swigt__p_lldb__SBBreakpointLocation = {"_p_lldb__SBBreakpointLocation", "lldb::SBBreakpointLocation *", 0, 0, (void*)&_wrap_class_SBBreakpointLocation, 0}; +static swig_type_info _swigt__p_lldb__SBBreakpointName = {"_p_lldb__SBBreakpointName", "lldb::SBBreakpointName *", 0, 0, (void*)&_wrap_class_SBBreakpointName, 0}; +static swig_type_info _swigt__p_lldb__SBBroadcaster = {"_p_lldb__SBBroadcaster", "lldb::SBBroadcaster *", 0, 0, (void*)&_wrap_class_SBBroadcaster, 0}; +static swig_type_info _swigt__p_lldb__SBCommandInterpreter = {"_p_lldb__SBCommandInterpreter", "lldb::SBCommandInterpreter *", 0, 0, (void*)&_wrap_class_SBCommandInterpreter, 0}; +static swig_type_info _swigt__p_lldb__SBCommandInterpreterRunOptions = {"_p_lldb__SBCommandInterpreterRunOptions", "lldb::SBCommandInterpreterRunOptions *", 0, 0, (void*)&_wrap_class_SBCommandInterpreterRunOptions, 0}; +static swig_type_info _swigt__p_lldb__SBCommandReturnObject = {"_p_lldb__SBCommandReturnObject", "lldb::SBCommandReturnObject *", 0, 0, (void*)&_wrap_class_SBCommandReturnObject, 0}; +static swig_type_info _swigt__p_lldb__SBCommunication = {"_p_lldb__SBCommunication", "lldb::SBCommunication *", 0, 0, (void*)&_wrap_class_SBCommunication, 0}; +static swig_type_info _swigt__p_lldb__SBCompileUnit = {"_p_lldb__SBCompileUnit", "lldb::SBCompileUnit *", 0, 0, (void*)&_wrap_class_SBCompileUnit, 0}; +static swig_type_info _swigt__p_lldb__SBData = {"_p_lldb__SBData", "lldb::SBData *", 0, 0, (void*)&_wrap_class_SBData, 0}; +static swig_type_info _swigt__p_lldb__SBDebugger = {"_p_lldb__SBDebugger", "lldb::SBDebugger *", 0, 0, (void*)&_wrap_class_SBDebugger, 0}; +static swig_type_info _swigt__p_lldb__SBDeclaration = {"_p_lldb__SBDeclaration", "lldb::SBDeclaration *", 0, 0, (void*)&_wrap_class_SBDeclaration, 0}; +static swig_type_info _swigt__p_lldb__SBEnvironment = {"_p_lldb__SBEnvironment", "lldb::SBEnvironment *", 0, 0, (void*)&_wrap_class_SBEnvironment, 0}; +static swig_type_info _swigt__p_lldb__SBError = {"_p_lldb__SBError", "lldb::SBError *", 0, 0, (void*)&_wrap_class_SBError, 0}; +static swig_type_info _swigt__p_lldb__SBEvent = {"_p_lldb__SBEvent", "lldb::SBEvent *", 0, 0, (void*)&_wrap_class_SBEvent, 0}; +static swig_type_info _swigt__p_lldb__SBExecutionContext = {"_p_lldb__SBExecutionContext", "lldb::SBExecutionContext *", 0, 0, (void*)&_wrap_class_SBExecutionContext, 0}; +static swig_type_info _swigt__p_lldb__SBExpressionOptions = {"_p_lldb__SBExpressionOptions", "lldb::SBExpressionOptions *", 0, 0, (void*)&_wrap_class_SBExpressionOptions, 0}; +static swig_type_info _swigt__p_lldb__SBFile = {"_p_lldb__SBFile", "lldb::SBFile *", 0, 0, (void*)&_wrap_class_SBFile, 0}; +static swig_type_info _swigt__p_lldb__SBFileSpec = {"_p_lldb__SBFileSpec", "lldb::SBFileSpec *", 0, 0, (void*)&_wrap_class_SBFileSpec, 0}; +static swig_type_info _swigt__p_lldb__SBFileSpecList = {"_p_lldb__SBFileSpecList", "lldb::SBFileSpecList *", 0, 0, (void*)&_wrap_class_SBFileSpecList, 0}; +static swig_type_info _swigt__p_lldb__SBFormat = {"_p_lldb__SBFormat", "lldb::SBFormat *", 0, 0, (void*)&_wrap_class_SBFormat, 0}; +static swig_type_info _swigt__p_lldb__SBFrame = {"_p_lldb__SBFrame", "lldb::SBFrame *", 0, 0, (void*)&_wrap_class_SBFrame, 0}; +static swig_type_info _swigt__p_lldb__SBFunction = {"_p_lldb__SBFunction", "lldb::SBFunction *", 0, 0, (void*)&_wrap_class_SBFunction, 0}; +static swig_type_info _swigt__p_lldb__SBHostOS = {"_p_lldb__SBHostOS", "lldb::SBHostOS *", 0, 0, (void*)&_wrap_class_SBHostOS, 0}; +static swig_type_info _swigt__p_lldb__SBInstruction = {"_p_lldb__SBInstruction", "lldb::SBInstruction *", 0, 0, (void*)&_wrap_class_SBInstruction, 0}; +static swig_type_info _swigt__p_lldb__SBInstructionList = {"_p_lldb__SBInstructionList", "lldb::SBInstructionList *", 0, 0, (void*)&_wrap_class_SBInstructionList, 0}; +static swig_type_info _swigt__p_lldb__SBLanguageRuntime = {"_p_lldb__SBLanguageRuntime", "lldb::SBLanguageRuntime *", 0, 0, (void*)&_wrap_class_SBLanguageRuntime, 0}; +static swig_type_info _swigt__p_lldb__SBLaunchInfo = {"_p_lldb__SBLaunchInfo", "lldb::SBLaunchInfo *", 0, 0, (void*)&_wrap_class_SBLaunchInfo, 0}; +static swig_type_info _swigt__p_lldb__SBLineEntry = {"_p_lldb__SBLineEntry", "lldb::SBLineEntry *", 0, 0, (void*)&_wrap_class_SBLineEntry, 0}; +static swig_type_info _swigt__p_lldb__SBListener = {"_p_lldb__SBListener", "lldb::SBListener *", 0, 0, (void*)&_wrap_class_SBListener, 0}; +static swig_type_info _swigt__p_lldb__SBMemoryRegionInfo = {"_p_lldb__SBMemoryRegionInfo", "lldb::SBMemoryRegionInfo *", 0, 0, (void*)&_wrap_class_SBMemoryRegionInfo, 0}; +static swig_type_info _swigt__p_lldb__SBMemoryRegionInfoList = {"_p_lldb__SBMemoryRegionInfoList", "lldb::SBMemoryRegionInfoList *", 0, 0, (void*)&_wrap_class_SBMemoryRegionInfoList, 0}; +static swig_type_info _swigt__p_lldb__SBModule = {"_p_lldb__SBModule", "lldb::SBModule *", 0, 0, (void*)&_wrap_class_SBModule, 0}; +static swig_type_info _swigt__p_lldb__SBModuleSpec = {"_p_lldb__SBModuleSpec", "lldb::SBModuleSpec *", 0, 0, (void*)&_wrap_class_SBModuleSpec, 0}; +static swig_type_info _swigt__p_lldb__SBModuleSpecList = {"_p_lldb__SBModuleSpecList", "lldb::SBModuleSpecList *", 0, 0, (void*)&_wrap_class_SBModuleSpecList, 0}; +static swig_type_info _swigt__p_lldb__SBPlatform = {"_p_lldb__SBPlatform", "lldb::SBPlatform *", 0, 0, (void*)&_wrap_class_SBPlatform, 0}; +static swig_type_info _swigt__p_lldb__SBPlatformConnectOptions = {"_p_lldb__SBPlatformConnectOptions", "lldb::SBPlatformConnectOptions *", 0, 0, (void*)&_wrap_class_SBPlatformConnectOptions, 0}; +static swig_type_info _swigt__p_lldb__SBPlatformShellCommand = {"_p_lldb__SBPlatformShellCommand", "lldb::SBPlatformShellCommand *", 0, 0, (void*)&_wrap_class_SBPlatformShellCommand, 0}; +static swig_type_info _swigt__p_lldb__SBProcess = {"_p_lldb__SBProcess", "lldb::SBProcess *", 0, 0, (void*)&_wrap_class_SBProcess, 0}; +static swig_type_info _swigt__p_lldb__SBProcessInfo = {"_p_lldb__SBProcessInfo", "lldb::SBProcessInfo *", 0, 0, (void*)&_wrap_class_SBProcessInfo, 0}; +static swig_type_info _swigt__p_lldb__SBProcessInfoList = {"_p_lldb__SBProcessInfoList", "lldb::SBProcessInfoList *", 0, 0, (void*)&_wrap_class_SBProcessInfoList, 0}; +static swig_type_info _swigt__p_lldb__SBQueue = {"_p_lldb__SBQueue", "lldb::SBQueue *", 0, 0, (void*)&_wrap_class_SBQueue, 0}; +static swig_type_info _swigt__p_lldb__SBQueueItem = {"_p_lldb__SBQueueItem", "lldb::SBQueueItem *", 0, 0, (void*)&_wrap_class_SBQueueItem, 0}; +static swig_type_info _swigt__p_lldb__SBReproducer = {"_p_lldb__SBReproducer", "lldb::SBReproducer *", 0, 0, (void*)&_wrap_class_SBReproducer, 0}; +static swig_type_info _swigt__p_lldb__SBSaveCoreOptions = {"_p_lldb__SBSaveCoreOptions", "lldb::SBSaveCoreOptions *", 0, 0, (void*)&_wrap_class_SBSaveCoreOptions, 0}; +static swig_type_info _swigt__p_lldb__SBScriptObject = {"_p_lldb__SBScriptObject", "lldb::SBScriptObject *", 0, 0, (void*)&_wrap_class_SBScriptObject, 0}; +static swig_type_info _swigt__p_lldb__SBSection = {"_p_lldb__SBSection", "lldb::SBSection *", 0, 0, (void*)&_wrap_class_SBSection, 0}; +static swig_type_info _swigt__p_lldb__SBSourceManager = {"_p_lldb__SBSourceManager", "lldb::SBSourceManager *", 0, 0, (void*)&_wrap_class_SBSourceManager, 0}; +static swig_type_info _swigt__p_lldb__SBStatisticsOptions = {"_p_lldb__SBStatisticsOptions", "lldb::SBStatisticsOptions *", 0, 0, (void*)&_wrap_class_SBStatisticsOptions, 0}; +static swig_type_info _swigt__p_lldb__SBStream = {"_p_lldb__SBStream", "lldb::SBStream *", 0, 0, (void*)&_wrap_class_SBStream, 0}; +static swig_type_info _swigt__p_lldb__SBStringList = {"_p_lldb__SBStringList", "lldb::SBStringList *", 0, 0, (void*)&_wrap_class_SBStringList, 0}; +static swig_type_info _swigt__p_lldb__SBStructuredData = {"_p_lldb__SBStructuredData", "lldb::SBStructuredData *", 0, 0, (void*)&_wrap_class_SBStructuredData, 0}; +static swig_type_info _swigt__p_lldb__SBSymbol = {"_p_lldb__SBSymbol", "lldb::SBSymbol *", 0, 0, (void*)&_wrap_class_SBSymbol, 0}; +static swig_type_info _swigt__p_lldb__SBSymbolContext = {"_p_lldb__SBSymbolContext", "lldb::SBSymbolContext *", 0, 0, (void*)&_wrap_class_SBSymbolContext, 0}; +static swig_type_info _swigt__p_lldb__SBSymbolContextList = {"_p_lldb__SBSymbolContextList", "lldb::SBSymbolContextList *", 0, 0, (void*)&_wrap_class_SBSymbolContextList, 0}; +static swig_type_info _swigt__p_lldb__SBTarget = {"_p_lldb__SBTarget", "lldb::SBTarget *", 0, 0, (void*)&_wrap_class_SBTarget, 0}; +static swig_type_info _swigt__p_lldb__SBThread = {"_p_lldb__SBThread", "lldb::SBThread *", 0, 0, (void*)&_wrap_class_SBThread, 0}; +static swig_type_info _swigt__p_lldb__SBThreadCollection = {"_p_lldb__SBThreadCollection", "lldb::SBThreadCollection *", 0, 0, (void*)&_wrap_class_SBThreadCollection, 0}; +static swig_type_info _swigt__p_lldb__SBThreadPlan = {"_p_lldb__SBThreadPlan", "lldb::SBThreadPlan *", 0, 0, (void*)&_wrap_class_SBThreadPlan, 0}; +static swig_type_info _swigt__p_lldb__SBTrace = {"_p_lldb__SBTrace", "lldb::SBTrace *", 0, 0, (void*)&_wrap_class_SBTrace, 0}; +static swig_type_info _swigt__p_lldb__SBTraceCursor = {"_p_lldb__SBTraceCursor", "lldb::SBTraceCursor *", 0, 0, (void*)&_wrap_class_SBTraceCursor, 0}; +static swig_type_info _swigt__p_lldb__SBType = {"_p_lldb__SBType", "lldb::SBType *", 0, 0, (void*)&_wrap_class_SBType, 0}; +static swig_type_info _swigt__p_lldb__SBTypeCategory = {"_p_lldb__SBTypeCategory", "lldb::SBTypeCategory *", 0, 0, (void*)&_wrap_class_SBTypeCategory, 0}; +static swig_type_info _swigt__p_lldb__SBTypeEnumMember = {"_p_lldb__SBTypeEnumMember", "lldb::SBTypeEnumMember *", 0, 0, (void*)&_wrap_class_SBTypeEnumMember, 0}; +static swig_type_info _swigt__p_lldb__SBTypeEnumMemberList = {"_p_lldb__SBTypeEnumMemberList", "lldb::SBTypeEnumMemberList *", 0, 0, (void*)&_wrap_class_SBTypeEnumMemberList, 0}; +static swig_type_info _swigt__p_lldb__SBTypeFilter = {"_p_lldb__SBTypeFilter", "lldb::SBTypeFilter *", 0, 0, (void*)&_wrap_class_SBTypeFilter, 0}; +static swig_type_info _swigt__p_lldb__SBTypeFormat = {"_p_lldb__SBTypeFormat", "lldb::SBTypeFormat *", 0, 0, (void*)&_wrap_class_SBTypeFormat, 0}; +static swig_type_info _swigt__p_lldb__SBTypeList = {"_p_lldb__SBTypeList", "lldb::SBTypeList *", 0, 0, (void*)&_wrap_class_SBTypeList, 0}; +static swig_type_info _swigt__p_lldb__SBTypeMember = {"_p_lldb__SBTypeMember", "lldb::SBTypeMember *", 0, 0, (void*)&_wrap_class_SBTypeMember, 0}; +static swig_type_info _swigt__p_lldb__SBTypeMemberFunction = {"_p_lldb__SBTypeMemberFunction", "lldb::SBTypeMemberFunction *", 0, 0, (void*)&_wrap_class_SBTypeMemberFunction, 0}; +static swig_type_info _swigt__p_lldb__SBTypeNameSpecifier = {"_p_lldb__SBTypeNameSpecifier", "lldb::SBTypeNameSpecifier *", 0, 0, (void*)&_wrap_class_SBTypeNameSpecifier, 0}; +static swig_type_info _swigt__p_lldb__SBTypeStaticField = {"_p_lldb__SBTypeStaticField", "lldb::SBTypeStaticField *", 0, 0, (void*)&_wrap_class_SBTypeStaticField, 0}; +static swig_type_info _swigt__p_lldb__SBTypeSummary = {"_p_lldb__SBTypeSummary", "lldb::SBTypeSummary *", 0, 0, (void*)&_wrap_class_SBTypeSummary, 0}; +static swig_type_info _swigt__p_lldb__SBTypeSummaryOptions = {"_p_lldb__SBTypeSummaryOptions", "lldb::SBTypeSummaryOptions *", 0, 0, (void*)&_wrap_class_SBTypeSummaryOptions, 0}; +static swig_type_info _swigt__p_lldb__SBTypeSynthetic = {"_p_lldb__SBTypeSynthetic", "lldb::SBTypeSynthetic *", 0, 0, (void*)&_wrap_class_SBTypeSynthetic, 0}; +static swig_type_info _swigt__p_lldb__SBUnixSignals = {"_p_lldb__SBUnixSignals", "lldb::SBUnixSignals *", 0, 0, (void*)&_wrap_class_SBUnixSignals, 0}; +static swig_type_info _swigt__p_lldb__SBValue = {"_p_lldb__SBValue", "lldb::SBValue *", 0, 0, (void*)&_wrap_class_SBValue, 0}; +static swig_type_info _swigt__p_lldb__SBValueList = {"_p_lldb__SBValueList", "lldb::SBValueList *", 0, 0, (void*)&_wrap_class_SBValueList, 0}; +static swig_type_info _swigt__p_lldb__SBVariablesOptions = {"_p_lldb__SBVariablesOptions", "lldb::SBVariablesOptions *", 0, 0, (void*)&_wrap_class_SBVariablesOptions, 0}; +static swig_type_info _swigt__p_lldb__SBWatchpoint = {"_p_lldb__SBWatchpoint", "lldb::SBWatchpoint *", 0, 0, (void*)&_wrap_class_SBWatchpoint, 0}; +static swig_type_info _swigt__p_lldb__SBWatchpointOptions = {"_p_lldb__SBWatchpointOptions", "lldb::SBWatchpointOptions *", 0, 0, (void*)&_wrap_class_SBWatchpointOptions, 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__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__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__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__SupportFile_t = {"_p_std__shared_ptrT_lldb_private__SupportFile_t", "lldb::SupportFileSP *|std::shared_ptr< lldb_private::SupportFile > *", 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__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__string = {"_p_std__string", "std::string *", 0, 0, (void*)&_wrap_class_string, 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__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__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__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__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::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", "lldb::ScriptObjectPtr|void *", 0, 0, (void*)0, 0}; + +static swig_type_info *swig_type_initial[] = { + &_swigt__p_bool, + &_swigt__p_double, + &_swigt__p_f_p_q_const__char_p_void__void, + &_swigt__p_f_p_void__p_void, + &_swigt__p_f_p_void_p_p_q_const__char__bool, + &_swigt__p_f_p_void_p_q_const__void_size_t__void, + &_swigt__p_f_p_void_r_q_const__lldb__SBModuleSpec_r_lldb__SBFileSpec_r_lldb__SBFileSpec__lldb__SBError, + &_swigt__p_f_unsigned_long_long_p_void__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__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__SBPlatform, + &_swigt__p_lldb__SBPlatformConnectOptions, + &_swigt__p_lldb__SBPlatformShellCommand, + &_swigt__p_lldb__SBProcess, + &_swigt__p_lldb__SBProcessInfo, + &_swigt__p_lldb__SBProcessInfoList, + &_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__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__ScriptedMetadata_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__SupportFile_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__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__string, + &_swigt__p_std__unique_ptrT_lldb_private__AddressRange_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__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__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__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_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_f_p_q_const__char_p_void__void[] = { {&_swigt__p_f_p_q_const__char_p_void__void, 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_p_q_const__char__bool[] = { {&_swigt__p_f_p_void_p_p_q_const__char__bool, 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_f_p_void_r_q_const__lldb__SBModuleSpec_r_lldb__SBFileSpec_r_lldb__SBFileSpec__lldb__SBError[] = { {&_swigt__p_f_p_void_r_q_const__lldb__SBModuleSpec_r_lldb__SBFileSpec_r_lldb__SBFileSpec__lldb__SBError, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_f_unsigned_long_long_p_void__void[] = { {&_swigt__p_f_unsigned_long_long_p_void__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__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__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__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__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__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__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__SupportFile_t[] = { {&_swigt__p_std__shared_ptrT_lldb_private__SupportFile_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__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__string[] = { {&_swigt__p_std__string, 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__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__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__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__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_double, + _swigc__p_f_p_q_const__char_p_void__void, + _swigc__p_f_p_void__p_void, + _swigc__p_f_p_void_p_p_q_const__char__bool, + _swigc__p_f_p_void_p_q_const__void_size_t__void, + _swigc__p_f_p_void_r_q_const__lldb__SBModuleSpec_r_lldb__SBFileSpec_r_lldb__SBFileSpec__lldb__SBError, + _swigc__p_f_unsigned_long_long_p_void__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__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__SBPlatform, + _swigc__p_lldb__SBPlatformConnectOptions, + _swigc__p_lldb__SBPlatformShellCommand, + _swigc__p_lldb__SBProcess, + _swigc__p_lldb__SBProcessInfo, + _swigc__p_lldb__SBProcessInfoList, + _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__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__ScriptedMetadata_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__SupportFile_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__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__string, + _swigc__p_std__unique_ptrT_lldb_private__AddressRange_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__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__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__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) -------- */ + +/* ----------------------------------------------------------------------------- + * Type initialization: + * This problem is 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 linked list. 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. So to actually build the cast linked list, + * we find the array of casts associated with the type, and loop through it + * adding the casts to the list. The one last 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 linked list (because the cast->type) pointer will + * be correct. + * ----------------------------------------------------------------------------- */ + +#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 + +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 *ret; + swig_cast_info *cast; + +#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 = swig_module.cast_initial[i]; + while (cast->type) { + + /* Don't need to add information already in the list */ + ret = 0; +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: look cast %s\n", cast->type->name); +#endif + if (swig_module.next != &swig_module) { + ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name); +#ifdef SWIGRUNTIME_DEBUG + if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name); +#endif + } + if (ret) { + if (type == swig_module.type_initial[i]) { +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: skip old type %s\n", ret->name); +#endif + cast->type = ret; + ret = 0; + } else { + /* Check for casting already in the list */ + swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type); +#ifdef SWIGRUNTIME_DEBUG + if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name); +#endif + if (!ocast) ret = 0; + } + } + + if (!ret) { +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name); +#endif + if (type->cast) { + type->cast->prev = cast; + cast->next = type->cast; + } + type->cast = 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; + swig_cast_info *equiv; + 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) { + equiv = swig_module.types[i]->cast; + while (equiv) { + if (!equiv->converter) { + if (equiv->type && !equiv->type->clientdata) + SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata); + } + equiv = equiv->next; + } + } + } +} + +#ifdef __cplusplus +#if 0 +{ /* c-mode */ +#endif +} +#endif + + + +/* Forward declaration of where the user's %init{} gets inserted */ +void SWIG_init_user(lua_State* L ); + +#ifdef __cplusplus +extern "C" { +#endif +/* this is the initialization function + added at the very end of the code + the function is always called SWIG_init, but an earlier #define will rename it +*/ +#if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)) +LUALIB_API int SWIG_init(lua_State* L) +#else +SWIGEXPORT int SWIG_init(lua_State* L) /* default Lua action */ +#endif +{ +#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC) /* valid for both Lua and eLua */ + int i; + int globalRegister = 0; + /* start with global table */ + lua_pushglobaltable (L); + /* SWIG's internal initialisation */ + SWIG_InitializeModule((void*)L); + SWIG_PropagateClientData(); +#endif + +#if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)) || defined(SWIG_LUA_ELUA_EMULATE) + /* add a global fn */ + SWIG_Lua_add_function(L,"swig_type",SWIG_Lua_type); + SWIG_Lua_add_function(L,"swig_equals",SWIG_Lua_class_equal); +#endif + +#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC) + /* set up base class pointers (the hierarchy) */ + for (i = 0; swig_types[i]; i++){ + if (swig_types[i]->clientdata){ + SWIG_Lua_init_base_class(L,(swig_lua_class*)(swig_types[i]->clientdata)); + } + } +#ifdef SWIG_LUA_MODULE_GLOBAL + globalRegister = 1; +#endif + + +#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) + SWIG_Lua_namespace_register(L,&swig_SwigModule, globalRegister); +#endif + +#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) + for (i = 0; swig_types[i]; i++){ + if (swig_types[i]->clientdata){ + SWIG_Lua_elua_class_register_instance(L,(swig_lua_class*)(swig_types[i]->clientdata)); + } + } +#endif + +#if defined(SWIG_LUA_ELUA_EMULATE) + lua_newtable(L); + SWIG_Lua_elua_emulate_register(L,swig_SwigModule.ns_methods); + SWIG_Lua_elua_emulate_register_clear(L); + if(globalRegister) { + lua_pushstring(L,swig_SwigModule.name); + lua_pushvalue(L,-2); + lua_rawset(L,-4); + } +#endif + +#endif + +#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC) + /* invoke user-specific initialization */ + SWIG_init_user(L); + /* end module */ + /* Note: We do not clean up the stack here (Lua will do this for us). At this + point, we have the globals table and out module table on the stack. Returning + one value makes the module table the result of the require command. */ + return 1; +#else + return 0; +#endif +} + +#ifdef __cplusplus +} +#endif + + +const char* SWIG_LUACODE= + ""; + +void SWIG_init_user(lua_State* L) +{ + /* exec Lua code if applicable */ + SWIG_Lua_dostring(L,SWIG_LUACODE); +} + |