/tags/rel-1-3-29/SWIG/Lib/lua/typemaps.i
Swig | 493 lines | 269 code | 42 blank | 182 comment | 0 complexity | 47f0a6cec0dd448da4393e2d6949c1e7 MD5 | raw file
Possible License(s): LGPL-2.1, Cube, GPL-3.0, 0BSD, GPL-2.0
- /* -----------------------------------------------------------------------------
- * See the LICENSE file for information on copyright, usage and redistribution
- * of SWIG, and the README file for authors - http://www.swig.org/release.html.
- *
- * typemaps.swg
- *
- * SWIG Library file containing the main typemap code to support Lua modules.
- * ----------------------------------------------------------------------------- */
- /* -----------------------------------------------------------------------------
- * Basic inout typemaps
- * ----------------------------------------------------------------------------- */
- /*
- These provide the basic ability for passing in & out of standard numeric data types
- (int,long,float,double, etc)
- The basic code looks like this:
- %typemap(in,checkfn="lua_isnumber") int *INPUT(int temp), int &INPUT(int temp)
- %{ temp = (int)lua_tonumber(L,$input);
- $1 = &temp; %}
- %typemap(in, numinputs=0) int *OUTPUT (int temp)
- %{ $1 = &temp; %}
- %typemap(argout) int *OUTPUT
- %{ lua_pushnumber(L, (double) *$1); SWIG_arg++;%}
- %typemap(in) int *INOUT = int *INPUT;
- %typemap(argout) int *INOUT = int *OUTPUT;
- However the code below is a mixture of #defines & such, so nowhere as easy to read
- To make you code work correctly its not just a matter of %including this file
- You also have to give SWIG the hints on which to use where
- eg
- extern int add_pointer(int* a1,int* a2); // a1 & a2 are pointer values to be added
- extern void swap(int* s1, int* s2); // does the swap
- You will need to either change the argument names
- extern int add_pointer(int* INPUT,int* INPUT);
- or provide a %apply statement
- %apply int* INOUT{ int *s1, int *s2 };
- // if SWIG sees int* s1, int* s2, assume they are inout params
- */
- %define SWIG_NUMBER_TYPEMAP(TYPE)
- %typemap(in,checkfn="lua_isnumber") TYPE *INPUT($*ltype temp), TYPE &INPUT($*ltype temp)
- %{ temp = ($*ltype)lua_tonumber(L,$input);
- $1 = &temp; %}
- %typemap(in, numinputs=0) TYPE *OUTPUT ($*ltype temp)
- %{ $1 = &temp; %}
- %typemap(argout) TYPE *OUTPUT
- %{ lua_pushnumber(L, (lua_Number) *$1); SWIG_arg++;%}
- %typemap(in) TYPE *INOUT = TYPE *INPUT;
- %typemap(argout) TYPE *INOUT = TYPE *OUTPUT;
- %typemap(in) TYPE &INOUT = TYPE *INPUT;
- %typemap(argout) TYPE &INOUT = TYPE *OUTPUT;
- // const version (the $*ltype is the basic number without ptr or const's)
- %typemap(in,checkfn="lua_isnumber") const TYPE *INPUT($*ltype temp)
- %{ temp = ($*ltype)lua_tonumber(L,$input);
- $1 = &temp; %}
- %enddef
- // now the code
- SWIG_NUMBER_TYPEMAP(int); SWIG_NUMBER_TYPEMAP(unsigned int);
- SWIG_NUMBER_TYPEMAP(short); SWIG_NUMBER_TYPEMAP(unsigned short);
- SWIG_NUMBER_TYPEMAP(long); SWIG_NUMBER_TYPEMAP(unsigned long);
- SWIG_NUMBER_TYPEMAP(float);
- SWIG_NUMBER_TYPEMAP(double);
- SWIG_NUMBER_TYPEMAP(enum SWIGTYPE);
- // note we dont do char, as a char* is probably a string not a ptr to a single char
- /* -----------------------------------------------------------------------------
- * Basic Array typemaps
- * ----------------------------------------------------------------------------- */
- /*
- I have no idea why this kind of code does not exist in SWIG as standard,
- but here is it.
- This code will convert to/from 1D numeric arrays.
- In order to reduce code bloat, there are a few macros
- and quite a few functions defined
- (unfortunately this makes it a lot less clear)
- assuming we have functions
- void process_array(int arr[3]); // nice fixed size array
- void process_var_array(float arr[],int len); // variable sized array
- void process_var_array_inout(double arr*,int len); // variable sized array
- // data passed in & out
- void process_enum_inout_array_var(enum Days *arrinout, int len); // using enums
- void return_array_5(int arrout[5]); // out array only
- in order to wrap them correctly requires a typemap
- // inform SWIG of the correct typemap
- // For fixed length, you must specify it as <type> INPUT[ANY]
- %apply (int INPUT[ANY]) {(int arr[3])};
- // variable length arrays are just the same
- %apply (float INPUT[],int) {(float arr[],int len)};
- // it is also ok, to map the TYPE* instead of a TYPE[]
- %apply (double *INOUT,int) {(double arr*,int len)};
- // for the enum's you must use enum SWIGTYPE
- %apply (enum SWIGTYPE *INOUT,int) {(enum Days *arrinout, int len)};
- // fixed length out if also fine
- %apply (int OUTPUT[ANY]) {(int arrout[5])};
- Generally, you could use %typemap(...)=...
- but the %apply is neater & easier
- a few things of note:
- * all Lua tables are indexed from 1, all C/C++ arrays are indexed from 0
- therefore t={6,5,3} -- t[1]==6, t[2]==5, t[3]==3
- when passed to process_array(int arr[3]) becomes
- arr[0]==6, arr[1]==5, arr[2]==3
- * for OUTPUT arrays, no array need be passed in, the fn will return a Lua table
- so for the above mentioned return_array_5() would look like
- arr=return_array_5() -- no parameters passed in
- * for INOUT arrays, a table must be passed in, and a new table will be returned
- (this is consistant with the way that numbers are processed
- if you want just use
- arr={...}
- arr=process_var_array_inout(arr) -- arr is replaced by the new version
- The following are not yet supported:
- * variable length output only array (inout's work ok)
- * multidimentional arrays
- * arrays of objects/structs
- * arrays of pointers
- */
- /*
- The internals of the array managment stuff
- helper fns/macros
- SWIG_ALLOC_ARRAY(TYPE,LEN) // returns a typed array TYPE[LEN]
- SWIG_FREE_ARRAY(PTR) // delete the ptr (if not zero)
- // counts the specified table & gets the size
- // integer version
- int SWIG_itable_size(lua_State* L, int index);
- // other version
- int SWIG_table_size(lua_State* L, int index);
- SWIG_DECLARE_TYPEMAP_ARR_FN(NAME,TYPE)
- // this fn declares up 4 functions for helping to read/write tables
- // these can then be called by the macros ...
- // all assume the table is an integer indexes from 1
- // but the C array is a indexed from 0
- // created a fixed size array, reads the specified table
- // and then fills the array with numbers
- // returns ptr to the array if ok, or 0 for error
- // (also pushes a error message to the stack)
- TYPE* SWIG_get_NAME_num_array_fixed(lua_State* L, int index, int size);
- // as per SWIG_get_NAME_num_array_fixed()
- // but reads the entire table & creates an array of the correct size
- // (if the table is empty, it returns an error rather than a zero length array)
- TYPE* SWIG_get_NAME_num_array_var(lua_State* L, int index, int* size);
- // writes a table to Lua with all the specified numbers
- void SWIG_write_NAME_num_array(lua_State* L,TYPE *array,int size);
- // read the specified table, and fills the array with numbers
- // returns 1 of ok (only fails if it doesnt find numbers)
- // helper fn (called by SWIG_get_NAME_num_array_*() fns)
- int SWIG_read_NAME_num_array(lua_State* L,int index,TYPE *array,int size);
- */
- %{
- #ifdef __cplusplus /* generic alloc/dealloc fns*/
- #define SWIG_ALLOC_ARRAY(TYPE,LEN) new (TYPE)[LEN]
- #define SWIG_FREE_ARRAY(PTR) if(PTR){delete[] PTR;}
- #else
- #define SWIG_ALLOC_ARRAY(TYPE,LEN) (TYPE *)malloc(LEN*sizeof(TYPE))
- #define SWIG_FREE_ARRAY(PTR) if(PTR){free(PTR);}
- #endif
- /* counting the size of arrays:*/
- int SWIG_itable_size(lua_State* L, int index)
- {
- int n=0;
- while(1){
- lua_rawgeti(L,index,n+1);
- if (lua_isnil(L,-1))break;
- ++n;
- lua_pop(L,1);
- }
- lua_pop(L,1);
- return n;
- }
- int SWIG_table_size(lua_State* L, int index)
- {
- int n=0;
- lua_pushnil(L); /* first key*/
- while (lua_next(L, index) != 0) {
- ++n;
- lua_pop(L, 1); /* removes `value'; keeps `key' for next iteration*/
- }
- return n;
- }
- /* super macro to declare array typemap helper fns */
- #define SWIG_DECLARE_TYPEMAP_ARR_FN(NAME,TYPE)\
- int SWIG_read_##NAME##_num_array(lua_State* L,int index,TYPE *array,int size){\
- int i;\
- for (i = 0; i < size; i++) {\
- lua_rawgeti(L,index,i+1);\
- if (lua_isnumber(L,-1)){\
- array[i] = (TYPE)lua_tonumber(L,-1);\
- } else {\
- lua_pop(L,1);\
- return 0;\
- }\
- lua_pop(L,1);\
- }\
- return 1;\
- }\
- static TYPE* SWIG_get_##NAME##_num_array_fixed(lua_State* L, int index, int size){\
- TYPE *array;\
- if (!lua_istable(L,index) || SWIG_itable_size(L,index) != size) {\
- lua_pushfstring(L,"expected a table of size %d",size);\
- return 0;\
- }\
- array=SWIG_ALLOC_ARRAY(TYPE,size);\
- if (!SWIG_read_##NAME##_num_array(L,index,array,size)){\
- lua_pushstring(L,"table must contain numbers");\
- SWIG_FREE_ARRAY(array);\
- return 0;\
- }\
- return array;\
- }\
- static TYPE* SWIG_get_##NAME##_num_array_var(lua_State* L, int index, int* size)\
- {\
- TYPE *array;\
- if (!lua_istable(L,index)) {\
- lua_pushstring(L,"expected a table");\
- return 0;\
- }\
- *size=SWIG_itable_size(L,index);\
- if (*size<1){\
- lua_pushstring(L,"table appears to be empty");\
- return 0;\
- }\
- array=SWIG_ALLOC_ARRAY(TYPE,*size);\
- if (!SWIG_read_##NAME##_num_array(L,index,array,*size)){\
- lua_pushstring(L,"table must contain numbers");\
- SWIG_FREE_ARRAY(array);\
- return 0;\
- }\
- return array;\
- }\
- void SWIG_write_##NAME##_num_array(lua_State* L,TYPE *array,int size){\
- int i;\
- lua_newtable(L);\
- for (i = 0; i < size; i++){\
- lua_pushnumber(L,(lua_Number)array[i]);\
- lua_rawseti(L,-2,i+1);/* -1 is the number, -2 is the table*/ \
- }\
- }
- %}
- /*
- This is one giant macro to define the typemaps & the helpers
- for array handling
- */
- %define SWIG_TYPEMAP_NUM_ARR(NAME,TYPE)
- %{SWIG_DECLARE_TYPEMAP_ARR_FN(NAME,TYPE);%}
- // fixed size array's
- %typemap(in) TYPE INPUT[ANY]
- %{ $1 = SWIG_get_##NAME##_num_array_fixed(L,$input,$1_dim0);
- if (!$1) SWIG_fail;%}
- %typemap(freearg) TYPE INPUT[ANY]
- %{ SWIG_FREE_ARRAY($1);%}
- // variable size array's
- %typemap(in) (TYPE *INPUT,int)
- %{ $1 = SWIG_get_##NAME##_num_array_var(L,$input,&$2);
- if (!$1) SWIG_fail;%}
- %typemap(freearg) (TYPE *INPUT,int)
- %{ SWIG_FREE_ARRAY($1);%}
- // out fixed arrays
- %typemap(in,numinputs=0) TYPE OUTPUT[ANY]
- %{ $1 = SWIG_ALLOC_ARRAY(TYPE,$1_dim0); %}
- %typemap(argout) TYPE OUTPUT[ANY]
- %{ SWIG_write_##NAME##_num_array(L,$1,$1_dim0); SWIG_arg++; %}
- %typemap(freearg) TYPE OUTPUT[ANY]
- %{ SWIG_FREE_ARRAY($1); %}
- // inout fixed arrays
- %typemap(in) TYPE INOUT[ANY]=TYPE INPUT[ANY];
- %typemap(argout) TYPE INOUT[ANY]=TYPE OUTPUT[ANY];
- %typemap(freearg) TYPE INOUT[ANY]=TYPE INPUT[ANY];
- // inout variable arrays
- %typemap(in) (TYPE *INOUT,int)=(TYPE *INPUT,int);
- %typemap(argout) (TYPE *INOUT,int)
- %{ SWIG_write_##NAME##_num_array(L,$1,$2); SWIG_arg++; %}
- %typemap(freearg) (TYPE *INOUT,int)=(TYPE *INPUT,int);
- // TODO out variable arrays (is there a standard form for such things?)
- %enddef
- // the following line of code
- // declares the C helper fns for the array typemaps
- // as well as defining typemaps for
- // fixed len arrays in & out, & variable length arrays in
- SWIG_TYPEMAP_NUM_ARR(int,int);
- SWIG_TYPEMAP_NUM_ARR(uint,unsigned int);
- SWIG_TYPEMAP_NUM_ARR(short,short);
- SWIG_TYPEMAP_NUM_ARR(ushort,unsigned short);
- SWIG_TYPEMAP_NUM_ARR(long,long);
- SWIG_TYPEMAP_NUM_ARR(ulong,unsigned long);
- SWIG_TYPEMAP_NUM_ARR(float,float);
- SWIG_TYPEMAP_NUM_ARR(double,double);
- // again enums are a problem so they need their own type
- // we use the int conversion routine & recast it
- %typemap(in) enum SWIGTYPE INPUT[ANY]
- %{ $1 = ($ltype)SWIG_get_int_num_array_fixed(L,$input,$1_dim0);
- if (!$1) SWIG_fail;%}
- %typemap(freearg) enum SWIGTYPE INPUT[ANY]
- %{ SWIG_FREE_ARRAY($1);%}
- // variable size array's
- %typemap(in) (enum SWIGTYPE *INPUT,int)
- %{ $1 = ($ltype)SWIG_get_int_num_array_var(L,$input,&$2);
- if (!$1) SWIG_fail;%}
- %typemap(freearg) (enum SWIGTYPE *INPUT,int)
- %{ SWIG_FREE_ARRAY($1);%}
- // out fixed arrays
- %typemap(in,numinputs=0) enum SWIGTYPE OUTPUT[ANY]
- %{ $1 = SWIG_ALLOC_ARRAY(enum SWIGTYPE,$1_dim0); %}
- %typemap(argout) enum SWIGTYPE OUTPUT[ANY]
- %{ SWIG_write_int_num_array(L,(int*)$1,$1_dim0); SWIG_arg++; %}
- %typemap(freearg) enum SWIGTYPE OUTPUT[ANY]
- %{ SWIG_FREE_ARRAY($1); %}
- // inout fixed arrays
- %typemap(in) enum SWIGTYPE INOUT[ANY]=enum SWIGTYPE INPUT[ANY];
- %typemap(argout) enum SWIGTYPE INOUT[ANY]=enum SWIGTYPE OUTPUT[ANY];
- %typemap(freearg) enum SWIGTYPE INOUT[ANY]=enum SWIGTYPE INPUT[ANY];
- // inout variable arrays
- %typemap(in) (enum SWIGTYPE *INOUT,int)=(enum SWIGTYPE *INPUT,int);
- %typemap(argout) (enum SWIGTYPE *INOUT,int)
- %{ SWIG_write_int_num_array(L,(int*)$1,$2); SWIG_arg++; %}
- %typemap(freearg) (enum SWIGTYPE *INOUT,int)=(enum SWIGTYPE *INPUT,int);
- /* Surprisingly pointer arrays are easier:
- this is because all ptr arrays become void**
- so only a few fns are needed & a few casts
- The function defined are
- // created a fixed size array, reads the specified table
- // and then fills the array with pointers (checking the type)
- // returns ptr to the array if ok, or 0 for error
- // (also pushes a error message to the stack)
- void** SWIG_get_ptr_array_fixed(lua_State* L, int index, int size,swig_type_info *type);
- // as per SWIG_get_ptr_array_fixed()
- // but reads the entire table & creates an array of the correct size
- // (if the table is empty, it returns an error rather than a zero length array)
- void** SWIG_get_ptr_array_var(lua_State* L, int index, int* size,swig_type_info *type);
- // writes a table to Lua with all the specified pointers
- // all pointers have the ownership value 'own' (normally 0)
- void SWIG_write_ptr_array(lua_State* L,void **array,int size,int own);
- // read the specified table, and fills the array with ptrs
- // returns 1 of ok (only fails if it doesnt find correct type of ptrs)
- // helper fn (called by SWIG_get_ptr_array_*() fns)
- int SWIG_read_ptr_array(lua_State* L,int index,void **array,int size,swig_type_info *type);
- The key thing to remember is that it is assumed that there is no
- modification of pointers ownership in the arrays
- eg A fn:
- void pointers_in(TYPE* arr[],int len);
- will make copies of the pointer into a temp array and then pass it into the fn
- Lua does not remeber that this fn held the pointers, so it is not safe to keep
- these pointers until later
- eg A fn:
- void pointers_out(TYPE* arr[3]);
- will return a table containing three pointers
- however these pointers are NOT owned by Lua, merely borrowed
- so if the C/C++ frees then Lua is not aware
- */
- %{
- int SWIG_read_ptr_array(lua_State* L,int index,void **array,int size,swig_type_info *type){
- int i;
- for (i = 0; i < size; i++) {
- lua_rawgeti(L,index,i+1);
- if (!lua_isuserdata(L,-1) || SWIG_ConvertPtr(L,-1,&array[i],type,0)==-1){
- lua_pop(L,1);
- return 0;
- }
- lua_pop(L,1);
- }
- return 1;
- }
- static void** SWIG_get_ptr_array_fixed(lua_State* L, int index, int size,swig_type_info *type){
- void **array;
- if (!lua_istable(L,index) || SWIG_itable_size(L,index) != size) {
- lua_pushfstring(L,"expected a table of size %d",size);
- return 0;
- }
- array=SWIG_ALLOC_ARRAY(void*,size);
- if (!SWIG_read_ptr_array(L,index,array,size,type)){
- lua_pushfstring(L,"table must contain pointers of type %s",type->name);
- SWIG_FREE_ARRAY(array);
- return 0;
- }
- return array;
- }
- static void** SWIG_get_ptr_array_var(lua_State* L, int index, int* size,swig_type_info *type){
- void **array;
- if (!lua_istable(L,index)) {
- lua_pushstring(L,"expected a table");
- return 0;
- }
- *size=SWIG_itable_size(L,index);
- if (*size<1){
- lua_pushstring(L,"table appears to be empty");
- return 0;
- }
- array=SWIG_ALLOC_ARRAY(void*,*size);
- if (!SWIG_read_ptr_array(L,index,array,*size,type)){
- lua_pushfstring(L,"table must contain pointers of type %s",type->name);
- SWIG_FREE_ARRAY(array);
- return 0;
- }
- return array;
- }
- void SWIG_write_ptr_array(lua_State* L,void **array,int size,swig_type_info *type,int own){
- int i;
- lua_newtable(L);
- for (i = 0; i < size; i++){
- SWIG_NewPointerObj(L,array[i],type,own);
- lua_rawseti(L,-2,i+1);/* -1 is the number, -2 is the table*/
- }
- }
- %}
- // fixed size array's
- %typemap(in) SWIGTYPE* INPUT[ANY]
- %{ $1 = ($ltype)SWIG_get_ptr_array_fixed(L,$input,$1_dim0,$*1_descriptor);
- if (!$1) SWIG_fail;%}
- %typemap(freearg) SWIGTYPE* INPUT[ANY]
- %{ SWIG_FREE_ARRAY($1);%}
- // variable size array's
- %typemap(in) (SWIGTYPE **INPUT,int)
- %{ $1 = ($ltype)SWIG_get_ptr_array_var(L,$input,&$2,$*1_descriptor);
- if (!$1) SWIG_fail;%}
- %typemap(freearg) (SWIGTYPE **INPUT,int)
- %{ SWIG_FREE_ARRAY($1);%}
- // out fixed arrays
- %typemap(in,numinputs=0) SWIGTYPE* OUTPUT[ANY]
- %{ $1 = SWIG_ALLOC_ARRAY($*1_type,$1_dim0); %}
- %typemap(argout) SWIGTYPE* OUTPUT[ANY]
- %{ SWIG_write_ptr_array(L,(void**)$1,$1_dim0,$*1_descriptor,0); SWIG_arg++; %}
- %typemap(freearg) SWIGTYPE* OUTPUT[ANY]
- %{ SWIG_FREE_ARRAY($1); %}
- // inout fixed arrays
- %typemap(in) SWIGTYPE* INOUT[ANY]=SWIGTYPE* INPUT[ANY];
- %typemap(argout) SWIGTYPE* INOUT[ANY]=SWIGTYPE* OUTPUT[ANY];
- %typemap(freearg) SWIGTYPE* INOUT[ANY]=SWIGTYPE* INPUT[ANY];
- // inout variable arrays
- %typemap(in) (SWIGTYPE** INOUT,int)=(SWIGTYPE** INPUT,int);
- %typemap(argout) (SWIGTYPE** INOUT,int)
- %{ SWIG_write_ptr_array(L,(void**)$1,$2,$*1_descriptor,0); SWIG_arg++; %}
- %typemap(freearg) (SWIGTYPE**INOUT,int)=(SWIGTYPE**INPUT,int);