Mercurial > pub > dyncall > dyncall
annotate test/plain/test_main.c @ 188:44ae5b653086
- more endian detection in macros
author | Tassilo Philipp |
---|---|
date | Mon, 13 Mar 2017 13:23:10 +0100 |
parents | 0ab08c1541f0 |
children | f5577f6bf97a |
rev | line source |
---|---|
0 | 1 /* |
2 | |
3 Package: dyncall | |
4 Library: test | |
5 File: test/plain/test_main.c | |
6 Description: | |
7 License: | |
8 | |
9 Copyright (c) 2007-2015 Daniel Adler <dadler@uni-goettingen.de>, | |
10 Tassilo Philipp <tphilipp@potion-studios.com> | |
11 | |
12 Permission to use, copy, modify, and distribute this software for any | |
13 purpose with or without fee is hereby granted, provided that the above | |
14 copyright notice and this permission notice appear in all copies. | |
15 | |
16 THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES | |
17 WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF | |
18 MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR | |
19 ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES | |
20 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN | |
21 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF | |
22 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. | |
23 | |
24 */ | |
25 | |
26 | |
27 | |
28 | |
141 | 29 #include "../common/test_framework.h" |
0 | 30 #include "../../dyncall/dyncall.h" |
31 #include "../common/platformInit.h" | |
32 #include "../common/platformInit.c" /* Impl. for functions only used in this translation unit */ | |
33 | |
34 | |
35 /* ------------------------------------------------------------------------- | |
36 * test: identity function calls | |
37 * ------------------------------------------------------------------------- */ | |
38 | |
39 #define DEF_FUNCS(API,NAME) \ | |
40 void API fun_##NAME##_v() { } \ | |
41 DCbool API fun_##NAME##_b(DCbool x) { return x; } \ | |
42 DCint API fun_##NAME##_i(DCint x) { return x; } \ | |
43 DClong API fun_##NAME##_j(DClong x) { return x; } \ | |
44 DClonglong API fun_##NAME##_l(DClonglong x) { return x; } \ | |
45 DCfloat API fun_##NAME##_f(DCfloat x) { return x; } \ | |
46 DCdouble API fun_##NAME##_d(DCdouble x) { return x; } \ | |
47 DCpointer API fun_##NAME##_p(DCpointer x) { return x; } | |
48 | |
49 /* __cdecl */ | |
50 | |
51 #if !defined(DC__OS_Win32) | |
52 # define __declspec(X) | |
53 # define __cdecl | |
54 #endif | |
55 | |
56 DEF_FUNCS(__cdecl,c) | |
57 | |
58 DC_DEFINE_TEST_FUNC_BEGIN(testCallC) | |
59 | |
60 DCCallVM* pc = dcNewCallVM(4096); | |
61 dcMode(pc,DC_CALL_C_DEFAULT); | |
62 /* void */ | |
63 dcReset(pc); | |
64 dcCallVoid(pc, (DCpointer) &fun_c_v); | |
65 /* bool */ | |
66 { | |
67 DCbool r, val=DC_TRUE; | |
68 dcReset(pc); | |
69 dcArgBool(pc, val); | |
70 r = dcCallBool(pc, (DCpointer) &fun_c_b); | |
71 DC_TEST(r == val); | |
72 | |
146
0ab08c1541f0
- fixed armhf ellipsis calls, were ignoring spill area
cslag
parents:
141
diff
changeset
|
73 val=DC_FALSE; |
0 | 74 dcReset(pc); |
75 dcArgBool(pc, val); | |
76 r = dcCallBool(pc, (DCpointer) &fun_c_b); | |
77 DC_TEST(r == val); | |
78 } | |
79 /* int */ | |
80 { | |
81 DCint r, val=1234; | |
82 dcReset(pc); | |
83 dcArgInt(pc, val); | |
84 r = dcCallInt(pc, (DCpointer) &fun_c_i); | |
85 DC_TEST(r == val); | |
86 } | |
87 /* long */ | |
88 { | |
89 DClong r, val=(DClong) 0xCAFEBABEL; | |
90 dcReset(pc); | |
91 dcArgLong(pc, val); | |
92 r = dcCallLong(pc, (DCpointer) &fun_c_j); | |
93 DC_TEST(r == val); | |
94 } | |
95 /* long long */ | |
96 { | |
97 DClonglong r, val=(DClonglong) 0xCAFEBABEDEADC0DELL; | |
98 dcReset(pc); | |
99 dcArgLongLong(pc, val); | |
100 r = dcCallLongLong(pc, (DCpointer) &fun_c_l); | |
101 DC_TEST(r == (DClonglong)val); | |
102 } | |
103 /* float */ | |
104 { | |
105 DCfloat r, val=1.234567f; | |
106 dcReset(pc); | |
107 dcArgFloat(pc, val); | |
108 r = dcCallFloat(pc, (DCpointer) &fun_c_f); | |
109 DC_TEST(r == val); | |
110 } | |
111 /* double */ | |
112 { | |
113 DCdouble r, val=1.23456789; | |
114 dcReset(pc); | |
115 dcArgDouble(pc, val); | |
116 r = dcCallDouble(pc, (DCpointer) &fun_c_d); | |
117 DC_TEST(r == val); | |
118 } | |
119 /* ptr */ | |
120 { | |
121 DCpointer r; | |
122 dcReset(pc); | |
123 dcArgPointer(pc, (DCpointer) &fun_c_b); | |
124 r = dcCallPointer(pc, (DCpointer) &fun_c_p); | |
125 DC_TEST(r == (DCpointer) &fun_c_b); | |
126 } | |
127 dcFree(pc); | |
128 | |
129 DC_DEFINE_TEST_FUNC_END | |
130 | |
131 | |
132 #ifdef DC__OS_Win32 | |
133 /* win32 __stdcall */ | |
134 | |
135 DEF_FUNCS(__stdcall,std) | |
136 | |
137 DC_DEFINE_TEST_FUNC_BEGIN(testCallStd) | |
138 | |
139 DCCallVM* pc = dcNewCallVM(4096); | |
140 dcMode(pc,DC_CALL_C_X86_WIN32_STD); | |
141 /* void */ | |
142 dcReset(pc); | |
143 dcCallVoid(pc, (DCpointer) &fun_std_v); | |
144 /* bool */ | |
145 { | |
146 DCbool r, val=DC_TRUE; | |
147 dcReset(pc); | |
148 dcArgBool(pc, val); | |
149 r = dcCallBool(pc, (DCpointer) &fun_std_b); | |
150 DC_TEST(r == val); | |
151 | |
146
0ab08c1541f0
- fixed armhf ellipsis calls, were ignoring spill area
cslag
parents:
141
diff
changeset
|
152 val=DC_FALSE; |
0 | 153 dcReset(pc); |
154 dcArgBool(pc, val); | |
155 r = dcCallBool(pc, (DCpointer) &fun_std_b); | |
156 DC_TEST(r == val); | |
157 } | |
158 /* int */ | |
159 { | |
160 DCint r, val=1234; | |
161 dcReset(pc); | |
162 dcArgInt(pc, val); | |
163 r = dcCallInt(pc, (DCpointer) &fun_std_i); | |
164 DC_TEST(r == val); | |
165 } | |
166 /* long */ | |
167 { | |
168 DClong r, val=0xCAFEBABEUL; | |
169 dcReset(pc); | |
170 dcArgLong(pc, val); | |
171 r = dcCallLong(pc, (DCpointer) &fun_std_j); | |
172 DC_TEST(r == val); | |
173 } | |
174 /* long long */ | |
175 { | |
176 DClonglong r, val=0xCAFEBABEDEADC0DEULL; | |
177 dcReset(pc); | |
178 dcArgLongLong(pc, val); | |
179 r = dcCallLongLong(pc, (DCpointer) &fun_std_l); | |
180 DC_TEST(r == val); | |
181 } | |
182 /* float */ | |
183 { | |
184 DCfloat r, val=1.234567f; | |
185 dcReset(pc); | |
186 dcArgFloat(pc, val); | |
187 r = dcCallFloat(pc, (DCpointer) &fun_std_f); | |
188 DC_TEST(r == val); | |
189 } | |
190 /* double */ | |
191 { | |
192 DCdouble r, val=1.23456789; | |
193 dcReset(pc); | |
194 dcArgDouble(pc, val); | |
195 r = dcCallDouble(pc, (DCpointer) &fun_std_d); | |
196 DC_TEST(r == val); | |
197 } | |
198 /* ptr */ | |
199 { | |
200 DCpointer r; | |
201 dcReset(pc); | |
202 dcArgPointer(pc, (DCpointer) &fun_c_b); | |
203 r = dcCallPointer(pc, (DCpointer) &fun_std_p); | |
204 DC_TEST(r == &fun_c_b); | |
205 } | |
206 dcFree(pc); | |
207 | |
208 DC_DEFINE_TEST_FUNC_END | |
209 | |
210 #endif | |
211 | |
212 | |
213 #ifdef DC__OS_Win32 | |
214 /* win32 __fastcall */ | |
215 | |
216 DEF_FUNCS(__fastcall,fast) | |
217 | |
218 DC_DEFINE_TEST_FUNC_BEGIN(testCallFast) | |
219 | |
220 DCCallVM* pc = dcNewCallVM(4096); | |
221 #ifdef DC__C_GNU | |
222 dcMode(pc,DC_CALL_C_X86_WIN32_FAST_GNU); | |
223 #else | |
224 dcMode(pc,DC_CALL_C_X86_WIN32_FAST_MS); | |
225 #endif | |
226 /* void */ | |
227 dcReset(pc); | |
228 dcCallVoid(pc, (DCpointer) &fun_fast_v); | |
229 /* bool */ | |
230 { | |
231 DCbool r, val=DC_TRUE; | |
232 dcReset(pc); | |
233 dcArgBool(pc, val); | |
234 r = dcCallBool(pc, (DCpointer) &fun_fast_b); | |
235 DC_TEST(r == val); | |
236 | |
146
0ab08c1541f0
- fixed armhf ellipsis calls, were ignoring spill area
cslag
parents:
141
diff
changeset
|
237 val=DC_FALSE; |
0 | 238 dcReset(pc); |
239 dcArgBool(pc, val); | |
240 r = dcCallBool(pc, (DCpointer) &fun_fast_b); | |
241 DC_TEST(r == val); | |
242 } | |
243 /* int */ | |
244 { | |
245 DCint r, val=1234; | |
246 dcReset(pc); | |
247 dcArgInt(pc, val); | |
248 r = dcCallInt(pc, (DCpointer) &fun_fast_i); | |
249 DC_TEST(r == val); | |
250 } | |
251 /* long */ | |
252 { | |
253 DClong r, val=0xCAFEBABEUL; | |
254 dcReset(pc); | |
255 dcArgLong(pc, val); | |
256 r = dcCallLong(pc, (DCpointer) &fun_fast_j); | |
257 DC_TEST(r == val); | |
258 } | |
259 /* long long */ | |
260 { | |
261 DClonglong r, val=0xCAFEBABEDEADC0DEULL; | |
262 dcReset(pc); | |
263 dcArgLongLong(pc, val); | |
264 r = dcCallLongLong(pc, (DCpointer) &fun_fast_l); | |
265 DC_TEST(r == val); | |
266 } | |
267 /* float */ | |
268 { | |
269 DCfloat r, val=1.234567f; | |
270 dcReset(pc); | |
271 dcArgFloat(pc, val); | |
272 r = dcCallFloat(pc, (DCpointer) &fun_fast_f); | |
273 DC_TEST(r == val); | |
274 } | |
275 /* double */ | |
276 { | |
277 DCdouble r, val=1.23456789; | |
278 dcReset(pc); | |
279 dcArgDouble(pc, val); | |
280 r = dcCallDouble(pc, (DCpointer) &fun_fast_d); | |
281 DC_TEST(r == val); | |
282 } | |
283 /* ptr */ | |
284 { | |
285 DCpointer r; | |
286 dcReset(pc); | |
287 dcArgPointer(pc, (DCpointer) &fun_c_b); | |
288 r = dcCallPointer(pc, (DCpointer) &fun_fast_p); | |
289 DC_TEST(r == &fun_c_b); | |
290 } | |
291 dcFree(pc); | |
292 | |
293 DC_DEFINE_TEST_FUNC_END | |
294 #endif | |
295 | |
296 int testCallStructs(); | |
297 int testStructSizes(); | |
298 int main(int argc, char* argv[]) | |
299 { | |
300 int b = TRUE; | |
301 dcTest_initPlatform(); | |
302 | |
303 b = b && testCallC(); | |
304 printf("C:%d\n",b); | |
305 | |
306 b = b && testStructSizes(); | |
307 printf("Struct Sizes:%d\n",b); | |
308 | |
309 /*b = b && testCallStructs(); | |
310 printf("Call Structs:%d\n",b);*/ | |
311 | |
312 #if defined(DC__OS_Win32) | |
313 | |
314 b = b && testCallStd(); | |
315 printf("Std:%d\n",b); | |
316 | |
317 b = b && testCallFast(); | |
318 #ifdef DC__C_GNU | |
319 printf("FastGNU:%d\n",b); | |
320 #else | |
321 printf("FastMS:%d\n",b); | |
322 #endif | |
323 | |
324 #endif | |
325 | |
326 printf("result: plain: %d\n", b); | |
327 | |
328 dcTest_deInitPlatform(); | |
329 | |
330 return !b; | |
331 } | |
332 |