Mercurial > pub > dyncall > dyncall

comparison test/plain/test_main.c @ 531:f6430d194be6

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
cleanups
author Tassilo Philipp
date Sat, 16 Apr 2022 14:59:05 +0200
parents da4b267c10bf
children d4bf63ab9164
comparison
equal deleted inserted replaced
530:585dcb68f55d 531:f6430d194be6
4 Library: test 4 Library: test
5 File: test/plain/test_main.c 5 File: test/plain/test_main.c
6 Description: 6 Description:
7 License: 7 License:
8 8
9 Copyright (c) 2007-2019 Daniel Adler <dadler@uni-goettingen.de>, 9 Copyright (c) 2007-2022 Daniel Adler <dadler@uni-goettingen.de>,
10 Tassilo Philipp <tphilipp@potion-studios.com> 10 Tassilo Philipp <tphilipp@potion-studios.com>
11 11
12 Permission to use, copy, modify, and distribute this software for any 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 13 purpose with or without fee is hereby granted, provided that the above
14 copyright notice and this permission notice appear in all copies. 14 copyright notice and this permission notice appear in all copies.
52 #endif 52 #endif
53 53
54 int g_void_testval; 54 int g_void_testval;
55 DEF_FUNCS(__cdecl,c) 55 DEF_FUNCS(__cdecl,c)
56 56
57 int testCallC() 57 static int testCallC()
58 { 58 {
59 int ret = 1; 59 int ret = 1;
60 60
61 DCCallVM* pc = dcNewCallVM(4096); 61 DCCallVM* pc = dcNewCallVM(4096);
62 dcMode(pc,DC_CALL_C_DEFAULT); 62 dcMode(pc,DC_CALL_C_DEFAULT);
70 DCbool r, val=DC_TRUE; 70 DCbool r, val=DC_TRUE;
71 dcReset(pc); 71 dcReset(pc);
72 dcArgBool(pc, val); 72 dcArgBool(pc, val);
73 r = dcCallBool(pc, (DCpointer) &fun_c_b); 73 r = dcCallBool(pc, (DCpointer) &fun_c_b);
74 printf("bt (cdecl): %d\n", (r == val)); 74 printf("bt (cdecl): %d\n", (r == val));
75 ret = (r == val) && ret; 75 ret = (r == val) && ret;
76 76
77 val=DC_FALSE; 77 val=DC_FALSE;
78 dcReset(pc); 78 dcReset(pc);
79 dcArgBool(pc, val); 79 dcArgBool(pc, val);
80 r = dcCallBool(pc, (DCpointer) &fun_c_b); 80 r = dcCallBool(pc, (DCpointer) &fun_c_b);
81 printf("bf (cdecl): %d\n", (r == val)); 81 printf("bf (cdecl): %d\n", (r == val));
82 ret = (r == val) && ret; 82 ret = (r == val) && ret;
83 } 83 }
84 /* int */ 84 /* int */
85 { 85 {
86 DCint r, val=1234; 86 DCint r, val=1234;
87 dcReset(pc); 87 dcReset(pc);
88 dcArgInt(pc, val); 88 dcArgInt(pc, val);
89 r = dcCallInt(pc, (DCpointer) &fun_c_i); 89 r = dcCallInt(pc, (DCpointer) &fun_c_i);
90 printf("i (cdecl): %d\n", (r == val)); 90 printf("i (cdecl): %d\n", (r == val));
91 ret = (r == val) && ret; 91 ret = (r == val) && ret;
92 } 92 }
93 /* long */ 93 /* long */
94 { 94 {
95 DClong r, val=(DClong) 0xCAFEBABEL; 95 DClong r, val=(DClong) 0xCAFEBABEL;
96 dcReset(pc); 96 dcReset(pc);
97 dcArgLong(pc, val); 97 dcArgLong(pc, val);
98 r = dcCallLong(pc, (DCpointer) &fun_c_j); 98 r = dcCallLong(pc, (DCpointer) &fun_c_j);
99 printf("l (cdecl): %d\n", (r == val)); 99 printf("l (cdecl): %d\n", (r == val));
100 ret = (r == val) && ret; 100 ret = (r == val) && ret;
101 } 101 }
102 /* long long */ 102 /* long long */
103 { 103 {
104 DClonglong r, val=(DClonglong) 0xCAFEBABEDEADC0DELL; 104 DClonglong r, val=(DClonglong) 0xCAFEBABEDEADC0DELL;
105 dcReset(pc); 105 dcReset(pc);
106 dcArgLongLong(pc, val); 106 dcArgLongLong(pc, val);
107 r = dcCallLongLong(pc, (DCpointer) &fun_c_l); 107 r = dcCallLongLong(pc, (DCpointer) &fun_c_l);
108 printf("ll (cdecl): %d\n", (r == (DClonglong)val)); 108 printf("ll (cdecl): %d\n", (r == (DClonglong)val));
109 ret = (r == (DClonglong)val) && ret; 109 ret = (r == (DClonglong)val) && ret;
110 } 110 }
111 /* float */ 111 /* float */
112 { 112 {
113 DCfloat r, val=1.234567f; 113 DCfloat r, val=1.234567f;
114 dcReset(pc); 114 dcReset(pc);
115 dcArgFloat(pc, val); 115 dcArgFloat(pc, val);
116 r = dcCallFloat(pc, (DCpointer) &fun_c_f); 116 r = dcCallFloat(pc, (DCpointer) &fun_c_f);
117 printf("f (cdecl): %d\n", (r == val)); 117 printf("f (cdecl): %d\n", (r == val));
118 ret = (r == val) && ret; 118 ret = (r == val) && ret;
119 } 119 }
120 /* double */ 120 /* double */
121 { 121 {
122 DCdouble r, val=1.23456789; 122 DCdouble r, val=1.23456789;
123 dcReset(pc); 123 dcReset(pc);
124 dcArgDouble(pc, val); 124 dcArgDouble(pc, val);
125 r = dcCallDouble(pc, (DCpointer) &fun_c_d); 125 r = dcCallDouble(pc, (DCpointer) &fun_c_d);
126 printf("d (cdecl): %d\n", (r == val)); 126 printf("d (cdecl): %d\n", (r == val));
127 ret = (r == val) && ret; 127 ret = (r == val) && ret;
128 } 128 }
129 /* ptr */ 129 /* ptr */
130 { 130 {
131 DCpointer r; 131 DCpointer r;
132 dcReset(pc); 132 dcReset(pc);
133 dcArgPointer(pc, (DCpointer) &fun_c_b); 133 dcArgPointer(pc, (DCpointer) &fun_c_b);
134 r = dcCallPointer(pc, (DCpointer) &fun_c_p); 134 r = dcCallPointer(pc, (DCpointer) &fun_c_p);
135 printf("p (cdecl): %d\n", (r == (DCpointer) &fun_c_b)); 135 printf("p (cdecl): %d\n", (r == (DCpointer) &fun_c_b));
136 ret = (r == (DCpointer) &fun_c_b) && ret; 136 ret = (r == (DCpointer) &fun_c_b) && ret;
137 } 137 }
138 dcFree(pc); 138 dcFree(pc);
139 139
140 return ret; 140 return ret;
141 } 141 }
144 #if defined(DC__OS_Win32) 144 #if defined(DC__OS_Win32)
145 /* win32 __stdcall */ 145 /* win32 __stdcall */
146 146
147 DEF_FUNCS(__stdcall,std) 147 DEF_FUNCS(__stdcall,std)
148 148
149 int testCallStd() 149 static int testCallStd()
150 { 150 {
151 int ret = 1; 151 int ret = 1;
152 152
153 DCCallVM* pc = dcNewCallVM(4096); 153 DCCallVM* pc = dcNewCallVM(4096);
154 dcMode(pc,DC_CALL_C_X86_WIN32_STD); 154 dcMode(pc,DC_CALL_C_X86_WIN32_STD);
162 DCbool r, val=DC_TRUE; 162 DCbool r, val=DC_TRUE;
163 dcReset(pc); 163 dcReset(pc);
164 dcArgBool(pc, val); 164 dcArgBool(pc, val);
165 r = dcCallBool(pc, (DCpointer) &fun_std_b); 165 r = dcCallBool(pc, (DCpointer) &fun_std_b);
166 printf("bt (stdcall): %d\n", (r == val)); 166 printf("bt (stdcall): %d\n", (r == val));
167 ret = (r == val) && ret; 167 ret = (r == val) && ret;
168 168
169 val=DC_FALSE; 169 val=DC_FALSE;
170 dcReset(pc); 170 dcReset(pc);
171 dcArgBool(pc, val); 171 dcArgBool(pc, val);
172 r = dcCallBool(pc, (DCpointer) &fun_std_b); 172 r = dcCallBool(pc, (DCpointer) &fun_std_b);
173 printf("bf (stdcall): %d\n", (r == val)); 173 printf("bf (stdcall): %d\n", (r == val));
174 ret = (r == val) && ret; 174 ret = (r == val) && ret;
175 } 175 }
176 /* int */ 176 /* int */
177 { 177 {
178 DCint r, val=1234; 178 DCint r, val=1234;
179 dcReset(pc); 179 dcReset(pc);
180 dcArgInt(pc, val); 180 dcArgInt(pc, val);
181 r = dcCallInt(pc, (DCpointer) &fun_std_i); 181 r = dcCallInt(pc, (DCpointer) &fun_std_i);
182 printf("i (stdcall): %d\n", (r == val)); 182 printf("i (stdcall): %d\n", (r == val));
183 ret = (r == val) && ret; 183 ret = (r == val) && ret;
184 } 184 }
185 /* long */ 185 /* long */
186 { 186 {
187 DClong r, val=0xCAFEBABEUL; 187 DClong r, val=0xCAFEBABEUL;
188 dcReset(pc); 188 dcReset(pc);
189 dcArgLong(pc, val); 189 dcArgLong(pc, val);
190 r = dcCallLong(pc, (DCpointer) &fun_std_j); 190 r = dcCallLong(pc, (DCpointer) &fun_std_j);
191 printf("l (stdcall): %d\n", (r == val)); 191 printf("l (stdcall): %d\n", (r == val));
192 ret = (r == val) && ret; 192 ret = (r == val) && ret;
193 } 193 }
194 /* long long */ 194 /* long long */
195 { 195 {
196 DClonglong r, val=0xCAFEBABEDEADC0DEULL; 196 DClonglong r, val=0xCAFEBABEDEADC0DEULL;
197 dcReset(pc); 197 dcReset(pc);
198 dcArgLongLong(pc, val); 198 dcArgLongLong(pc, val);
199 r = dcCallLongLong(pc, (DCpointer) &fun_std_l); 199 r = dcCallLongLong(pc, (DCpointer) &fun_std_l);
200 printf("ll (stdcall): %d\n", (r == val)); 200 printf("ll (stdcall): %d\n", (r == val));
201 ret = (r == val) && ret; 201 ret = (r == val) && ret;
202 } 202 }
203 /* float */ 203 /* float */
204 { 204 {
205 DCfloat r, val=1.234567f; 205 DCfloat r, val=1.234567f;
206 dcReset(pc); 206 dcReset(pc);
207 dcArgFloat(pc, val); 207 dcArgFloat(pc, val);
208 r = dcCallFloat(pc, (DCpointer) &fun_std_f); 208 r = dcCallFloat(pc, (DCpointer) &fun_std_f);
209 printf("f (stdcall): %d\n", (r == val)); 209 printf("f (stdcall): %d\n", (r == val));
210 ret = (r == val) && ret; 210 ret = (r == val) && ret;
211 } 211 }
212 /* double */ 212 /* double */
213 { 213 {
214 DCdouble r, val=1.23456789; 214 DCdouble r, val=1.23456789;
215 dcReset(pc); 215 dcReset(pc);
216 dcArgDouble(pc, val); 216 dcArgDouble(pc, val);
217 r = dcCallDouble(pc, (DCpointer) &fun_std_d); 217 r = dcCallDouble(pc, (DCpointer) &fun_std_d);
218 printf("d (stdcall): %d\n", (r == val)); 218 printf("d (stdcall): %d\n", (r == val));
219 ret = (r == val) && ret; 219 ret = (r == val) && ret;
220 } 220 }
221 /* ptr */ 221 /* ptr */
222 { 222 {
223 DCpointer r; 223 DCpointer r;
224 dcReset(pc); 224 dcReset(pc);
225 dcArgPointer(pc, (DCpointer) &fun_c_b); 225 dcArgPointer(pc, (DCpointer) &fun_c_b);
226 r = dcCallPointer(pc, (DCpointer) &fun_std_p); 226 r = dcCallPointer(pc, (DCpointer) &fun_std_p);
227 printf("p (stdcall): %d\n", (r == &fun_c_b)); 227 printf("p (stdcall): %d\n", (r == &fun_c_b));
228 ret = (r == &fun_c_b) && ret; 228 ret = (r == &fun_c_b) && ret;
229 } 229 }
230 dcFree(pc); 230 dcFree(pc);
231 231
232 return ret; 232 return ret;
233 } 233 }
238 #if defined(DC__OS_Win32) 238 #if defined(DC__OS_Win32)
239 /* win32 __fastcall */ 239 /* win32 __fastcall */
240 240
241 DEF_FUNCS(__fastcall,fast) 241 DEF_FUNCS(__fastcall,fast)
242 242
243 int testCallFast() 243 static int testCallFast()
244 { 244 {
245 int ret = 1; 245 int ret = 1;
246 246
247 DCCallVM* pc = dcNewCallVM(4096); 247 DCCallVM* pc = dcNewCallVM(4096);
248 #ifdef DC__C_GNU 248 #ifdef DC__C_GNU
262 DCbool r, val=DC_TRUE; 262 DCbool r, val=DC_TRUE;
263 dcReset(pc); 263 dcReset(pc);
264 dcArgBool(pc, val); 264 dcArgBool(pc, val);
265 r = dcCallBool(pc, (DCpointer) &fun_fast_b); 265 r = dcCallBool(pc, (DCpointer) &fun_fast_b);
266 printf("bt ("FT"fastcall): %d\n", (r == val)); 266 printf("bt ("FT"fastcall): %d\n", (r == val));
267 ret = (r == val) && ret; 267 ret = (r == val) && ret;
268 268
269 val=DC_FALSE; 269 val=DC_FALSE;
270 dcReset(pc); 270 dcReset(pc);
271 dcArgBool(pc, val); 271 dcArgBool(pc, val);
272 r = dcCallBool(pc, (DCpointer) &fun_fast_b); 272 r = dcCallBool(pc, (DCpointer) &fun_fast_b);
273 printf("bf ("FT"fastcall): %d\n", (r == val)); 273 printf("bf ("FT"fastcall): %d\n", (r == val));
274 ret = (r == val) && ret; 274 ret = (r == val) && ret;
275 } 275 }
276 /* int */ 276 /* int */
277 { 277 {
278 DCint r, val=1234; 278 DCint r, val=1234;
279 dcReset(pc); 279 dcReset(pc);
280 dcArgInt(pc, val); 280 dcArgInt(pc, val);
281 r = dcCallInt(pc, (DCpointer) &fun_fast_i); 281 r = dcCallInt(pc, (DCpointer) &fun_fast_i);
282 printf("i ("FT"fastcall): %d\n", (r == val)); 282 printf("i ("FT"fastcall): %d\n", (r == val));
283 ret = (r == val) && ret; 283 ret = (r == val) && ret;
284 } 284 }
285 /* long */ 285 /* long */
286 { 286 {
287 DClong r, val=0xCAFEBABEUL; 287 DClong r, val=0xCAFEBABEUL;
288 dcReset(pc); 288 dcReset(pc);
289 dcArgLong(pc, val); 289 dcArgLong(pc, val);
290 r = dcCallLong(pc, (DCpointer) &fun_fast_j); 290 r = dcCallLong(pc, (DCpointer) &fun_fast_j);
291 printf("l ("FT"fastcall): %d\n", (r == val)); 291 printf("l ("FT"fastcall): %d\n", (r == val));
292 ret = (r == val) && ret; 292 ret = (r == val) && ret;
293 } 293 }
294 /* long long */ 294 /* long long */
295 { 295 {
296 DClonglong r, val=0xCAFEBABEDEADC0DEULL; 296 DClonglong r, val=0xCAFEBABEDEADC0DEULL;
297 dcReset(pc); 297 dcReset(pc);
298 dcArgLongLong(pc, val); 298 dcArgLongLong(pc, val);
299 r = dcCallLongLong(pc, (DCpointer) &fun_fast_l); 299 r = dcCallLongLong(pc, (DCpointer) &fun_fast_l);
300 printf("ll ("FT"fastcall): %d\n", (r == val)); 300 printf("ll ("FT"fastcall): %d\n", (r == val));
301 ret = (r == val) && ret; 301 ret = (r == val) && ret;
302 } 302 }
303 /* float */ 303 /* float */
304 { 304 {
305 DCfloat r, val=1.234567f; 305 DCfloat r, val=1.234567f;
306 dcReset(pc); 306 dcReset(pc);
307 dcArgFloat(pc, val); 307 dcArgFloat(pc, val);
308 r = dcCallFloat(pc, (DCpointer) &fun_fast_f); 308 r = dcCallFloat(pc, (DCpointer) &fun_fast_f);
309 printf("f ("FT"fastcall): %d\n", (r == val)); 309 printf("f ("FT"fastcall): %d\n", (r == val));
310 ret = (r == val) && ret; 310 ret = (r == val) && ret;
311 } 311 }
312 /* double */ 312 /* double */
313 { 313 {
314 DCdouble r, val=1.23456789; 314 DCdouble r, val=1.23456789;
315 dcReset(pc); 315 dcReset(pc);
316 dcArgDouble(pc, val); 316 dcArgDouble(pc, val);
317 r = dcCallDouble(pc, (DCpointer) &fun_fast_d); 317 r = dcCallDouble(pc, (DCpointer) &fun_fast_d);
318 printf("d ("FT"fastcall): %d\n", (r == val)); 318 printf("d ("FT"fastcall): %d\n", (r == val));
319 ret = (r == val) && ret; 319 ret = (r == val) && ret;
320 } 320 }
321 /* ptr */ 321 /* ptr */
322 { 322 {
323 DCpointer r; 323 DCpointer r;
324 dcReset(pc); 324 dcReset(pc);
325 dcArgPointer(pc, (DCpointer) &fun_c_b); 325 dcArgPointer(pc, (DCpointer) &fun_c_b);
326 r = dcCallPointer(pc, (DCpointer) &fun_fast_p); 326 r = dcCallPointer(pc, (DCpointer) &fun_fast_p);
327 printf("p ("FT"fastcall): %d\n", (r == &fun_c_b)); 327 printf("p ("FT"fastcall): %d\n", (r == &fun_c_b));
328 ret = (r == &fun_c_b) && ret; 328 ret = (r == &fun_c_b) && ret;
329 } 329 }
330 dcFree(pc); 330 dcFree(pc);
331 331
332 return ret; 332 return ret;
333 } 333 }
342 { 342 {
343 int r = 1; 343 int r = 1;
344 dcTest_initPlatform(); 344 dcTest_initPlatform();
345 345
346 r = testCallC() && r; 346 r = testCallC() && r;
347 r = testStructSizes() && r; 347 r = testAggrReturns() && r;
348 /*r = testCallStructs() && r;*/ 348 r = testAggrParameters() && r;
349 r = testAggrReturns() && r;
350 r = testAggrParameters() && r;
349 #if defined(DC__OS_Win32) 351 #if defined(DC__OS_Win32)
350 r = testCallStd() && r; 352 r = testCallStd() && r;
351 r = testCallFast() && r; 353 r = testCallFast() && r;
352 #endif 354 #endif
353 355