Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- /* ----------------------------------------------------------------------------
- * This file was automatically generated by SWIG (http://www.swig.org).
- * Version 3.0.0
- *
- * This file is not intended to be easily readable and contains a number of
- * coding conventions designed to improve portability and efficiency. Do not make
- * changes to this file unless you know what you are doing--modify the SWIG
- * interface file instead.
- * ----------------------------------------------------------------------------- */
- #define SWIGLUA
- #define SWIG_LUA_TARGET SWIG_LUA_FLAVOR_LUA
- #define SWIG_LUA_MODULE_GLOBAL
- #ifdef __cplusplus
- /* SwigValueWrapper is described in swig.swg */
- template<typename T> class SwigValueWrapper {
- struct SwigMovePointer {
- T *ptr;
- SwigMovePointer(T *p) : ptr(p) { }
- ~SwigMovePointer() { delete ptr; }
- SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
- } pointer;
- SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
- SwigValueWrapper(const SwigValueWrapper<T>& rhs);
- public:
- SwigValueWrapper() : pointer(0) { }
- SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
- operator T&() const { return *pointer.ptr; }
- T *operator&() { return pointer.ptr; }
- };
- template <typename T> T SwigValueInit() {
- return T();
- }
- #endif
- /* -----------------------------------------------------------------------------
- * 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 (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
- # ifndef GCC_HASCLASSVISIBILITY
- # define GCC_HASCLASSVISIBILITY
- # 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
- /* -----------------------------------------------------------------------------
- * 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
- /* 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 to return 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)
- #define SWIG_ERROR (-1)
- #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 temporal 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 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(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. We choose
- to print the last name, as it is often (?) the most
- specific. */
- 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 = ((d - '0') << 4);
- else if ((d >= 'a') && (d <= 'f'))
- uu = ((d - ('a'-10)) << 4);
- else
- return (char *) 0;
- d = *(c++);
- if ((d >= '0') && (d <= '9'))
- uu |= (d - '0');
- else if ((d >= 'a') && (d <= 'f'))
- uu |= (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
- /* -----------------------------------------------------------------------------
- * 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_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 the location of the innermost Lua call-point
- (as formated 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 the
- location of the innermost Lua call-point (as formated 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]; /* arbitary 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) \
- if (!(expr)) { SWIG_Lua_pusherrstring(L, (char *) msg); goto fail; } else
- /* 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))
- /* 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)
- {
- assert(lua_istable(L,-1));
- int 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));
- }
- int parsed_tables_array = lua_gettop(L);
- lua_pushvalue(L,target_table);
- lua_rawsetp(L, parsed_tables_array, table);
- int i;
- int table_parsed = 0;
- int 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 = 0;
- /* 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)
- {
- /* There must be a module/namespace table at the top of the stack */
- assert(lua_istable(L,-1));
- swig_lua_class **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)
- {
- /* 1 argument - table on the top of the stack */
- int 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);
- swig_lua_namespace **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);
- /* Macros for iteration among class bases */
- #if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA)
- #define SWIG_LUA_INIT_BASE_SEARCH(bases_count)\
- SWIG_Lua_get_table(L,".bases");\
- assert(lua_istable(L,-1));\
- bases_count = lua_rawlen(L,-1);\
- int bases_table = lua_gettop(L);
- #define SWIG_LUA_GET_BASE_METATABLE(i,base_swig_type, valid)\
- 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 /* en elua .bases table doesn't exist. Use table from swig_lua_class */
- #define SWIG_LUA_INIT_BASE_SEARCH(bases_count)\
- 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 */
- #define SWIG_LUA_GET_BASE_METATABLE(i,base_swig_type, valid)\
- 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
- 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 *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 */
- lua_getmetatable(L,first_arg);
- int original_metatable = last_arg + 1;
- int bases_count;
- SWIG_LUA_INIT_BASE_SEARCH(bases_count);
- int result = SWIG_ERROR;
- if(ret)
- *ret = 0;
- if(bases_count>0)
- {
- int i;
- int j;
- int subcall_first_arg = lua_gettop(L) + 1;/* Here a copy of first_arg and arguments begin */
- int valid = 1;
- for(j=first_arg;j<=last_arg;j++)
- lua_pushvalue(L,j);
- int subcall_last_arg = lua_gettop(L);
- swig_type_info *base_swig_type = 0;
- /* Trick: temporarily replacing original metatable with metatable for base class and call getter */
- for(i=0;i<bases_count;i++) {
- SWIG_LUA_GET_BASE_METATABLE(i,base_swig_type,valid);
- 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 */
- const int 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(lua_State *L, swig_type_info *type, int first_arg, int *ret)
- {
- /* there should be 2 params passed in
- (1) userdata (not the meta table)
- (2) string name of the attribute
- */
- int substack_start = lua_gettop(L)-2;
- assert(first_arg == substack_start+1);
- 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 its 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 */
- /* 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 its 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 */
- int 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
- */
- assert(lua_isuserdata(L,1));
- swig_lua_userdata *usr=(swig_lua_userdata*)lua_touserdata(L,1); /* get data */
- swig_type_info *type = usr->type;
- int ret = 0;
- int result = SWIG_Lua_class_do_get(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 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 its 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 */
- int 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
- */
- assert(lua_isuserdata(L,1));
- swig_lua_userdata *usr=(swig_lua_userdata*)lua_touserdata(L,1); /* get data */
- swig_type_info *type = usr->type;
- int ret = 0;
- int 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) */
- assert(lua_isuserdata(L,1)); /* just in case */
- unsigned long userData = (unsigned long)lua_touserdata(L,1); /* get the userdata address for later */
- lua_getmetatable(L,1); /* get the meta table */
- assert(lua_istable(L,-1)); /* just in case */
- lua_getfield(L, -1, ".type");
- const char *className = lua_tostring(L, -1);
- char output[256];
- snprintf(output, 255, "<%s userdata: %lX>", className, userData);
- lua_pushstring(L, (const char*)output);
- 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;
- }
- /* gets the swig class 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 */
- lua_pushstring(L,"SWIG");
- lua_newtable(L);
- lua_rawset(L,LUA_REGISTRYINDEX);
- /* then get it */
- lua_pushstring(L,"SWIG");
- lua_rawget(L,LUA_REGISTRYINDEX);
- }
- }
- /* 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 int 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 int 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 int 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 int 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);
- }
- /* 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;
- /* Add bases to .bases table */
- SWIG_Lua_get_table(L,".bases");
- assert(lua_istable(L,-1)); /* just in case */
- int bases_count = 0;
- 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);
- }
- }
- }
- /* 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)
- {
- int 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)
- {
- int begin = lua_gettop(L);
- /* 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 */
- int i = 0;
- 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++)
- {
- SWIG_Lua_get_class_metatable(L,clss->bases[i]->fqname);
- int 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 tostring method for better output */
- SWIG_Lua_add_function(L,"__tostring",SWIG_Lua_class_tostring);
- /* 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)
- {
- 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"
- */
- int 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)
- {
- int begin = lua_gettop(L);
- /* 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 */
- int i = 0;
- 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)
- {
- swig_lua_userdata *usr;
- swig_cast_info *cast;
- if (lua_isnil(L,index)){*ptr=0; return SWIG_OK;} /* special case: lua nil => NULL pointer */
- usr=(swig_lua_userdata*)lua_touserdata(L,index); /* get data */
- if (usr)
- {
- if (flags & SWIG_POINTER_DISOWN) /* must disown the object */
- {
- usr->own=0;
- }
- if (!type) /* special cast void*, no casting fn */
- {
- *ptr=usr->ptr;
- return SWIG_OK; /* ok */
- }
- cast=SWIG_TypeCheckStruct(usr->type,type); /* performs normal type checking */
- if (cast)
- {
- int newmemory = 0;
- *ptr=SWIG_TypeCast(cast,usr->ptr,&newmemory);
- assert(!newmemory); /* newmemory handling not yet implemented */
- return SWIG_OK; /* ok */
- }
- }
- return SWIG_ERROR; /* error */
- }
- SWIGRUNTIME void* SWIG_Lua_MustGetPtr(lua_State *L,int index,swig_type_info *type,int flags,
- int argnum,const char *func_name){
- void *result;
- 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;
- }
- /* 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_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;
- }
- /* -----------------------------------------------------------------------------
- * 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_pushnumber(L,(lua_Number)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);
- lua_pushfstring(L,"%c",(char)constants[i].lvalue);
- 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 its lua_dostring()
- In lua 5.1.X its 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) -------- */
- static swig_type_info *swig_types[1];
- static swig_module_info swig_module = {swig_types, 0, 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 "sample"
- #define SWIG_init luaopen_sample
- #define SWIG_init_user luaopen_sample_user
- #define SWIG_LUACODE luaopen_sample_luacode
- namespace swig {
- typedef struct{} LANGUAGE_OBJ;
- }
- #include "test.h"
- %{
- int Nibai(int b)
- {
- return b * 2;
- }
- #ifdef __cplusplus
- extern "C" {
- #endif
- static int _wrap_add(lua_State* L) {
- int SWIG_arg = 0;
- int arg1 ;
- int arg2 ;
- int result;
- SWIG_check_num_args("add",2,2)
- if(!lua_isnumber(L,1)) SWIG_fail_arg("add",1,"int");
- if(!lua_isnumber(L,2)) SWIG_fail_arg("add",2,"int");
- arg1 = (int)lua_tonumber(L, 1);
- arg2 = (int)lua_tonumber(L, 2);
- result = (int)add(arg1,arg2);
- lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
- return SWIG_arg;
- if(0) SWIG_fail;
- fail:
- lua_error(L);
- return SWIG_arg;
- }
- static int _wrap_sub(lua_State* L) {
- int SWIG_arg = 0;
- int arg1 ;
- int arg2 ;
- int result;
- SWIG_check_num_args("sub",2,2)
- if(!lua_isnumber(L,1)) SWIG_fail_arg("sub",1,"int");
- if(!lua_isnumber(L,2)) SWIG_fail_arg("sub",2,"int");
- arg1 = (int)lua_tonumber(L, 1);
- arg2 = (int)lua_tonumber(L, 2);
- result = (int)sub(arg1,arg2);
- lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
- return SWIG_arg;
- if(0) SWIG_fail;
- fail:
- lua_error(L);
- return SWIG_arg;
- }
- static int _wrap_Div(lua_State* L) {
- int SWIG_arg = 0;
- int arg1 ;
- int arg2 ;
- int result;
- SWIG_check_num_args("Div",2,2)
- if(!lua_isnumber(L,1)) SWIG_fail_arg("Div",1,"int");
- if(!lua_isnumber(L,2)) SWIG_fail_arg("Div",2,"int");
- arg1 = (int)lua_tonumber(L, 1);
- arg2 = (int)lua_tonumber(L, 2);
- result = (int)Div(arg1,arg2);
- lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
- return SWIG_arg;
- if(0) SWIG_fail;
- fail:
- lua_error(L);
- return SWIG_arg;
- }
- static int _wrap_Mod(lua_State* L) {
- int SWIG_arg = 0;
- int arg1 ;
- int arg2 ;
- int result;
- SWIG_check_num_args("Mod",2,2)
- if(!lua_isnumber(L,1)) SWIG_fail_arg("Mod",1,"int");
- if(!lua_isnumber(L,2)) SWIG_fail_arg("Mod",2,"int");
- arg1 = (int)lua_tonumber(L, 1);
- arg2 = (int)lua_tonumber(L, 2);
- result = (int)Mod(arg1,arg2);
- lua_pushnumber(L, (lua_Number) result); SWIG_arg++;
- return SWIG_arg;
- if(0) SWIG_fail;
- fail:
- lua_error(L);
- return SWIG_arg;
- }
- static swig_lua_attribute swig_SwigModule_attributes[] = {
- {0,0,0}
- };
- static swig_lua_const_info swig_SwigModule_constants[]= {
- {0,0,0,0,0,0}
- };
- static swig_lua_method swig_SwigModule_methods[]= {
- { "add", _wrap_add},
- { "sub", _wrap_sub},
- { "Div", _wrap_Div},
- { "Mod", _wrap_Mod},
- {0,0}
- };
- static swig_lua_class* swig_SwigModule_classes[]= {
- 0
- };
- static swig_lua_namespace* swig_SwigModule_namespaces[] = {
- 0
- };
- static swig_lua_method swig_SwigModule_meta[] = {
- {0,0}
- };
- static swig_lua_namespace swig_SwigModule = {
- "sample",
- 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 *swig_type_initial[] = {
- NULL
- };
- static swig_cast_info *swig_cast_initial[] = {
- NULL
- };
- /* -------- 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
- SWIGRUNTIME void
- SWIG_InitializeModule(void *clientdata) {
- size_t i;
- swig_module_info *module_head, *iter;
- int found, 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);
- module_head = &swig_module;
- } else {
- /* the interpreter has loaded a SWIG module, but has it loaded this one? */
- found=0;
- iter=module_head;
- do {
- if (iter==&swig_module) {
- found=1;
- break;
- }
- iter=iter->next;
- } while (iter!= module_head);
- /* if the is found in the list, then all is done and we may leave */
- if (found) return;
- /* otherwise we must add out 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 %d\n", 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 %d %s\n", 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 %d %s\n", 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;
- /* 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_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));
- }
- }
- int globalRegister = 0;
- #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___Module.ns_methods);
- SWIG_Lua_elua_emulate_register_clear(L);
- if(globalRegister) {
- lua_pushstring(L,swig___Module.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);
- }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement