Mercurial > pub > dyncall > dyncall

comparison test/plain/test_main.c @ 627:c477ddd64718 r1.4-RC5

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
- test/plain: * added some aggregate-by-val-as-vararg cases * made output be more in line w/ sig format
author Tassilo Philipp
date Fri, 28 Oct 2022 15:08:21 +0200
parents 71c884e610f0
children a388de1c822e
comparison
equal deleted inserted replaced
626:667fe7b2be62 627:c477ddd64718
69 { 69 {
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("b)b == t (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("b)b == f (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)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("j)j (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("l)l (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)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)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)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;
161 { 161 {
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("b)b == t (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("b)b == f (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)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("j)j (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("l)l (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)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)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)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;
261 { 261 {
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("b)b == t ("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("b)b == f ("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)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("j)j ("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("l)l ("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)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)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)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;