| 1 | //\r |
| 2 | // SWIG Typemap library\r |
| 3 | // C# implementation\r |
| 4 | //\r |
| 5 | \r |
| 6 | // ------------------------------------------------------------------------\r |
| 7 | // Pointer and reference handling\r |
| 8 | //\r |
| 9 | // These mappings provide support for input/output arguments and common\r |
| 10 | // uses for C/C++ pointers and C++ references.\r |
| 11 | // ------------------------------------------------------------------------\r |
| 12 | \r |
| 13 | /*\r |
| 14 | INPUT typemaps\r |
| 15 | --------------\r |
| 16 | \r |
| 17 | These typemaps are used for pointer/reference parameters that are input only\r |
| 18 | are mapped to a C# input parameter.\r |
| 19 | \r |
| 20 | The following typemaps can be applied to turn a pointer or reference into a simple\r |
| 21 | input value. That is, instead of passing a pointer or reference to an object,\r |
| 22 | you would use a real value instead.\r |
| 23 | \r |
| 24 | bool *INPUT, bool &INPUT\r |
| 25 | signed char *INPUT, signed char &INPUT\r |
| 26 | unsigned char *INPUT, unsigned char &INPUT\r |
| 27 | short *INPUT, short &INPUT\r |
| 28 | unsigned short *INPUT, unsigned short &INPUT\r |
| 29 | int *INPUT, int &INPUT\r |
| 30 | unsigned int *INPUT, unsigned int &INPUT\r |
| 31 | long *INPUT, long &INPUT\r |
| 32 | unsigned long *INPUT, unsigned long &INPUT\r |
| 33 | long long *INPUT, long long &INPUT\r |
| 34 | unsigned long long *INPUT, unsigned long long &INPUT\r |
| 35 | float *INPUT, float &INPUT\r |
| 36 | double *INPUT, double &INPUT\r |
| 37 | \r |
| 38 | To use these, suppose you had a C function like this :\r |
| 39 | \r |
| 40 | double fadd(double *a, double *b) {\r |
| 41 | return *a+*b;\r |
| 42 | }\r |
| 43 | \r |
| 44 | You could wrap it with SWIG as follows :\r |
| 45 | \r |
| 46 | %include "typemaps.i"\r |
| 47 | double fadd(double *INPUT, double *INPUT);\r |
| 48 | \r |
| 49 | or you can use the %apply directive :\r |
| 50 | \r |
| 51 | %include "typemaps.i"\r |
| 52 | %apply double *INPUT { double *a, double *b };\r |
| 53 | double fadd(double *a, double *b);\r |
| 54 | \r |
| 55 | In C# you could then use it like this:\r |
| 56 | double answer = modulename.fadd(10.0, 20.0);\r |
| 57 | \r |
| 58 | */\r |
| 59 | \r |
| 60 | %define INPUT_TYPEMAP(TYPE, CTYPE, CSTYPE)\r |
| 61 | %typemap(ctype) TYPE *INPUT, TYPE &INPUT "CTYPE"\r |
| 62 | %typemap(imtype) TYPE *INPUT, TYPE &INPUT "CSTYPE"\r |
| 63 | %typemap(cstype) TYPE *INPUT, TYPE &INPUT "CSTYPE"\r |
| 64 | %typemap(csin) TYPE *INPUT, TYPE &INPUT "$csinput"\r |
| 65 | \r |
| 66 | %typemap(in) TYPE *INPUT, TYPE &INPUT\r |
| 67 | %{ $1 = ($1_ltype)&$input; %}\r |
| 68 | \r |
| 69 | %typemap(typecheck) TYPE *INPUT = TYPE;\r |
| 70 | %typemap(typecheck) TYPE &INPUT = TYPE;\r |
| 71 | %enddef\r |
| 72 | \r |
| 73 | INPUT_TYPEMAP(bool, unsigned int, bool)\r |
| 74 | //INPUT_TYPEMAP(char, char, char)\r |
| 75 | INPUT_TYPEMAP(signed char, signed char, sbyte)\r |
| 76 | INPUT_TYPEMAP(unsigned char, unsigned char, byte)\r |
| 77 | INPUT_TYPEMAP(short, short, short)\r |
| 78 | INPUT_TYPEMAP(unsigned short, unsigned short, ushort)\r |
| 79 | INPUT_TYPEMAP(int, int, int)\r |
| 80 | INPUT_TYPEMAP(unsigned int, unsigned int, uint)\r |
| 81 | INPUT_TYPEMAP(long, long, int)\r |
| 82 | INPUT_TYPEMAP(unsigned long, unsigned long, uint)\r |
| 83 | INPUT_TYPEMAP(long long, long long, long)\r |
| 84 | INPUT_TYPEMAP(unsigned long long, unsigned long long, ulong)\r |
| 85 | INPUT_TYPEMAP(float, float, float)\r |
| 86 | INPUT_TYPEMAP(double, double, double)\r |
| 87 | \r |
| 88 | #undef INPUT_TYPEMAP\r |
| 89 | \r |
| 90 | /*\r |
| 91 | OUTPUT typemaps\r |
| 92 | ---------------\r |
| 93 | \r |
| 94 | These typemaps are used for pointer/reference parameters that are output only and\r |
| 95 | are mapped to a C# output parameter.\r |
| 96 | \r |
| 97 | The following typemaps can be applied to turn a pointer or reference into an "output"\r |
| 98 | value. When calling a function, no input value would be given for\r |
| 99 | a parameter, but an output value would be returned. In C#, the 'out' keyword is\r |
| 100 | used when passing the parameter to a function that takes an output parameter.\r |
| 101 | \r |
| 102 | bool *OUTPUT, bool &OUTPUT\r |
| 103 | signed char *OUTPUT, signed char &OUTPUT\r |
| 104 | unsigned char *OUTPUT, unsigned char &OUTPUT\r |
| 105 | short *OUTPUT, short &OUTPUT\r |
| 106 | unsigned short *OUTPUT, unsigned short &OUTPUT\r |
| 107 | int *OUTPUT, int &OUTPUT\r |
| 108 | unsigned int *OUTPUT, unsigned int &OUTPUT\r |
| 109 | long *OUTPUT, long &OUTPUT\r |
| 110 | unsigned long *OUTPUT, unsigned long &OUTPUT\r |
| 111 | long long *OUTPUT, long long &OUTPUT\r |
| 112 | unsigned long long *OUTPUT, unsigned long long &OUTPUT\r |
| 113 | float *OUTPUT, float &OUTPUT\r |
| 114 | double *OUTPUT, double &OUTPUT\r |
| 115 | \r |
| 116 | For example, suppose you were trying to wrap the modf() function in the\r |
| 117 | C math library which splits x into integral and fractional parts (and\r |
| 118 | returns the integer part in one of its parameters):\r |
| 119 | \r |
| 120 | double modf(double x, double *ip);\r |
| 121 | \r |
| 122 | You could wrap it with SWIG as follows :\r |
| 123 | \r |
| 124 | %include "typemaps.i"\r |
| 125 | double modf(double x, double *OUTPUT);\r |
| 126 | \r |
| 127 | or you can use the %apply directive :\r |
| 128 | \r |
| 129 | %include "typemaps.i"\r |
| 130 | %apply double *OUTPUT { double *ip };\r |
| 131 | double modf(double x, double *ip);\r |
| 132 | \r |
| 133 | The C# output of the function would be the function return value and the \r |
| 134 | value returned in the second output parameter. In C# you would use it like this:\r |
| 135 | \r |
| 136 | double dptr;\r |
| 137 | double fraction = modulename.modf(5, out dptr);\r |
| 138 | \r |
| 139 | */\r |
| 140 | \r |
| 141 | %define OUTPUT_TYPEMAP(TYPE, CTYPE, CSTYPE, TYPECHECKPRECEDENCE)\r |
| 142 | %typemap(ctype) TYPE *OUTPUT, TYPE &OUTPUT "CTYPE *"\r |
| 143 | %typemap(imtype) TYPE *OUTPUT, TYPE &OUTPUT "out CSTYPE"\r |
| 144 | %typemap(cstype) TYPE *OUTPUT, TYPE &OUTPUT "out CSTYPE"\r |
| 145 | %typemap(csin) TYPE *OUTPUT, TYPE &OUTPUT "out $csinput"\r |
| 146 | \r |
| 147 | %typemap(in) TYPE *OUTPUT, TYPE &OUTPUT\r |
| 148 | %{ $1 = ($1_ltype)$input; %}\r |
| 149 | \r |
| 150 | %typecheck(SWIG_TYPECHECK_##TYPECHECKPRECEDENCE) TYPE *OUTPUT, TYPE &OUTPUT ""\r |
| 151 | %enddef\r |
| 152 | \r |
| 153 | OUTPUT_TYPEMAP(bool, unsigned int, bool, BOOL_PTR)\r |
| 154 | //OUTPUT_TYPEMAP(char, char, char, CHAR_PTR)\r |
| 155 | OUTPUT_TYPEMAP(signed char, signed char, sbyte, INT8_PTR)\r |
| 156 | OUTPUT_TYPEMAP(unsigned char, unsigned char, byte, UINT8_PTR)\r |
| 157 | OUTPUT_TYPEMAP(short, short, short, INT16_PTR)\r |
| 158 | OUTPUT_TYPEMAP(unsigned short, unsigned short, ushort, UINT16_PTR)\r |
| 159 | OUTPUT_TYPEMAP(int, int, int, INT32_PTR)\r |
| 160 | OUTPUT_TYPEMAP(unsigned int, unsigned int, uint, UINT32_PTR)\r |
| 161 | OUTPUT_TYPEMAP(long, long, int, INT32_PTR)\r |
| 162 | OUTPUT_TYPEMAP(unsigned long, unsigned long, uint, UINT32_PTR)\r |
| 163 | OUTPUT_TYPEMAP(long long, long long, long, INT64_PTR)\r |
| 164 | OUTPUT_TYPEMAP(unsigned long long, unsigned long long, ulong, UINT64_PTR)\r |
| 165 | OUTPUT_TYPEMAP(float, float, float, FLOAT_PTR)\r |
| 166 | OUTPUT_TYPEMAP(double, double, double, DOUBLE_PTR)\r |
| 167 | \r |
| 168 | #undef OUTPUT_TYPEMAP\r |
| 169 | \r |
| 170 | \r |
| 171 | /*\r |
| 172 | INOUT typemaps\r |
| 173 | --------------\r |
| 174 | \r |
| 175 | These typemaps are for pointer/reference parameters that are both input and\r |
| 176 | output and are mapped to a C# reference parameter.\r |
| 177 | \r |
| 178 | The following typemaps can be applied to turn a pointer or reference into a\r |
| 179 | reference parameters, that is the parameter is both an input and an output.\r |
| 180 | In C#, the 'ref' keyword is used for reference parameters.\r |
| 181 | \r |
| 182 | bool *INOUT, bool &INOUT\r |
| 183 | signed char *INOUT, signed char &INOUT\r |
| 184 | unsigned char *INOUT, unsigned char &INOUT\r |
| 185 | short *INOUT, short &INOUT\r |
| 186 | unsigned short *INOUT, unsigned short &INOUT\r |
| 187 | int *INOUT, int &INOUT\r |
| 188 | unsigned int *INOUT, unsigned int &INOUT\r |
| 189 | long *INOUT, long &INOUT\r |
| 190 | unsigned long *INOUT, unsigned long &INOUT\r |
| 191 | long long *INOUT, long long &INOUT\r |
| 192 | unsigned long long *INOUT, unsigned long long &INOUT\r |
| 193 | float *INOUT, float &INOUT\r |
| 194 | double *INOUT, double &INOUT\r |
| 195 | \r |
| 196 | For example, suppose you were trying to wrap the following function :\r |
| 197 | \r |
| 198 | void neg(double *x) {\r |
| 199 | *x = -(*x);\r |
| 200 | }\r |
| 201 | \r |
| 202 | You could wrap it with SWIG as follows :\r |
| 203 | \r |
| 204 | %include "typemaps.i"\r |
| 205 | void neg(double *INOUT);\r |
| 206 | \r |
| 207 | or you can use the %apply directive :\r |
| 208 | \r |
| 209 | %include "typemaps.i"\r |
| 210 | %apply double *INOUT { double *x };\r |
| 211 | void neg(double *x);\r |
| 212 | \r |
| 213 | The C# output of the function would be the new value returned by the \r |
| 214 | reference parameter. In C# you would use it like this:\r |
| 215 | \r |
| 216 | \r |
| 217 | double x = 5.0;\r |
| 218 | neg(ref x);\r |
| 219 | \r |
| 220 | The implementation of the OUTPUT and INOUT typemaps is different to the scripting\r |
| 221 | languages in that the scripting languages will return the output value as part \r |
| 222 | of the function return value.\r |
| 223 | \r |
| 224 | */\r |
| 225 | \r |
| 226 | %define INOUT_TYPEMAP(TYPE, CTYPE, CSTYPE, TYPECHECKPRECEDENCE)\r |
| 227 | %typemap(ctype) TYPE *INOUT, TYPE &INOUT "CTYPE *"\r |
| 228 | %typemap(imtype) TYPE *INOUT, TYPE &INOUT "ref CSTYPE"\r |
| 229 | %typemap(cstype) TYPE *INOUT, TYPE &INOUT "ref CSTYPE"\r |
| 230 | %typemap(csin) TYPE *INOUT, TYPE &INOUT "ref $csinput"\r |
| 231 | \r |
| 232 | %typemap(in) TYPE *INOUT, TYPE &INOUT\r |
| 233 | %{ $1 = ($1_ltype)$input; %}\r |
| 234 | \r |
| 235 | %typecheck(SWIG_TYPECHECK_##TYPECHECKPRECEDENCE) TYPE *INOUT, TYPE &INOUT ""\r |
| 236 | %enddef\r |
| 237 | \r |
| 238 | INOUT_TYPEMAP(bool, unsigned int, bool, BOOL_PTR)\r |
| 239 | //INOUT_TYPEMAP(char, char, char, CHAR_PTR)\r |
| 240 | INOUT_TYPEMAP(signed char, signed char, sbyte, INT8_PTR)\r |
| 241 | INOUT_TYPEMAP(unsigned char, unsigned char, byte, UINT8_PTR)\r |
| 242 | INOUT_TYPEMAP(short, short, short, INT16_PTR)\r |
| 243 | INOUT_TYPEMAP(unsigned short, unsigned short, ushort, UINT16_PTR)\r |
| 244 | INOUT_TYPEMAP(int, int, int, INT32_PTR)\r |
| 245 | INOUT_TYPEMAP(unsigned int, unsigned int, uint, UINT32_PTR)\r |
| 246 | INOUT_TYPEMAP(long, long, int, INT32_PTR)\r |
| 247 | INOUT_TYPEMAP(unsigned long, unsigned long, uint, UINT32_PTR)\r |
| 248 | INOUT_TYPEMAP(long long, long long, long, INT64_PTR)\r |
| 249 | INOUT_TYPEMAP(unsigned long long, unsigned long long, ulong, UINT64_PTR)\r |
| 250 | INOUT_TYPEMAP(float, float, float, FLOAT_PTR)\r |
| 251 | INOUT_TYPEMAP(double, double, double, DOUBLE_PTR)\r |
| 252 | \r |
| 253 | #undef INOUT_TYPEMAP\r |
| 254 | \r |