Commit | Line | Data |
---|---|---|
920dae64 AT |
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 |