1 /* ----------------------------------------------------------------------------- 2 * typemaps.i 3 * 4 * Pointer handling 5 * 6 * These mappings provide support for input/output arguments and 7 * common uses for C/C++ pointers. INOUT mappings allow for C/C++ 8 * pointer variables in addition to input/output arguments. 9 * ----------------------------------------------------------------------------- */ 10 11 #if !defined(SWIG_USE_OLD_TYPEMAPS) 12 %include <typemaps/typemaps.swg> 13 #else 14 15 /* 16 The SWIG typemap library provides a language independent mechanism for 17 supporting output arguments, input values, and other C function 18 calling mechanisms. The primary use of the library is to provide a 19 better interface to certain C function--especially those involving 20 pointers. 21 */ 22 23 // ------------------------------------------------------------------------ 24 // Pointer handling 25 // 26 // These mappings provide support for input/output arguments and common 27 // uses for C/C++ pointers. 28 // ------------------------------------------------------------------------ 29 30 // INPUT typemaps. 31 // These remap a C pointer to be an "INPUT" value which is passed by value 32 // instead of reference. 33 34 /* 35 The following methods can be applied to turn a pointer into a simple 36 "input" value. That is, instead of passing a pointer to an object, 37 you would use a real value instead. 38 39 int *INPUT 40 short *INPUT 41 long *INPUT 42 long long *INPUT 43 unsigned int *INPUT 44 unsigned short *INPUT 45 unsigned long *INPUT 46 unsigned long long *INPUT 47 unsigned char *INPUT 48 bool *INPUT 49 float *INPUT 50 double *INPUT 51 52 To use these, suppose you had a C function like this : 53 54 double fadd(double *a, double *b) { 55 return *a+*b; 56 } 57 58 You could wrap it with SWIG as follows : 59 60 %include typemaps.i 61 double fadd(double *INPUT, double *INPUT); 62 63 or you can use the %apply directive : 64 65 %include typemaps.i 66 %apply double *INPUT { double *a, double *b }; 67 double fadd(double *a, double *b); 68 69 */ 70 71 %define INPUT_TYPEMAP(type, converter) 72 %typemap(in) type *INPUT($*1_ltype temp), type &INPUT($*1_ltype temp) 73 { 74 temp = ($*1_ltype) converter($input); 75 $1 = &temp; 76 } 77 %typemap(typecheck) type *INPUT = type; 78 %typemap(typecheck) type &INPUT = type; 79 %enddef 80 81 INPUT_TYPEMAP(float, NUM2DBL); 82 INPUT_TYPEMAP(double, NUM2DBL); 83 INPUT_TYPEMAP(int, NUM2INT); 84 INPUT_TYPEMAP(short, NUM2SHRT); 85 INPUT_TYPEMAP(long, NUM2LONG); 86 INPUT_TYPEMAP(long long, NUM2LL); 87 INPUT_TYPEMAP(unsigned int, NUM2UINT); 88 INPUT_TYPEMAP(unsigned short, NUM2USHRT); 89 INPUT_TYPEMAP(unsigned long, NUM2ULONG); 90 INPUT_TYPEMAP(unsigned long long, NUM2ULL); 91 INPUT_TYPEMAP(unsigned char, NUM2UINT); 92 INPUT_TYPEMAP(signed char, NUM2INT); 93 INPUT_TYPEMAP(bool, RTEST); 94 95 #undef INPUT_TYPEMAP 96 97 // OUTPUT typemaps. These typemaps are used for parameters that 98 // are output only. The output value is appended to the result as 99 // a array element. 100 101 /* 102 The following methods can be applied to turn a pointer into an "output" 103 value. When calling a function, no input value would be given for 104 a parameter, but an output value would be returned. In the case of 105 multiple output values, they are returned in the form of a Ruby Array. 106 107 int *OUTPUT 108 short *OUTPUT 109 long *OUTPUT 110 long long *OUTPUT 111 unsigned int *OUTPUT 112 unsigned short *OUTPUT 113 unsigned long *OUTPUT 114 unsigned long long *OUTPUT 115 unsigned char *OUTPUT 116 bool *OUTPUT 117 float *OUTPUT 118 double *OUTPUT 119 120 For example, suppose you were trying to wrap the modf() function in the 121 C math library which splits x into integral and fractional parts (and 122 returns the integer part in one of its parameters).K: 123 124 double modf(double x, double *ip); 125 126 You could wrap it with SWIG as follows : 127 128 %include typemaps.i 129 double modf(double x, double *OUTPUT); 130 131 or you can use the %apply directive : 132 133 %include typemaps.i 134 %apply double *OUTPUT { double *ip }; 135 double modf(double x, double *ip); 136 137 The Ruby output of the function would be a Array containing both 138 output values. 139 */ 140 141 %define OUTPUT_TYPEMAP(type, converter, convtype) 142 %typemap(in,numinputs=0) type *OUTPUT($*1_ltype temp), type &OUTPUT($*1_ltype temp) "$1 = &temp;"; 143 %typemap(argout, fragment="output_helper") type *OUTPUT, type &OUTPUT { 144 VALUE o = converter(convtype (*$1)); 145 $result = output_helper($result, o); 146 } 147 %enddef 148 149 OUTPUT_TYPEMAP(int, INT2NUM, (int)); 150 OUTPUT_TYPEMAP(short, INT2NUM, (int)); 151 OUTPUT_TYPEMAP(long, INT2NUM, (long)); 152 OUTPUT_TYPEMAP(long long, LL2NUM, (long long)); 153 OUTPUT_TYPEMAP(unsigned int, UINT2NUM, (unsigned int)); 154 OUTPUT_TYPEMAP(unsigned short, UINT2NUM, (unsigned int)); 155 OUTPUT_TYPEMAP(unsigned long, UINT2NUM, (unsigned long)); 156 OUTPUT_TYPEMAP(unsigned long long, ULL2NUM, (unsigned long long)); 157 OUTPUT_TYPEMAP(unsigned char, UINT2NUM, (unsigned int)); 158 OUTPUT_TYPEMAP(signed char, INT2NUM, (int)); 159 OUTPUT_TYPEMAP(float, rb_float_new, (double)); 160 OUTPUT_TYPEMAP(double, rb_float_new, (double)); 161 162 #undef OUTPUT_TYPEMAP 163 164 %typemap(in,numinputs=0) bool *OUTPUT(bool temp), bool &OUTPUT(bool temp) "$1 = &temp;"; 165 %typemap(argout, fragment="output_helper") bool *OUTPUT, bool &OUTPUT { 166 VALUE o = (*$1) ? Qtrue : Qfalse; 167 $result = output_helper($result, o); 168 } 169 170 // INOUT 171 // Mappings for an argument that is both an input and output 172 // parameter 173 174 /* 175 The following methods can be applied to make a function parameter both 176 an input and output value. This combines the behavior of both the 177 "INPUT" and "OUTPUT" methods described earlier. Output values are 178 returned in the form of a Ruby array. 179 180 int *INOUT 181 short *INOUT 182 long *INOUT 183 long long *INOUT 184 unsigned int *INOUT 185 unsigned short *INOUT 186 unsigned long *INOUT 187 unsigned long long *INOUT 188 unsigned char *INOUT 189 bool *INOUT 190 float *INOUT 191 double *INOUT 192 193 For example, suppose you were trying to wrap the following function : 194 195 void neg(double *x) { 196 *x = -(*x); 197 } 198 199 You could wrap it with SWIG as follows : 200 201 %include typemaps.i 202 void neg(double *INOUT); 203 204 or you can use the %apply directive : 205 206 %include typemaps.i 207 %apply double *INOUT { double *x }; 208 void neg(double *x); 209 210 Unlike C, this mapping does not directly modify the input value (since 211 this makes no sense in Ruby). Rather, the modified input value shows 212 up as the return value of the function. Thus, to apply this function 213 to a Ruby variable you might do this : 214 215 x = neg(x) 216 217 Note : previous versions of SWIG used the symbol 'BOTH' to mark 218 input/output arguments. This is still supported, but will be slowly 219 phased out in future releases. 220 221 */ 222 223 %typemap(in) int *INOUT = int *INPUT; 224 %typemap(in) short *INOUT = short *INPUT; 225 %typemap(in) long *INOUT = long *INPUT; 226 %typemap(in) long long *INOUT = long long *INPUT; 227 %typemap(in) unsigned *INOUT = unsigned *INPUT; 228 %typemap(in) unsigned short *INOUT = unsigned short *INPUT; 229 %typemap(in) unsigned long *INOUT = unsigned long *INPUT; 230 %typemap(in) unsigned long long *INOUT = unsigned long long *INPUT; 231 %typemap(in) unsigned char *INOUT = unsigned char *INPUT; 232 %typemap(in) signed char *INOUT = signed char *INPUT; 233 %typemap(in) bool *INOUT = bool *INPUT; 234 %typemap(in) float *INOUT = float *INPUT; 235 %typemap(in) double *INOUT = double *INPUT; 236 237 %typemap(in) int &INOUT = int &INPUT; 238 %typemap(in) short &INOUT = short &INPUT; 239 %typemap(in) long &INOUT = long &INPUT; 240 %typemap(in) long long &INOUT = long long &INPUT; 241 %typemap(in) unsigned &INOUT = unsigned &INPUT; 242 %typemap(in) unsigned short &INOUT = unsigned short &INPUT; 243 %typemap(in) unsigned long &INOUT = unsigned long &INPUT; 244 %typemap(in) unsigned long long &INOUT = unsigned long long &INPUT; 245 %typemap(in) unsigned char &INOUT = unsigned char &INPUT; 246 %typemap(in) signed char &INOUT = signed char &INPUT; 247 %typemap(in) bool &INOUT = bool &INPUT; 248 %typemap(in) float &INOUT = float &INPUT; 249 %typemap(in) double &INOUT = double &INPUT; 250 251 %typemap(argout) int *INOUT = int *OUTPUT; 252 %typemap(argout) short *INOUT = short *OUTPUT; 253 %typemap(argout) long *INOUT = long *OUTPUT; 254 %typemap(argout) long long *INOUT = long long *OUTPUT; 255 %typemap(argout) unsigned *INOUT = unsigned *OUTPUT; 256 %typemap(argout) unsigned short *INOUT = unsigned short *OUTPUT; 257 %typemap(argout) unsigned long *INOUT = unsigned long *OUTPUT; 258 %typemap(argout) unsigned long long *INOUT = unsigned long long *OUTPUT; 259 %typemap(argout) unsigned char *INOUT = unsigned char *OUTPUT; 260 %typemap(argout) signed char *INOUT = signed char *OUTPUT; 261 %typemap(argout) bool *INOUT = bool *OUTPUT; 262 %typemap(argout) float *INOUT = float *OUTPUT; 263 %typemap(argout) double *INOUT = double *OUTPUT; 264 265 %typemap(argout) int &INOUT = int &OUTPUT; 266 %typemap(argout) short &INOUT = short &OUTPUT; 267 %typemap(argout) long &INOUT = long &OUTPUT; 268 %typemap(argout) long long &INOUT = long long &OUTPUT; 269 %typemap(argout) unsigned &INOUT = unsigned &OUTPUT; 270 %typemap(argout) unsigned short &INOUT = unsigned short &OUTPUT; 271 %typemap(argout) unsigned long &INOUT = unsigned long &OUTPUT; 272 %typemap(argout) unsigned long long &INOUT = unsigned long long &OUTPUT; 273 %typemap(argout) unsigned char &INOUT = unsigned char &OUTPUT; 274 %typemap(argout) signed char &INOUT = signed char &OUTPUT; 275 %typemap(argout) bool &INOUT = bool &OUTPUT; 276 %typemap(argout) float &INOUT = float &OUTPUT; 277 %typemap(argout) double &INOUT = double &OUTPUT; 278 279 /* Overloading information */ 280 281 %typemap(typecheck) double *INOUT = double; 282 %typemap(typecheck) signed char *INOUT = signed char; 283 %typemap(typecheck) unsigned char *INOUT = unsigned char; 284 %typemap(typecheck) unsigned long *INOUT = unsigned long; 285 %typemap(typecheck) unsigned long long *INOUT = unsigned long long; 286 %typemap(typecheck) unsigned short *INOUT = unsigned short; 287 %typemap(typecheck) unsigned int *INOUT = unsigned int; 288 %typemap(typecheck) long *INOUT = long; 289 %typemap(typecheck) long long *INOUT = long long; 290 %typemap(typecheck) short *INOUT = short; 291 %typemap(typecheck) int *INOUT = int; 292 %typemap(typecheck) float *INOUT = float; 293 294 %typemap(typecheck) double &INOUT = double; 295 %typemap(typecheck) signed char &INOUT = signed char; 296 %typemap(typecheck) unsigned char &INOUT = unsigned char; 297 %typemap(typecheck) unsigned long &INOUT = unsigned long; 298 %typemap(typecheck) unsigned long long &INOUT = unsigned long long; 299 %typemap(typecheck) unsigned short &INOUT = unsigned short; 300 %typemap(typecheck) unsigned int &INOUT = unsigned int; 301 %typemap(typecheck) long &INOUT = long; 302 %typemap(typecheck) long long &INOUT = long long; 303 %typemap(typecheck) short &INOUT = short; 304 %typemap(typecheck) int &INOUT = int; 305 %typemap(typecheck) float &INOUT = float; 306 307 #endif 308 309 // -------------------------------------------------------------------- 310 // Special types 311 // -------------------------------------------------------------------- 312 %include <progargcargv.i> 313 %include <file.i> 314 %include <timeval.i> 315
