/trunk/Lib/lua/luatypemaps.swg
Unknown | 389 lines | 325 code | 64 blank | 0 comment | 0 complexity | 3ce7a85025b85d8f00845adbec4f6d3e MD5 | raw file
Possible License(s): LGPL-2.1, Cube, GPL-3.0, 0BSD, GPL-2.0
- /* -----------------------------------------------------------------------------
- * luatypemaps.swg
- *
- * basic typemaps for Lua.
- * ----------------------------------------------------------------------------- */
- /* -----------------------------------------------------------------------------
- * standard typemaps
- * ----------------------------------------------------------------------------- */
- /* NEW LANGUAGE NOTE:
- the 'checkfn' param is something that I added for typemap(in)
- it is an optional fn call to check the type of the lua object
- the fn call must be of the form
- int checkfn(lua_State *L, int index);
- and return 1/0 depending upon if this is the correct type
- For the typemap(out), an additional SWIG_arg parmeter must be incremented
- to reflect the number of values returned (normally SWIG_arg++; will do)
- */
- // numbers
- %typemap(in,checkfn="lua_isnumber") int, short, long,
- signed char, float, double
- %{$1 = ($type)lua_tonumber(L, $input);%}
-
- // additional check for unsigned numbers, to not permit negative input
- %typemap(in,checkfn="lua_isnumber") unsigned int,
- unsigned short, unsigned long, unsigned char
- %{SWIG_contract_assert((lua_tonumber(L,$input)>=0),"number must not be negative")
- $1 = ($type)lua_tonumber(L, $input);%}
- %typemap(out) int,short,long,
- unsigned int,unsigned short,unsigned long,
- signed char,unsigned char,
- float,double
- %{ lua_pushnumber(L, (lua_Number) $1); SWIG_arg++;%}
- // we must also provide typemaps for privitives by const reference:
- // given a function:
- // int intbyref(const int& i);
- // SWIG assumes that this code will need a pointer to int to be passed in
- // (this might be ok for objects by const ref, but not for numeric primitives)
- // therefore we add a set of typemaps to fix this (for both in & out)
- %typemap(in,checkfn="lua_isnumber") const int&($basetype temp)
- %{ temp=($basetype)lua_tonumber(L,$input); $1=&temp;%}
- %typemap(in,checkfn="lua_isnumber") const unsigned int&($basetype temp)
- %{SWIG_contract_assert((lua_tonumber(L,$input)>=0),"number must not be negative")
- temp=($basetype)lua_tonumber(L,$input); $1=&temp;%}
- %typemap(out) const int&, const unsigned int&
- %{ lua_pushnumber(L, (lua_Number) *$1); SWIG_arg++;%}
- // for the other numbers we can just use an apply statement to cover them
- %apply const int & {const short&,const long&,const signed char&,
- const float&,const double&};
- %apply const unsigned int & {const unsigned short&,const unsigned long&,
- const unsigned char&};
- /* enums have to be handled slightly differently
- VC++ .net will not allow a cast from lua_Number(double) to enum directly.
- */
- %typemap(in,checkfn="lua_isnumber") enum SWIGTYPE
- %{$1 = ($type)(int)lua_tonumber(L, $input);%}
- %typemap(out) enum SWIGTYPE
- %{ lua_pushnumber(L, (lua_Number)(int)($1)); SWIG_arg++;%}
- // and const refs
- %typemap(in,checkfn="lua_isnumber") const enum SWIGTYPE &($basetype temp)
- %{ temp=($basetype)(int)lua_tonumber(L,$input); $1=&temp;%}
- %typemap(out) const enum SWIGTYPE &
- %{ lua_pushnumber(L, (lua_Number) *$1); SWIG_arg++;%}
- // boolean (which is a special type in lua)
- // note: lua_toboolean() returns 1 or 0
- // note: 1 & 0 are not booleans in lua, only true & false
- %typemap(in,checkfn="lua_isboolean") bool
- %{$1 = (lua_toboolean(L, $input)!=0);%}
- %typemap(out) bool
- %{ lua_pushboolean(L,(int)($1!=0)); SWIG_arg++;%}
- // for const bool&, SWIG treats this as a const bool* so we must dereference it
- %typemap(in,checkfn="lua_isboolean") const bool& (bool temp)
- %{temp=(lua_toboolean(L, $input)!=0);
- $1=&temp;%}
- %typemap(out) const bool&
- %{ lua_pushboolean(L,(int)((*$1)!=0)); SWIG_arg++;%}
- // strings (char * and char[])
- %fragment("SWIG_lua_isnilstring", "header") {
- 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;
- }
- }
- %typemap(in,checkfn="SWIG_lua_isnilstring",fragment="SWIG_lua_isnilstring") const char *, char *
- %{$1 = ($ltype)lua_tostring(L, $input);%}
- %typemap(in,checkfn="SWIG_lua_isnilstring",fragment="SWIG_lua_isnilstring") const char[ANY], char[ANY]
- %{$1 = ($ltype)lua_tostring(L, $input);%}
- %typemap(out) const char *, char *
- %{ lua_pushstring(L,(const char *)$1); SWIG_arg++;%}
- %typemap(out) const char[ANY], char[ANY]
- %{ lua_pushstring(L,(const char *)$1); SWIG_arg++;%}
- // char's
- // currently treating chars as small strings, not as numbers
- // (however signed & unsigned char's are numbers...)
- %typemap(in,checkfn="SWIG_lua_isnilstring",fragment="SWIG_lua_isnilstring") char
- %{$1 = (lua_tostring(L, $input))[0];%}
- %typemap(out) char
- %{ lua_pushfstring(L,"%c",$1); SWIG_arg++;%}
- // by const ref
- %typemap(in,checkfn="SWIG_lua_isnilstring",fragment="SWIG_lua_isnilstring") const char& (char temp)
- %{temp = (lua_tostring(L, $input))[0]; $1=&temp;%}
- %typemap(out) const char&
- %{ lua_pushfstring(L,"%c",*$1); SWIG_arg++;%}
- // pointers and references
- // under SWIG rules, it is ok, to have a pass in a lua nil,
- // it should be converted to a SWIG NULL.
- // This will only be allowed for pointers & arrays, not refs or by value
- // the checkfn lua_isuserdata will only work for userdata
- // the checkfn SWIG_isptrtype will work for both userdata and nil's
- %typemap(in,checkfn="SWIG_isptrtype") SWIGTYPE*,SWIGTYPE[]
- %{
- if (!SWIG_IsOK(SWIG_ConvertPtr(L,$input,(void**)&$1,$descriptor,$disown))){
- SWIG_fail_ptr("$symname",$argnum,$descriptor);
- }
- %}
- %typemap(in,checkfn="lua_isuserdata") SWIGTYPE&
- %{
- if (!SWIG_IsOK(SWIG_ConvertPtr(L,$input,(void**)&$1,$descriptor,$disown))){
- SWIG_fail_ptr("$symname",$argnum,$descriptor);
- }
- %}
- // out is simple
- %typemap(out) SWIGTYPE*,SWIGTYPE&
- %{SWIG_NewPointerObj(L,$1,$descriptor,$owner); SWIG_arg++; %}
- // dynamic casts
- // this uses the SWIG_TypeDynamicCast() which relies on RTTI to find out what the pointer really is
- // the we return it as the correct type
- %typemap(out) SWIGTYPE *DYNAMIC,
- SWIGTYPE &DYNAMIC
- {
- swig_type_info *ty = SWIG_TypeDynamicCast($1_descriptor, (void **) &$1);
- SWIG_NewPointerObj(L,(void*)$1,ty,$owner); SWIG_arg++;
- }
- // passing objects by value
- // SWIG_ConvertPtr wants an object pointer (the $<ype argp)
- // then dereferences it to get the object
- %typemap(in,checkfn="lua_isuserdata") SWIGTYPE ($<ype argp)
- %{
- if (!SWIG_IsOK(SWIG_ConvertPtr(L,$input,(void**)&argp,$&descriptor,0))){
- SWIG_fail_ptr("$symname",$argnum,$&descriptor);
- }
- $1 = *argp;
- %}
- // Also needed for object ptrs by const ref
- // eg A* const& ref_pointer(A* const& a);
- // found in mixed_types.i
- %typemap(in,checkfn="lua_isuserdata") SWIGTYPE *const&($*ltype temp)
- %{temp=($*ltype)SWIG_MustGetPtr(L,$input,$*descriptor,0,$argnum,"$symname");
- $1=($1_ltype)&temp;%}
- %typemap(out) SWIGTYPE *const&
- %{SWIG_NewPointerObj(L,*$1,$*descriptor,$owner); SWIG_arg++; %}
- // DISOWN-ing typemaps
- // if you have an object pointer which must be disowned, use this typemap
- // eg. for void destroy_foo(Foo* toDie);
- // use %apply SWIGTYPE* DISOWN {Foo* toDie};
- // you could just use %delobject, but this is more flexible
- %typemap(in,checkfn="SWIG_isptrtype") SWIGTYPE* DISOWN,SWIGTYPE DISOWN[]
- %{ if (!SWIG_IsOK(SWIG_ConvertPtr(L,$input,(void**)&$1,$descriptor,SWIG_POINTER_DISOWN))){
- SWIG_fail_ptr("$symname",$argnum,$descriptor);
- }
- %}
- // Primitive types--return by value
- // must make a new object, copy the data & return the new object
- // Note: the brackets are {...} and not %{..%}, because we want them to be included in the wrapper
- // this is because typemap(out) does not support local variables, like in typemap(in) does
- // and we need the $&1_ltype resultptr; to be declared
- #ifdef __cplusplus
- %typemap(out) SWIGTYPE
- {
- $&1_ltype resultptr = new $1_ltype((const $1_ltype &) $1);
- SWIG_NewPointerObj(L,(void *) resultptr,$&1_descriptor,1); SWIG_arg++;
- }
- #else
- %typemap(out) SWIGTYPE
- {
- $&1_ltype resultptr;
- resultptr = ($&1_ltype) malloc(sizeof($1_type));
- memmove(resultptr, &$1, sizeof($1_type));
- SWIG_NewPointerObj(L,(void *) resultptr,$&1_descriptor,1); SWIG_arg++;
- }
- #endif
- // member function pointer
- // a member fn ptr is not 4 bytes like a normal pointer, but 8 bytes (at least on mingw)
- // so the standard wrappering cannot be done
- // nor can you cast a member function pointer to a void* (obviously)
- // therefore a special wrappering functions SWIG_ConvertMember() & SWIG_NewMemberObj() were written
- #ifdef __cplusplus
- %typemap(in,checkfn="lua_isuserdata") SWIGTYPE (CLASS::*)
- %{
- if (!SWIG_IsOK(SWIG_ConvertMember(L,$input,(void*)(&$1),sizeof($type),$descriptor)))
- SWIG_fail_ptr("$symname",$argnum,$descriptor);
- %}
- %typemap(out) SWIGTYPE (CLASS::*)
- %{
- SWIG_NewMemberObj(L,(void*)(&$1),sizeof($type),$descriptor); SWIG_arg++;
- %}
- #endif
- // void (must be empty without the SWIG_arg++)
- %typemap(out) void "";
- /* void* is a special case
- A function void fn(void*) should take any kind of pointer as a parameter (just like C/C++ does)
- but if its an output, then it should be wrappered like any other SWIG object (using default typemap)
- */
- %typemap(in,checkfn="SWIG_isptrtype") void*
- %{$1=($1_ltype)SWIG_MustGetPtr(L,$input,0,0,$argnum,"$symname");%}
- /* long long is another special case:
- as lua only supports one numeric type (lua_Number), we will just
- cast it to that & accept the loss of precision.
- An alternative solution would be a long long struct or class
- with the relevant operators.
- */
- %apply long {long long, signed long long, unsigned long long};
- %apply const long& {const long long&, const signed long long&, const unsigned long long&};
- /* It is possible to also pass a lua_State* into a function, so
- void fn(int a, float b, lua_State* s) is wrappable as
- > fn(1,4.3) -- note: the state is implicitly passed in
- */
- %typemap(in, numinputs=0) lua_State*
- %{$1 = L;%}
- /* -----------------------------------------------------------------------------
- * typecheck rules
- * ----------------------------------------------------------------------------- */
- /* These are needed for the overloaded functions
- These define the detection routines which will spot what
- parmeters match which function
- */
- // unfortunately lua only considers one type of number
- // so all numbers (int,float,double) match
- // you could add an advanced fn to get type & check if its integral
- %typecheck(SWIG_TYPECHECK_INTEGER)
- int, short, long,
- unsigned int, unsigned short, unsigned long,
- signed char, unsigned char,
- long long, unsigned long long, signed long long,
- const int &, const short &, const long &,
- const unsigned int &, const unsigned short &, const unsigned long &,
- const signed char&, const unsigned char&,
- const long long &, const unsigned long long &,
- enum SWIGTYPE, const enum SWIGTYPE&,
- float, double, const float &, const double&
- {
- $1 = lua_isnumber(L,$input);
- }
- %typecheck(SWIG_TYPECHECK_BOOL)
- bool, const bool &
- {
- $1 = lua_isboolean(L,$input);
- }
- // special check for a char (string of length 1)
- %typecheck(SWIG_TYPECHECK_CHAR,fragment="SWIG_lua_isnilstring") char, const char& {
- $1 = SWIG_lua_isnilstring(L,$input) && (lua_strlen(L,$input)==1);
- }
- %typecheck(SWIG_TYPECHECK_STRING,fragment="SWIG_lua_isnilstring") char *, char[] {
- $1 = SWIG_lua_isnilstring(L,$input);
- }
- %typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE [] {
- void *ptr;
- if (SWIG_isptrtype(L,$input)==0 || SWIG_ConvertPtr(L,$input, (void **) &ptr, $1_descriptor, 0)) {
- $1 = 0;
- } else {
- $1 = 1;
- }
- }
- %typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE & {
- void *ptr;
- if (lua_isuserdata(L,$input)==0 || SWIG_ConvertPtr(L,$input, (void **) &ptr, $1_descriptor, 0)) {
- $1 = 0;
- } else {
- $1 = 1;
- }
- }
- %typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE {
- void *ptr;
- if (lua_isuserdata(L,$input)==0 || SWIG_ConvertPtr(L,$input, (void **) &ptr, $&1_descriptor, 0)) {
- $1 = 0;
- } else {
- $1 = 1;
- }
- }
- %typecheck(SWIG_TYPECHECK_VOIDPTR) void * {
- void *ptr;
- if (SWIG_isptrtype(L,$input)==0 || SWIG_ConvertPtr(L,$input, (void **) &ptr, 0, 0)) {
- $1 = 0;
- } else {
- $1 = 1;
- }
- }
- // Also needed for object ptrs by const ref
- // eg const A* ref_pointer(A* const& a);
- // found in mixed_types.i
- %typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *const&
- {
- void *ptr;
- if (lua_isuserdata(L,$input)==0 || SWIG_ConvertPtr(L,$input, (void **) &ptr, $*descriptor, 0)) {
- $1 = 0;
- } else {
- $1 = 1;
- }
- }
- /* -----------------------------------------------------------------------------
- * Others
- * ----------------------------------------------------------------------------- */
- // Array reference typemaps
- %apply SWIGTYPE & { SWIGTYPE ((&)[ANY]) }
- /* const pointers */
- %apply SWIGTYPE * { SWIGTYPE *const }
- // size_t (which is just a unsigned long)
- %apply unsigned long { size_t };
- %apply const unsigned long & { const size_t & };
- /* -----------------------------------------------------------------------------
- * Specials
- * ----------------------------------------------------------------------------- */
- // swig::LANGUAGE_OBJ was added to allow containers of native objects
- // however its rather difficult to do this in lua, as you cannot hold pointers
- // to native objects (they are held in the interpreter)
- // therefore for now: just ignoring this feature
- #ifdef __cplusplus
- %ignore swig::LANGUAGE_OBJ;
- //%inline %{
- %{
- namespace swig {
- typedef struct{} LANGUAGE_OBJ;
- }
- %}
- #endif // __cplusplus