diff options
Diffstat (limited to 'share/swig/2.0.11/lua/typemaps.i')
| -rw-r--r-- | share/swig/2.0.11/lua/typemaps.i | 564 |
1 files changed, 564 insertions, 0 deletions
diff --git a/share/swig/2.0.11/lua/typemaps.i b/share/swig/2.0.11/lua/typemaps.i new file mode 100644 index 0000000..7a095a1 --- /dev/null +++ b/share/swig/2.0.11/lua/typemaps.i @@ -0,0 +1,564 @@ +/* ----------------------------------------------------------------------------- + * 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 &OUTPUT = TYPE *OUTPUT; +%typemap(argout) TYPE &OUTPUT = 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(unsigned char); SWIG_NUMBER_TYPEMAP(signed char); + +SWIG_NUMBER_TYPEMAP(short); SWIG_NUMBER_TYPEMAP(unsigned short); SWIG_NUMBER_TYPEMAP(signed short); +SWIG_NUMBER_TYPEMAP(int); SWIG_NUMBER_TYPEMAP(unsigned int); SWIG_NUMBER_TYPEMAP(signed int); +SWIG_NUMBER_TYPEMAP(long); SWIG_NUMBER_TYPEMAP(unsigned long); SWIG_NUMBER_TYPEMAP(signed long); +SWIG_NUMBER_TYPEMAP(float); +SWIG_NUMBER_TYPEMAP(double); +SWIG_NUMBER_TYPEMAP(enum SWIGTYPE); +// also for long longs's +SWIG_NUMBER_TYPEMAP(long long); SWIG_NUMBER_TYPEMAP(unsigned long long); SWIG_NUMBER_TYPEMAP(signed long long); + +// note we dont do char, as a char* is probably a string not a ptr to a single char + +// similar for booleans +%typemap(in,checkfn="lua_isboolean") bool *INPUT(bool temp), bool &INPUT(bool temp) +%{ temp = (lua_toboolean(L,$input)!=0); + $1 = &temp; %} + +%typemap(in, numinputs=0) bool *OUTPUT (bool temp),bool &OUTPUT (bool temp) +%{ $1 = &temp; %} + +%typemap(argout) bool *OUTPUT,bool &OUTPUT +%{ lua_pushboolean(L, (int)((*$1)!=0)); SWIG_arg++;%} + +%typemap(in) bool *INOUT = bool *INPUT; +%typemap(argout) bool *INOUT = bool *OUTPUT; +%typemap(in) bool &INOUT = bool &INPUT; +%typemap(argout) bool &INOUT = bool &OUTPUT; + +/* ----------------------------------------------------------------------------- + * 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 consistent 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 works ok) +* multidimensional arrays +* arrays of objects/structs +* arrays of pointers + +*/ + +/* +The internals of the array management 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); + +*/ + +/* Reported that you don't need to check for NULL for delete & free +There probably is some compiler that its not true for, so the code is left here just in case. +#ifdef __cplusplus +#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 +*/ +%{ +#ifdef __cplusplus /* generic alloc/dealloc fns*/ +#define SWIG_ALLOC_ARRAY(TYPE,LEN) new TYPE[LEN] +#define SWIG_FREE_ARRAY(PTR) delete[] PTR +#else +#define SWIG_ALLOC_ARRAY(TYPE,LEN) (TYPE *)malloc(LEN*sizeof(TYPE)) +#define SWIG_FREE_ARRAY(PTR) free(PTR) +#endif +/* counting the size of arrays:*/ +SWIGINTERN int SWIG_itable_size(lua_State* L, int index) +{ + int n=0; + while(1){ + lua_rawgeti(L,index,n+1); + if (lua_isnil(L,-1))break; + ++n; + lua_pop(L,1); + } + lua_pop(L,1); + return n; +} + +SWIGINTERN int SWIG_table_size(lua_State* L, int index) +{ + int n=0; + lua_pushnil(L); /* first key*/ + while (lua_next(L, index) != 0) { + ++n; + lua_pop(L, 1); /* removes `value'; keeps `key' for next iteration*/ + } + return n; +} + +/* super macro to declare array typemap helper fns */ +#define SWIG_DECLARE_TYPEMAP_ARR_FN(NAME,TYPE)\ + SWIGINTERN int SWIG_read_##NAME##_num_array(lua_State* L,int index,TYPE *array,int size){\ + int i;\ + for (i = 0; i < size; i++) {\ + lua_rawgeti(L,index,i+1);\ + if (lua_isnumber(L,-1)){\ + array[i] = (TYPE)lua_tonumber(L,-1);\ + } else {\ + lua_pop(L,1);\ + return 0;\ + }\ + lua_pop(L,1);\ + }\ + return 1;\ + }\ + SWIGINTERN TYPE* SWIG_get_##NAME##_num_array_fixed(lua_State* L, int index, int size){\ + TYPE *array;\ + if (!lua_istable(L,index) || SWIG_itable_size(L,index) != size) {\ + SWIG_Lua_pushferrstring(L,"expected a table of size %d",size);\ + return 0;\ + }\ + array=SWIG_ALLOC_ARRAY(TYPE,size);\ + if (!SWIG_read_##NAME##_num_array(L,index,array,size)){\ + SWIG_Lua_pusherrstring(L,"table must contain numbers");\ + SWIG_FREE_ARRAY(array);\ + return 0;\ + }\ + return array;\ + }\ + SWIGINTERN TYPE* SWIG_get_##NAME##_num_array_var(lua_State* L, int index, int* size)\ + {\ + TYPE *array;\ + if (!lua_istable(L,index)) {\ + SWIG_Lua_pusherrstring(L,"expected a table");\ + return 0;\ + }\ + *size=SWIG_itable_size(L,index);\ + if (*size<1){\ + SWIG_Lua_pusherrstring(L,"table appears to be empty");\ + return 0;\ + }\ + array=SWIG_ALLOC_ARRAY(TYPE,*size);\ + if (!SWIG_read_##NAME##_num_array(L,index,array,*size)){\ + SWIG_Lua_pusherrstring(L,"table must contain numbers");\ + SWIG_FREE_ARRAY(array);\ + return 0;\ + }\ + return array;\ + }\ + SWIGINTERN void SWIG_write_##NAME##_num_array(lua_State* L,TYPE *array,int size){\ + int i;\ + lua_newtable(L);\ + for (i = 0; i < size; i++){\ + lua_pushnumber(L,(lua_Number)array[i]);\ + lua_rawseti(L,-2,i+1);/* -1 is the number, -2 is the table*/ \ + }\ + } +%} + +/* +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?) + +// referencing so that (int *INPUT,int) and (int INPUT[],int) are the same +%typemap(in) (TYPE INPUT[],int)=(TYPE *INPUT,int); +%typemap(freearg) (TYPE INPUT[],int)=(TYPE *INPUT,int); + +%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(schar,signed char); +SWIG_TYPEMAP_NUM_ARR(uchar,unsigned char); +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 arrays +%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 doesn't 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 remember 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 + +*/ + +%{ +SWIGINTERN int SWIG_read_ptr_array(lua_State* L,int index,void **array,int size,swig_type_info *type){ + int i; + for (i = 0; i < size; i++) { + lua_rawgeti(L,index,i+1); + if (!lua_isuserdata(L,-1) || SWIG_ConvertPtr(L,-1,&array[i],type,0)==-1){ + lua_pop(L,1); + return 0; + } + lua_pop(L,1); + } + return 1; +} +SWIGINTERN void** SWIG_get_ptr_array_fixed(lua_State* L, int index, int size,swig_type_info *type){ + void **array; + if (!lua_istable(L,index) || SWIG_itable_size(L,index) != size) { + SWIG_Lua_pushferrstring(L,"expected a table of size %d",size); + return 0; + } + array=SWIG_ALLOC_ARRAY(void*,size); + if (!SWIG_read_ptr_array(L,index,array,size,type)){ + SWIG_Lua_pushferrstring(L,"table must contain pointers of type %s",type->name); + SWIG_FREE_ARRAY(array); + return 0; + } + return array; +} +SWIGINTERN void** SWIG_get_ptr_array_var(lua_State* L, int index, int* size,swig_type_info *type){ + void **array; + if (!lua_istable(L,index)) { + SWIG_Lua_pusherrstring(L,"expected a table"); + return 0; + } + *size=SWIG_itable_size(L,index); + if (*size<1){ + SWIG_Lua_pusherrstring(L,"table appears to be empty"); + return 0; + } + array=SWIG_ALLOC_ARRAY(void*,*size); + if (!SWIG_read_ptr_array(L,index,array,*size,type)){ + SWIG_Lua_pushferrstring(L,"table must contain pointers of type %s",type->name); + SWIG_FREE_ARRAY(array); + return 0; + } + return array; +} +SWIGINTERN void SWIG_write_ptr_array(lua_State* L,void **array,int size,swig_type_info *type,int own){ + int i; + lua_newtable(L); + for (i = 0; i < size; i++){ + SWIG_NewPointerObj(L,array[i],type,own); + lua_rawseti(L,-2,i+1);/* -1 is the number, -2 is the table*/ + } +} +%} + +// 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); + +/* ----------------------------------------------------------------------------- + * Pointer-Pointer typemaps + * ----------------------------------------------------------------------------- */ +/* +This code is to deal with the issue for pointer-pointer's +In particular for factory methods. + +for example take the following code segment: + +struct iMath; // some structure +int Create_Math(iMath** pptr); // its factory (assume it mallocs) + +to use it you might have the following C code: + +iMath* ptr; +int ok; +ok=Create_Math(&ptr); +// do things with ptr +//... +free(ptr); + +With the following SWIG code +%apply SWIGTYPE** OUTPUT{iMath **pptr }; + +You can get natural wrapping in Lua as follows: +ok,ptr=Create_Math() -- ptr is a iMath* which is returned with the int +ptr=nil -- the iMath* will be GC'ed as normal +*/ + +%typemap(in,numinputs=0) SWIGTYPE** OUTPUT ($*ltype temp) +%{ temp = ($*ltype)0; + $1 = &temp; %} +%typemap(argout) SWIGTYPE** OUTPUT +%{SWIG_NewPointerObj(L,*$1,$*descriptor,1); SWIG_arg++; %} + |