You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
151 lines
4.5 KiB
151 lines
4.5 KiB
/* -----------------------------------------------------------------------------
|
|
* 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.i
|
|
*
|
|
* Pointer handling
|
|
* These mappings provide support for input/output arguments and common
|
|
* uses for C/C++ pointers.
|
|
* ----------------------------------------------------------------------------- */
|
|
|
|
// INPUT typemaps.
|
|
// These remap a C pointer to be an "INPUT" value which is passed by value
|
|
// instead of reference.
|
|
|
|
/*
|
|
The following methods can be applied to turn a pointer into a simple
|
|
"input" value. That is, instead of passing a pointer to an object,
|
|
you would use a real value instead.
|
|
|
|
int *INPUT
|
|
short *INPUT
|
|
long *INPUT
|
|
long long *INPUT
|
|
unsigned int *INPUT
|
|
unsigned short *INPUT
|
|
unsigned long *INPUT
|
|
unsigned long long *INPUT
|
|
unsigned char *INPUT
|
|
bool *INPUT
|
|
float *INPUT
|
|
double *INPUT
|
|
|
|
To use these, suppose you had a C function like this :
|
|
|
|
double fadd(double *a, double *b) {
|
|
return *a+*b;
|
|
}
|
|
|
|
You could wrap it with SWIG as follows :
|
|
|
|
%include <typemaps.i>
|
|
double fadd(double *INPUT, double *INPUT);
|
|
|
|
or you can use the %apply directive :
|
|
|
|
%include <typemaps.i>
|
|
%apply double *INPUT { double *a, double *b };
|
|
double fadd(double *a, double *b);
|
|
|
|
*/
|
|
|
|
// OUTPUT typemaps. These typemaps are used for parameters that
|
|
// are output only. The output value is appended to the result as
|
|
// a list element.
|
|
|
|
/*
|
|
The following methods can be applied to turn a pointer into an "output"
|
|
value. When calling a function, no input value would be given for
|
|
a parameter, but an output value would be returned. In the case of
|
|
multiple output values, they are returned in the form of a Python tuple.
|
|
|
|
int *OUTPUT
|
|
short *OUTPUT
|
|
long *OUTPUT
|
|
long long *OUTPUT
|
|
unsigned int *OUTPUT
|
|
unsigned short *OUTPUT
|
|
unsigned long *OUTPUT
|
|
unsigned long long *OUTPUT
|
|
unsigned char *OUTPUT
|
|
bool *OUTPUT
|
|
float *OUTPUT
|
|
double *OUTPUT
|
|
|
|
For example, suppose you were trying to wrap the modf() function in the
|
|
C math library which splits x into integral and fractional parts (and
|
|
returns the integer part in one of its parameters).K:
|
|
|
|
double modf(double x, double *ip);
|
|
|
|
You could wrap it with SWIG as follows :
|
|
|
|
%include <typemaps.i>
|
|
double modf(double x, double *OUTPUT);
|
|
|
|
or you can use the %apply directive :
|
|
|
|
%include <typemaps.i>
|
|
%apply double *OUTPUT { double *ip };
|
|
double modf(double x, double *ip);
|
|
|
|
The Python output of the function would be a tuple containing both
|
|
output values.
|
|
|
|
*/
|
|
|
|
// INOUT
|
|
// Mappings for an argument that is both an input and output
|
|
// parameter
|
|
|
|
/*
|
|
The following methods can be applied to make a function parameter both
|
|
an input and output value. This combines the behavior of both the
|
|
"INPUT" and "OUTPUT" methods described earlier. Output values are
|
|
returned in the form of a Python tuple.
|
|
|
|
int *INOUT
|
|
short *INOUT
|
|
long *INOUT
|
|
long long *INOUT
|
|
unsigned int *INOUT
|
|
unsigned short *INOUT
|
|
unsigned long *INOUT
|
|
unsigned long long *INOUT
|
|
unsigned char *INOUT
|
|
bool *INOUT
|
|
float *INOUT
|
|
double *INOUT
|
|
|
|
For example, suppose you were trying to wrap the following function :
|
|
|
|
void neg(double *x) {
|
|
*x = -(*x);
|
|
}
|
|
|
|
You could wrap it with SWIG as follows :
|
|
|
|
%include <typemaps.i>
|
|
void neg(double *INOUT);
|
|
|
|
or you can use the %apply directive :
|
|
|
|
%include <typemaps.i>
|
|
%apply double *INOUT { double *x };
|
|
void neg(double *x);
|
|
|
|
Unlike C, this mapping does not directly modify the input value (since
|
|
this makes no sense in Python). Rather, the modified input value shows
|
|
up as the return value of the function. Thus, to apply this function
|
|
to a Python variable you might do this :
|
|
|
|
x = neg(x)
|
|
|
|
Note : previous versions of SWIG used the symbol 'BOTH' to mark
|
|
input/output arguments. This is still supported, but will be slowly
|
|
phased out in future releases.
|
|
|
|
*/
|
|
|
|
%include <typemaps/typemaps.swg>
|