projects / OpenSPARC-T2-SAM / blame
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Initial commit of OpenSPARC T2 architecture model.
[OpenSPARC-T2-SAM] / sam-t2 / devtools / amd64 / share / swig / 1.3.26 / csharp / typemaps.i
CommitLineData
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
14INPUT typemaps\r
15--------------\r
16\r
17These typemaps are used for pointer/reference parameters that are input only\r
18are mapped to a C# input parameter.\r
19\r
20The following typemaps can be applied to turn a pointer or reference into a simple\r
21input value. That is, instead of passing a pointer or reference to an object,\r
22you 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
38To 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
44You 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
49or 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
55In 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
73INPUT_TYPEMAP(bool, unsigned int, bool)\r
74//INPUT_TYPEMAP(char, char, char)\r
75INPUT_TYPEMAP(signed char, signed char, sbyte)\r
76INPUT_TYPEMAP(unsigned char, unsigned char, byte)\r
77INPUT_TYPEMAP(short, short, short)\r
78INPUT_TYPEMAP(unsigned short, unsigned short, ushort)\r
79INPUT_TYPEMAP(int, int, int)\r
80INPUT_TYPEMAP(unsigned int, unsigned int, uint)\r
81INPUT_TYPEMAP(long, long, int)\r
82INPUT_TYPEMAP(unsigned long, unsigned long, uint)\r
83INPUT_TYPEMAP(long long, long long, long)\r
84INPUT_TYPEMAP(unsigned long long, unsigned long long, ulong)\r
85INPUT_TYPEMAP(float, float, float)\r
86INPUT_TYPEMAP(double, double, double)\r
87\r
88#undef INPUT_TYPEMAP\r
89\r
90/*\r
91OUTPUT typemaps\r
92---------------\r
93\r
94These typemaps are used for pointer/reference parameters that are output only and\r
95are mapped to a C# output parameter.\r
96\r
97The following typemaps can be applied to turn a pointer or reference into an "output"\r
98value. When calling a function, no input value would be given for\r
99a parameter, but an output value would be returned. In C#, the 'out' keyword is\r
100used 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
116For example, suppose you were trying to wrap the modf() function in the\r
117C math library which splits x into integral and fractional parts (and\r
118returns the integer part in one of its parameters):\r
119\r
120 double modf(double x, double *ip);\r
121\r
122You 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
127or 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
133The C# output of the function would be the function return value and the \r
134value 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
153OUTPUT_TYPEMAP(bool, unsigned int, bool, BOOL_PTR)\r
154//OUTPUT_TYPEMAP(char, char, char, CHAR_PTR)\r
155OUTPUT_TYPEMAP(signed char, signed char, sbyte, INT8_PTR)\r
156OUTPUT_TYPEMAP(unsigned char, unsigned char, byte, UINT8_PTR)\r
157OUTPUT_TYPEMAP(short, short, short, INT16_PTR)\r
158OUTPUT_TYPEMAP(unsigned short, unsigned short, ushort, UINT16_PTR)\r
159OUTPUT_TYPEMAP(int, int, int, INT32_PTR)\r
160OUTPUT_TYPEMAP(unsigned int, unsigned int, uint, UINT32_PTR)\r
161OUTPUT_TYPEMAP(long, long, int, INT32_PTR)\r
162OUTPUT_TYPEMAP(unsigned long, unsigned long, uint, UINT32_PTR)\r
163OUTPUT_TYPEMAP(long long, long long, long, INT64_PTR)\r
164OUTPUT_TYPEMAP(unsigned long long, unsigned long long, ulong, UINT64_PTR)\r
165OUTPUT_TYPEMAP(float, float, float, FLOAT_PTR)\r
166OUTPUT_TYPEMAP(double, double, double, DOUBLE_PTR)\r
167\r
168#undef OUTPUT_TYPEMAP\r
169\r
170\r
171/*\r
172INOUT typemaps\r
173--------------\r
174\r
175These typemaps are for pointer/reference parameters that are both input and\r
176output and are mapped to a C# reference parameter.\r
177\r
178The following typemaps can be applied to turn a pointer or reference into a\r
179reference parameters, that is the parameter is both an input and an output.\r
180In 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
196For 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
202You could wrap it with SWIG as follows :\r
203\r
204 %include "typemaps.i"\r
205 void neg(double *INOUT);\r
206\r
207or 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
213The C# output of the function would be the new value returned by the \r
214reference 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
220The implementation of the OUTPUT and INOUT typemaps is different to the scripting\r
221languages in that the scripting languages will return the output value as part \r
222of 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
238INOUT_TYPEMAP(bool, unsigned int, bool, BOOL_PTR)\r
239//INOUT_TYPEMAP(char, char, char, CHAR_PTR)\r
240INOUT_TYPEMAP(signed char, signed char, sbyte, INT8_PTR)\r
241INOUT_TYPEMAP(unsigned char, unsigned char, byte, UINT8_PTR)\r
242INOUT_TYPEMAP(short, short, short, INT16_PTR)\r
243INOUT_TYPEMAP(unsigned short, unsigned short, ushort, UINT16_PTR)\r
244INOUT_TYPEMAP(int, int, int, INT32_PTR)\r
245INOUT_TYPEMAP(unsigned int, unsigned int, uint, UINT32_PTR)\r
246INOUT_TYPEMAP(long, long, int, INT32_PTR)\r
247INOUT_TYPEMAP(unsigned long, unsigned long, uint, UINT32_PTR)\r
248INOUT_TYPEMAP(long long, long long, long, INT64_PTR)\r
249INOUT_TYPEMAP(unsigned long long, unsigned long long, ulong, UINT64_PTR)\r
250INOUT_TYPEMAP(float, float, float, FLOAT_PTR)\r
251INOUT_TYPEMAP(double, double, double, DOUBLE_PTR)\r
252\r
253#undef INOUT_TYPEMAP\r
254\r
Full OpenSPARC architecture tarball including simulator, hypervisor, and OBP.