#include <string.h>
#include <ffi.h>
#include "alignof.h"
+#include <stdarg.h>
#include "testcases.c"
int count = 0;
char rbuf1[2048];
char rbuf2[2048];
-#define FPRINTF(STREAM,FMT,ARGS...) \
- { fprintf(STREAM, FMT, ##ARGS) ; \
- switch (count++) \
- { \
- case 0: \
- case 1: \
- sprintf(&rbuf1[strlen(rbuf1)], FMT, ##ARGS); \
- break ; \
- case 2: \
- sprintf(rbuf2, FMT, ##ARGS); \
- break; \
- case 3: \
- sprintf(&rbuf2[strlen(rbuf2)], FMT, ##ARGS); \
- if (strcmp (rbuf1, rbuf2)) abort(); \
- break; \
- } \
- }
-#else
-#define FPRINTF fprintf
+int fprintf(FILE *stream, const char *format, ...)
+{
+ va_list args;
+ va_start(args, format);
+
+ switch (count++)
+ {
+ case 0:
+ case 1:
+ vsprintf(&rbuf1[strlen(rbuf1)], format, args);
+ break;
+ case 2:
+ printf(rbuf1);
+ vsprintf(rbuf2, format, args);
+ break;
+ case 3:
+ vsprintf(&rbuf2[strlen(rbuf2)], format, args);
+ printf(rbuf2);
+ if (strcmp (rbuf1, rbuf2)) abort();
+ break;
+ }
+
+ va_end(args);
+
+ return 0;
+}
#endif
/* --------------------------------------------------------------- */
+#ifndef ABI_NUM
+#define ABI_NUM FFI_DEFAULT_ABI
+#endif
+
/* Definitions that ought to be part of libffi. */
static ffi_type ffi_type_char;
#define ffi_type_slonglong ffi_type_sint64
#define SKIP_EXTRA_STRUCTS
#define FFI_PREP_CIF(cif,argtypes,rettype) \
- if (ffi_prep_cif(&(cif),FFI_DEFAULT_ABI,sizeof(argtypes)/sizeof(argtypes[0]),&rettype,argtypes) != FFI_OK) abort()
+ if (ffi_prep_cif(&(cif),ABI_NUM,sizeof(argtypes)/sizeof(argtypes[0]),&rettype,argtypes) != FFI_OK) abort()
#define FFI_PREP_CIF_NOARGS(cif,rettype) \
- if (ffi_prep_cif(&(cif),FFI_DEFAULT_ABI,0,&rettype,NULL) != FFI_OK) abort()
+ if (ffi_prep_cif(&(cif),ABI_NUM,0,&rettype,NULL) != FFI_OK) abort()
#define FFI_CALL(cif,fn,args,retaddr) \
ffi_call(&(cif),(void(*)(void))(fn),retaddr,args)
int ir;
#if (!defined(DGTEST)) || DGTEST == 2
ir = i_v();
- FPRINTF(out,"->%d\n",ir);
+ fprintf(out,"->%d\n",ir);
fflush(out);
ir = 0; clear_traces();
{
FFI_CALL(cif,i_v,NULL,&ir);
}
}
- FPRINTF(out,"->%d\n",ir);
+ fprintf(out,"->%d\n",ir);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 3
ir = i_i(i1);
- FPRINTF(out,"->%d\n",ir);
+ fprintf(out,"->%d\n",ir);
fflush(out);
ir = 0; clear_traces();
{
FFI_CALL(cif,i_i,args,&ir);
}
}
- FPRINTF(out,"->%d\n",ir);
+ fprintf(out,"->%d\n",ir);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 4
ir = i_i2(i1,i2);
- FPRINTF(out,"->%d\n",ir);
+ fprintf(out,"->%d\n",ir);
fflush(out);
ir = 0; clear_traces();
{
FFI_CALL(cif,i_i2,args,&ir);
}
}
- FPRINTF(out,"->%d\n",ir);
+ fprintf(out,"->%d\n",ir);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 5
ir = i_i4(i1,i2,i3,i4);
- FPRINTF(out,"->%d\n",ir);
+ fprintf(out,"->%d\n",ir);
fflush(out);
ir = 0; clear_traces();
{
FFI_CALL(cif,i_i4,args,&ir);
}
}
- FPRINTF(out,"->%d\n",ir);
+ fprintf(out,"->%d\n",ir);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 6
ir = i_i8(i1,i2,i3,i4,i5,i6,i7,i8);
- FPRINTF(out,"->%d\n",ir);
+ fprintf(out,"->%d\n",ir);
fflush(out);
ir = 0; clear_traces();
{
FFI_CALL(cif,i_i8,args,&ir);
}
}
- FPRINTF(out,"->%d\n",ir);
+ fprintf(out,"->%d\n",ir);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 7
ir = i_i16(i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11,i12,i13,i14,i15,i16);
- FPRINTF(out,"->%d\n",ir);
+ fprintf(out,"->%d\n",ir);
fflush(out);
ir = 0; clear_traces();
{
FFI_CALL(cif,i_i16,args,&ir);
}
}
- FPRINTF(out,"->%d\n",ir);
+ fprintf(out,"->%d\n",ir);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 8
fr = f_f(f1);
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
fr = 0.0; clear_traces();
{
FFI_CALL(cif,f_f,args,&fr);
}
}
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 9
fr = f_f2(f1,f2);
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
fr = 0.0; clear_traces();
{
FFI_CALL(cif,f_f2,args,&fr);
}
}
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 10
fr = f_f4(f1,f2,f3,f4);
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
fr = 0.0; clear_traces();
{
FFI_CALL(cif,f_f4,args,&fr);
}
}
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 11
fr = f_f8(f1,f2,f3,f4,f5,f6,f7,f8);
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
fr = 0.0; clear_traces();
{
FFI_CALL(cif,f_f8,args,&fr);
}
}
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 12
fr = f_f16(f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16);
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
fr = 0.0; clear_traces();
{
FFI_CALL(cif,f_f16,args,&fr);
}
}
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 13
fr = f_f24(f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16,f17,f18,f19,f20,f21,f22,f23,f24);
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
fr = 0.0; clear_traces();
{
FFI_CALL(cif,f_f24,args,&fr);
}
}
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
#endif
}
#if (!defined(DGTEST)) || DGTEST == 14
dr = d_d(d1);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
{
FFI_CALL(cif,d_d,args,&dr);
}
}
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 15
dr = d_d2(d1,d2);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
{
FFI_CALL(cif,d_d2,args,&dr);
}
}
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 16
dr = d_d4(d1,d2,d3,d4);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
{
FFI_CALL(cif,d_d4,args,&dr);
}
}
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 17
dr = d_d8(d1,d2,d3,d4,d5,d6,d7,d8);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
{
FFI_CALL(cif,d_d8,args,&dr);
}
}
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 18
dr = d_d16(d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13,d14,d15,d16);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
{
FFI_CALL(cif,d_d16,args,&dr);
}
}
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
return;
#if (!defined(DGTEST)) || DGTEST == 19
vpr = vp_vpdpcpsp(&uc1,&d2,str3,&I4);
- FPRINTF(out,"->0x%p\n",vpr);
+ fprintf(out,"->0x%p\n",vpr);
fflush(out);
vpr = 0; clear_traces();
{
FFI_CALL(cif,vp_vpdpcpsp,args,&vpr);
}
}
- FPRINTF(out,"->0x%p\n",vpr);
+ fprintf(out,"->0x%p\n",vpr);
fflush(out);
#endif
return;
*/
#if (!defined(DGTEST)) || DGTEST == 20
ucr = uc_ucsil(uc1, us2, ui3, ul4);
- FPRINTF(out,"->%u\n",ucr);
+ fprintf(out,"->%u\n",ucr);
fflush(out);
ucr = 0; clear_traces();
{
ucr = (uchar) r;
}
}
- FPRINTF(out,"->%u\n",ucr);
+ fprintf(out,"->%u\n",ucr);
fflush(out);
#endif
/* Mixed int & float types.
*/
dr = d_iidd(i1,i2,d3,d4);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
{
FFI_CALL(cif,d_iidd,args,&dr);
}
}
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 22
dr = d_iiidi(i1,i2,i3,d4,i5);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
{
FFI_CALL(cif,d_iiidi,args,&dr);
}
}
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 23
dr = d_idid(i1,d2,i3,d4);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
{
FFI_CALL(cif,d_idid,args,&dr);
}
}
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 24
dr = d_fdi(f1,d2,i3);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
{
FFI_CALL(cif,d_fdi,args,&dr);
}
}
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 25
usr = us_cdcd(c1,d2,c3,d4);
- FPRINTF(out,"->%u\n",usr);
+ fprintf(out,"->%u\n",usr);
fflush(out);
usr = 0; clear_traces();
{
usr = (ushort) rint;
}
}
- FPRINTF(out,"->%u\n",usr);
+ fprintf(out,"->%u\n",usr);
fflush(out);
#endif
/* Long long types.
*/
llr = ll_iiilli(i1,i2,i3,ll1,i13);
- FPRINTF(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
fflush(out);
llr = 0; clear_traces();
{
FFI_CALL(cif,ll_iiilli,args,&llr);
}
}
- FPRINTF(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 27
llr = ll_flli(f13,ll1,i13);
- FPRINTF(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
fflush(out);
llr = 0; clear_traces();
{
FFI_CALL(cif,ll_flli,args,&llr);
}
}
- FPRINTF(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 28
fr = f_fi(f1,i9);
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
fr = 0.0; clear_traces();
{
FFI_CALL(cif,f_fi,args,&fr);
}
}
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 29
fr = f_f2i(f1,f2,i9);
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
fr = 0.0; clear_traces();
{
FFI_CALL(cif,f_f2i,args,&fr);
}
}
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 30
fr = f_f3i(f1,f2,f3,i9);
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
fr = 0.0; clear_traces();
{
FFI_CALL(cif,f_f3i,args,&fr);
}
}
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 31
fr = f_f4i(f1,f2,f3,f4,i9);
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
fr = 0.0; clear_traces();
{
FFI_CALL(cif,f_f4i,args,&fr);
}
}
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 32
fr = f_f7i(f1,f2,f3,f4,f5,f6,f7,i9);
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
fr = 0.0; clear_traces();
{
FFI_CALL(cif,f_f7i,args,&fr);
}
}
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 33
fr = f_f8i(f1,f2,f3,f4,f5,f6,f7,f8,i9);
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
fr = 0.0; clear_traces();
{
FFI_CALL(cif,f_f8i,args,&fr);
}
}
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 34
fr = f_f12i(f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,i9);
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
fr = 0.0; clear_traces();
{
FFI_CALL(cif,f_f12i,args,&fr);
}
}
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 35
fr = f_f13i(f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,i9);
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
fr = 0.0; clear_traces();
{
FFI_CALL(cif,f_f13i,args,&fr);
}
}
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 36
dr = d_di(d1,i9);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
{
FFI_CALL(cif,d_di,args,&dr);
}
}
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 37
dr = d_d2i(d1,d2,i9);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
{
FFI_CALL(cif,d_d2i,args,&dr);
}
}
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 38
dr = d_d3i(d1,d2,d3,i9);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
{
FFI_CALL(cif,d_d3i,args,&dr);
}
}
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 39
dr = d_d4i(d1,d2,d3,d4,i9);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
{
FFI_CALL(cif,d_d4i,args,&dr);
}
}
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 40
dr = d_d7i(d1,d2,d3,d4,d5,d6,d7,i9);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
{
FFI_CALL(cif,d_d7i,args,&dr);
}
}
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 41
dr = d_d8i(d1,d2,d3,d4,d5,d6,d7,d8,i9);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
{
FFI_CALL(cif,d_d8i,args,&dr);
}
}
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 42
dr = d_d12i(d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,i9);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
{
FFI_CALL(cif,d_d12i,args,&dr);
}
}
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 43
dr = d_d13i(d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13,i9);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
{
FFI_CALL(cif,d_d13i,args,&dr);
}
}
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
return;
#if (!defined(DGTEST)) || DGTEST == 44
{
Size1 r = S1_v();
- FPRINTF(out,"->{%c}\n",r.x1);
+ fprintf(out,"->{%c}\n",r.x1);
fflush(out);
memset(&r,0,sizeof(r)); clear_traces();
{
FFI_CALL(cif,S1_v,NULL,&r);
}
}
- FPRINTF(out,"->{%c}\n",r.x1);
+ fprintf(out,"->{%c}\n",r.x1);
fflush(out);
}
#endif
#if (!defined(DGTEST)) || DGTEST == 45
{
Size2 r = S2_v();
- FPRINTF(out,"->{%c%c}\n",r.x1,r.x2);
+ fprintf(out,"->{%c%c}\n",r.x1,r.x2);
fflush(out);
memset(&r,0,sizeof(r)); clear_traces();
{
FFI_CALL(cif,S2_v,NULL,&r);
}
}
- FPRINTF(out,"->{%c%c}\n",r.x1,r.x2);
+ fprintf(out,"->{%c%c}\n",r.x1,r.x2);
fflush(out);
}
#endif
#if (!defined(DGTEST)) || DGTEST == 46
{
Size3 r = S3_v();
- FPRINTF(out,"->{%c%c%c}\n",r.x1,r.x2,r.x3);
+ fprintf(out,"->{%c%c%c}\n",r.x1,r.x2,r.x3);
fflush(out);
memset(&r,0,sizeof(r)); clear_traces();
{
FFI_CALL(cif,S3_v,NULL,&r);
}
}
- FPRINTF(out,"->{%c%c%c}\n",r.x1,r.x2,r.x3);
+ fprintf(out,"->{%c%c%c}\n",r.x1,r.x2,r.x3);
fflush(out);
}
#endif
#if (!defined(DGTEST)) || DGTEST == 47
{
Size4 r = S4_v();
- FPRINTF(out,"->{%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4);
+ fprintf(out,"->{%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4);
fflush(out);
memset(&r,0,sizeof(r)); clear_traces();
{
FFI_CALL(cif,S4_v,NULL,&r);
}
}
- FPRINTF(out,"->{%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4);
+ fprintf(out,"->{%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4);
fflush(out);
}
#endif
#if (!defined(DGTEST)) || DGTEST == 48
{
Size7 r = S7_v();
- FPRINTF(out,"->{%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7);
+ fprintf(out,"->{%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7);
fflush(out);
memset(&r,0,sizeof(r)); clear_traces();
{
FFI_CALL(cif,S7_v,NULL,&r);
}
}
- FPRINTF(out,"->{%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7);
+ fprintf(out,"->{%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7);
fflush(out);
}
#endif
#if (!defined(DGTEST)) || DGTEST == 49
{
Size8 r = S8_v();
- FPRINTF(out,"->{%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8);
+ fprintf(out,"->{%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8);
fflush(out);
memset(&r,0,sizeof(r)); clear_traces();
{
FFI_CALL(cif,S8_v,NULL,&r);
}
}
- FPRINTF(out,"->{%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8);
+ fprintf(out,"->{%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8);
fflush(out);
}
#endif
#if (!defined(DGTEST)) || DGTEST == 50
{
Size12 r = S12_v();
- FPRINTF(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12);
+ fprintf(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12);
fflush(out);
memset(&r,0,sizeof(r)); clear_traces();
{
FFI_CALL(cif,S12_v,NULL,&r);
}
}
- FPRINTF(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12);
+ fprintf(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12);
fflush(out);
}
#endif
#if (!defined(DGTEST)) || DGTEST == 51
{
Size15 r = S15_v();
- FPRINTF(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12,r.x13,r.x14,r.x15);
+ fprintf(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12,r.x13,r.x14,r.x15);
fflush(out);
memset(&r,0,sizeof(r)); clear_traces();
{
FFI_CALL(cif,S15_v,NULL,&r);
}
}
- FPRINTF(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12,r.x13,r.x14,r.x15);
+ fprintf(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12,r.x13,r.x14,r.x15);
fflush(out);
}
#endif
#if (!defined(DGTEST)) || DGTEST == 52
{
Size16 r = S16_v();
- FPRINTF(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12,r.x13,r.x14,r.x15,r.x16);
+ fprintf(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12,r.x13,r.x14,r.x15,r.x16);
fflush(out);
memset(&r,0,sizeof(r)); clear_traces();
{
FFI_CALL(cif,S16_v,NULL,&r);
}
}
- FPRINTF(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12,r.x13,r.x14,r.x15,r.x16);
+ fprintf(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12,r.x13,r.x14,r.x15,r.x16);
fflush(out);
}
#endif
#if (!defined(DGTEST)) || DGTEST == 53
Ir = I_III(I1,I2,I3);
- FPRINTF(out,"->{%d}\n",Ir.x);
+ fprintf(out,"->{%d}\n",Ir.x);
fflush(out);
Ir.x = 0; clear_traces();
{
FFI_CALL(cif,I_III,args,&Ir);
}
}
- FPRINTF(out,"->{%d}\n",Ir.x);
+ fprintf(out,"->{%d}\n",Ir.x);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 54
Cr = C_CdC(C1,d2,C3);
- FPRINTF(out,"->{'%c'}\n",Cr.x);
+ fprintf(out,"->{'%c'}\n",Cr.x);
fflush(out);
Cr.x = '\0'; clear_traces();
{
FFI_CALL(cif,C_CdC,args,&Cr);
}
}
- FPRINTF(out,"->{'%c'}\n",Cr.x);
+ fprintf(out,"->{'%c'}\n",Cr.x);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 55
Fr = F_Ffd(F1,f2,d3);
- FPRINTF(out,"->{%g}\n",Fr.x);
+ fprintf(out,"->{%g}\n",Fr.x);
fflush(out);
Fr.x = 0.0; clear_traces();
{
FFI_CALL(cif,F_Ffd,args,&Fr);
}
}
- FPRINTF(out,"->{%g}\n",Fr.x);
+ fprintf(out,"->{%g}\n",Fr.x);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 56
Dr = D_fDd(f1,D2,d3);
- FPRINTF(out,"->{%g}\n",Dr.x);
+ fprintf(out,"->{%g}\n",Dr.x);
fflush(out);
Dr.x = 0.0; clear_traces();
{
FFI_CALL(cif,D_fDd,args,&Dr);
}
}
- FPRINTF(out,"->{%g}\n",Dr.x);
+ fprintf(out,"->{%g}\n",Dr.x);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 57
Dr = D_Dfd(D1,f2,d3);
- FPRINTF(out,"->{%g}\n",Dr.x);
+ fprintf(out,"->{%g}\n",Dr.x);
fflush(out);
Dr.x = 0.0; clear_traces();
{
FFI_CALL(cif,D_Dfd,args,&Dr);
}
}
- FPRINTF(out,"->{%g}\n",Dr.x);
+ fprintf(out,"->{%g}\n",Dr.x);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 58
Jr = J_JiJ(J1,i2,J2);
- FPRINTF(out,"->{%ld,%ld}\n",Jr.l1,Jr.l2);
+ fprintf(out,"->{%ld,%ld}\n",Jr.l1,Jr.l2);
fflush(out);
Jr.l1 = Jr.l2 = 0; clear_traces();
{
FFI_CALL(cif,J_JiJ,args,&Jr);
}
}
- FPRINTF(out,"->{%ld,%ld}\n",Jr.l1,Jr.l2);
+ fprintf(out,"->{%ld,%ld}\n",Jr.l1,Jr.l2);
fflush(out);
#endif
#ifndef SKIP_EXTRA_STRUCTS
#if (!defined(DGTEST)) || DGTEST == 59
Tr = T_TcT(T1,' ',T2);
- FPRINTF(out,"->{\"%c%c%c\"}\n",Tr.c[0],Tr.c[1],Tr.c[2]);
+ fprintf(out,"->{\"%c%c%c\"}\n",Tr.c[0],Tr.c[1],Tr.c[2]);
fflush(out);
Tr.c[0] = Tr.c[1] = Tr.c[2] = 0; clear_traces();
{
FFI_CALL(cif,T_TcT,args,&Tr);
}
}
- FPRINTF(out,"->{\"%c%c%c\"}\n",Tr.c[0],Tr.c[1],Tr.c[2]);
+ fprintf(out,"->{\"%c%c%c\"}\n",Tr.c[0],Tr.c[1],Tr.c[2]);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 60
Xr = X_BcdB(B1,c2,d3,B2);
- FPRINTF(out,"->{\"%s\",'%c'}\n",Xr.c,Xr.c1);
+ fprintf(out,"->{\"%s\",'%c'}\n",Xr.c,Xr.c1);
fflush(out);
Xr.c[0]=Xr.c1='\0'; clear_traces();
{
FFI_CALL(cif,X_BcdB,args,&Xr);
}
}
- FPRINTF(out,"->{\"%s\",'%c'}\n",Xr.c,Xr.c1);
+ fprintf(out,"->{\"%s\",'%c'}\n",Xr.c,Xr.c1);
fflush(out);
#endif
#endif
#if (!defined(DGTEST)) || DGTEST == 61
lr = l_l0K(K1,l9);
- FPRINTF(out,"->%ld\n",lr);
+ fprintf(out,"->%ld\n",lr);
fflush(out);
lr = 0; clear_traces();
{
FFI_CALL(cif,l_l0K,args,&lr);
}
}
- FPRINTF(out,"->%ld\n",lr);
+ fprintf(out,"->%ld\n",lr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 62
lr = l_l1K(l1,K1,l9);
- FPRINTF(out,"->%ld\n",lr);
+ fprintf(out,"->%ld\n",lr);
fflush(out);
lr = 0; clear_traces();
{
FFI_CALL(cif,l_l1K,args,&lr);
}
}
- FPRINTF(out,"->%ld\n",lr);
+ fprintf(out,"->%ld\n",lr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 63
lr = l_l2K(l1,l2,K1,l9);
- FPRINTF(out,"->%ld\n",lr);
+ fprintf(out,"->%ld\n",lr);
fflush(out);
lr = 0; clear_traces();
{
FFI_CALL(cif,l_l2K,args,&lr);
}
}
- FPRINTF(out,"->%ld\n",lr);
+ fprintf(out,"->%ld\n",lr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 64
lr = l_l3K(l1,l2,l3,K1,l9);
- FPRINTF(out,"->%ld\n",lr);
+ fprintf(out,"->%ld\n",lr);
fflush(out);
lr = 0; clear_traces();
{
FFI_CALL(cif,l_l3K,args,&lr);
}
}
- FPRINTF(out,"->%ld\n",lr);
+ fprintf(out,"->%ld\n",lr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 65
lr = l_l4K(l1,l2,l3,l4,K1,l9);
- FPRINTF(out,"->%ld\n",lr);
+ fprintf(out,"->%ld\n",lr);
fflush(out);
lr = 0; clear_traces();
{
FFI_CALL(cif,l_l4K,args,&lr);
}
}
- FPRINTF(out,"->%ld\n",lr);
+ fprintf(out,"->%ld\n",lr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 66
lr = l_l5K(l1,l2,l3,l4,l5,K1,l9);
- FPRINTF(out,"->%ld\n",lr);
+ fprintf(out,"->%ld\n",lr);
fflush(out);
lr = 0; clear_traces();
{
FFI_CALL(cif,l_l5K,args,&lr);
}
}
- FPRINTF(out,"->%ld\n",lr);
+ fprintf(out,"->%ld\n",lr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 67
lr = l_l6K(l1,l2,l3,l4,l5,l6,K1,l9);
- FPRINTF(out,"->%ld\n",lr);
+ fprintf(out,"->%ld\n",lr);
fflush(out);
lr = 0; clear_traces();
{
FFI_CALL(cif,l_l6K,args,&lr);
}
}
- FPRINTF(out,"->%ld\n",lr);
+ fprintf(out,"->%ld\n",lr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 68
fr = f_f17l3L(f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16,f17,l6,l7,l8,L1);
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
fr = 0.0; clear_traces();
{
FFI_CALL(cif,f_f17l3L,args,&fr);
}
}
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 69
dr = d_d17l3L(d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13,d14,d15,d16,d17,l6,l7,l8,L1);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
{
FFI_CALL(cif,d_d17l3L,args,&dr);
}
}
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 70
llr = ll_l2ll(l1,l2,ll1,l9);
- FPRINTF(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
fflush(out);
llr = 0; clear_traces();
{
FFI_CALL(cif,ll_l2ll,args,&llr);
}
}
- FPRINTF(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 71
llr = ll_l3ll(l1,l2,l3,ll1,l9);
- FPRINTF(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
fflush(out);
llr = 0; clear_traces();
{
FFI_CALL(cif,ll_l3ll,args,&llr);
}
}
- FPRINTF(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 72
llr = ll_l4ll(l1,l2,l3,l4,ll1,l9);
- FPRINTF(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
fflush(out);
llr = 0; clear_traces();
{
FFI_CALL(cif,ll_l4ll,args,&llr);
}
}
- FPRINTF(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 73
llr = ll_l5ll(l1,l2,l3,l4,l5,ll1,l9);
- FPRINTF(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
fflush(out);
llr = 0; clear_traces();
{
FFI_CALL(cif,ll_l5ll,args,&llr);
}
}
- FPRINTF(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 74
llr = ll_l6ll(l1,l2,l3,l4,l5,l6,ll1,l9);
- FPRINTF(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
fflush(out);
llr = 0; clear_traces();
{
FFI_CALL(cif,ll_l6ll,args,&llr);
}
}
- FPRINTF(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 75
llr = ll_l7ll(l1,l2,l3,l4,l5,l6,l7,ll1,l9);
- FPRINTF(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
fflush(out);
llr = 0; clear_traces();
{
FFI_CALL(cif,ll_l7ll,args,&llr);
}
}
- FPRINTF(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 76
dr = d_l2d(l1,l2,d2,l9);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
{
FFI_CALL(cif,d_l2d,args,&dr);
}
}
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 77
dr = d_l3d(l1,l2,l3,d2,l9);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
{
FFI_CALL(cif,d_l3d,args,&dr);
}
}
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 78
dr = d_l4d(l1,l2,l3,l4,d2,l9);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
{
FFI_CALL(cif,d_l4d,args,&dr);
}
}
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 79
dr = d_l5d(l1,l2,l3,l4,l5,d2,l9);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
{
FFI_CALL(cif,d_l5d,args,&dr);
}
}
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 80
dr = d_l6d(l1,l2,l3,l4,l5,l6,d2,l9);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
{
FFI_CALL(cif,d_l6d,args,&dr);
}
}
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 81
dr = d_l7d(l1,l2,l3,l4,l5,l6,l7,d2,l9);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
{
FFI_CALL(cif,d_l7d,args,&dr);
}
}
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
return;
#include <string.h>
#include <ffi.h>
#include "alignof.h"
+#include <stdarg.h>
#include "testcases.c"
int count = 0;
char rbuf1[2048];
char rbuf2[2048];
-#define FPRINTF(STREAM,FMT,ARGS...) \
- { fprintf(STREAM, FMT, ##ARGS) ; \
- switch (count++) \
- { \
- case 0: \
- case 1: \
- sprintf(&rbuf1[strlen(rbuf1)], FMT, ##ARGS); \
- break ; \
- case 2: \
- sprintf(rbuf2, FMT, ##ARGS); \
- break; \
- case 3: \
- sprintf(&rbuf2[strlen(rbuf2)], FMT, ##ARGS); \
- if (strcmp (rbuf1, rbuf2)) abort(); \
- break; \
- } \
- }
-#else
-#define FPRINTF fprintf
+int fprintf(FILE *stream, const char *format, ...)
+{
+ va_list args;
+ va_start(args, format);
+
+ switch (count++)
+ {
+ case 0:
+ case 1:
+ vsprintf(&rbuf1[strlen(rbuf1)], format, args);
+ break;
+ case 2:
+ printf(rbuf1);
+ vsprintf(rbuf2, format, args);
+ break;
+ case 3:
+ vsprintf(&rbuf2[strlen(rbuf2)], format, args);
+ printf(rbuf2);
+ if (strcmp (rbuf1, rbuf2)) abort();
+ break;
+ }
+
+ va_end(args);
+
+ return 0;
+}
#endif
/* --------------------------------------------------------------- */
+#ifndef ABI_NUM
+#define ABI_NUM FFI_DEFAULT_ABI
+#endif
+
/* Definitions that ought to be part of libffi. */
static ffi_type ffi_type_char;
#define ffi_type_slonglong ffi_type_sint64
#define SKIP_EXTRA_STRUCTS
#define FFI_PREP_CIF(cif,argtypes,rettype) \
- if (ffi_prep_cif(&(cif),FFI_DEFAULT_ABI,sizeof(argtypes)/sizeof(argtypes[0]),&rettype,argtypes) != FFI_OK) abort()
+ if (ffi_prep_cif(&(cif),ABI_NUM,sizeof(argtypes)/sizeof(argtypes[0]),&rettype,argtypes) != FFI_OK) abort()
#define FFI_PREP_CIF_NOARGS(cif,rettype) \
- if (ffi_prep_cif(&(cif),FFI_DEFAULT_ABI,0,&rettype,NULL) != FFI_OK) abort()
+ if (ffi_prep_cif(&(cif),ABI_NUM,0,&rettype,NULL) != FFI_OK) abort()
#if defined(__sparc__) && defined(__sun) && defined(__SUNPRO_C) /* SUNWspro cc */
/* SunPRO cc miscompiles the simulator function for X_BcdB: d.i[1] is
void v_v_simulator (ffi_cif* cif, void* retp, /*const*/ void* /*const*/ *args, void* data)
{
if (data != (void*)&v_v) { fprintf(out,"wrong data for v_v\n"); exit(1); }
- FPRINTF(out,"void f(void):\n");
+ fprintf(out,"void f(void):\n");
fflush(out);
}
{
if (data != (void*)&i_v) { fprintf(out,"wrong data for i_v\n"); exit(1); }
{int r=99;
- FPRINTF(out,"int f(void):");
+ fprintf(out,"int f(void):");
fflush(out);
*(ffi_arg*)retp = r;
}}
if (data != (void*)&i_i) { fprintf(out,"wrong data for i_i\n"); exit(1); }
int a = *(int*)(*args++);
int r=a+1;
- FPRINTF(out,"int f(int):(%d)",a);
+ fprintf(out,"int f(int):(%d)",a);
fflush(out);
*(ffi_arg*)retp = r;
}
{int a = *(int*)(*args++);
int b = *(int*)(*args++);
int r=a+b;
- FPRINTF(out,"int f(2*int):(%d,%d)",a,b);
+ fprintf(out,"int f(2*int):(%d,%d)",a,b);
fflush(out);
*(ffi_arg*)retp = r;
}}
int c = *(int*)(*args++);
int d = *(int*)(*args++);
int r=a+b+c+d;
- FPRINTF(out,"int f(4*int):(%d,%d,%d,%d)",a,b,c,d);
+ fprintf(out,"int f(4*int):(%d,%d,%d,%d)",a,b,c,d);
fflush(out);
*(ffi_arg*)retp = r;
}}
int g = *(int*)(*args++);
int h = *(int*)(*args++);
int r=a+b+c+d+e+f+g+h;
- FPRINTF(out,"int f(8*int):(%d,%d,%d,%d,%d,%d,%d,%d)",a,b,c,d,e,f,g,h);
+ fprintf(out,"int f(8*int):(%d,%d,%d,%d,%d,%d,%d,%d)",a,b,c,d,e,f,g,h);
fflush(out);
*(ffi_arg*)retp = r;
}}
int o = *(int*)(*args++);
int p = *(int*)(*args++);
int r=a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p;
- FPRINTF(out,"int f(16*int):(%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d)",
+ fprintf(out,"int f(16*int):(%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d)",
a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p);
fflush(out);
*(ffi_arg*)retp = r;
if (data != (void*)&f_f) { fprintf(out,"wrong data for f_f\n"); exit(1); }
{float a = *(float*)(*args++);
float r=a+1.0;
- FPRINTF(out,"float f(float):(%g)",a);
+ fprintf(out,"float f(float):(%g)",a);
fflush(out);
*(float*)retp = r;
}}
{float a = *(float*)(*args++);
float b = *(float*)(*args++);
float r=a+b;
- FPRINTF(out,"float f(2*float):(%g,%g)",a,b);
+ fprintf(out,"float f(2*float):(%g,%g)",a,b);
fflush(out);
*(float*)retp = r;
}}
float c = *(float*)(*args++);
float d = *(float*)(*args++);
float r=a+b+c+d;
- FPRINTF(out,"float f(4*float):(%g,%g,%g,%g)",a,b,c,d);
+ fprintf(out,"float f(4*float):(%g,%g,%g,%g)",a,b,c,d);
fflush(out);
*(float*)retp = r;
}}
float g = *(float*)(*args++);
float h = *(float*)(*args++);
float r=a+b+c+d+e+f+g+h;
- FPRINTF(out,"float f(8*float):(%g,%g,%g,%g,%g,%g,%g,%g)",a,b,c,d,e,f,g,h);
+ fprintf(out,"float f(8*float):(%g,%g,%g,%g,%g,%g,%g,%g)",a,b,c,d,e,f,g,h);
fflush(out);
*(float*)retp = r;
}}
float o = *(float*)(*args++);
float p = *(float*)(*args++);
float r=a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p;
- FPRINTF(out,"float f(16*float):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g)",a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p);
+ fprintf(out,"float f(16*float):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g)",a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p);
fflush(out);
*(float*)retp = r;
}}
float x = *(float*)(*args++);
float y = *(float*)(*args++);
float r=a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p+q+s+t+u+v+w+x+y;
- FPRINTF(out,"float f(24*float):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g)",a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,s,t,u,v,w,x,y);
+ fprintf(out,"float f(24*float):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g)",a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,s,t,u,v,w,x,y);
fflush(out);
*(float*)retp = r;
}}
if (data != (void*)&d_d) { fprintf(out,"wrong data for d_d\n"); exit(1); }
{double a = *(double*)(*args++);
double r=a+1.0;
- FPRINTF(out,"double f(double):(%g)",a);
+ fprintf(out,"double f(double):(%g)",a);
fflush(out);
*(double*)retp = r;
}}
{double a = *(double*)(*args++);
double b = *(double*)(*args++);
double r=a+b;
- FPRINTF(out,"double f(2*double):(%g,%g)",a,b);
+ fprintf(out,"double f(2*double):(%g,%g)",a,b);
fflush(out);
*(double*)retp = r;
}}
double c = *(double*)(*args++);
double d = *(double*)(*args++);
double r=a+b+c+d;
- FPRINTF(out,"double f(4*double):(%g,%g,%g,%g)",a,b,c,d);
+ fprintf(out,"double f(4*double):(%g,%g,%g,%g)",a,b,c,d);
fflush(out);
*(double*)retp = r;
}}
double g = *(double*)(*args++);
double h = *(double*)(*args++);
double r=a+b+c+d+e+f+g+h;
- FPRINTF(out,"double f(8*double):(%g,%g,%g,%g,%g,%g,%g,%g)",a,b,c,d,e,f,g,h);
+ fprintf(out,"double f(8*double):(%g,%g,%g,%g,%g,%g,%g,%g)",a,b,c,d,e,f,g,h);
fflush(out);
*(double*)retp = r;
}}
double o = *(double*)(*args++);
double p = *(double*)(*args++);
double r=a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p;
- FPRINTF(out,"double f(16*double):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g)",a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p);
+ fprintf(out,"double f(16*double):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g)",a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p);
fflush(out);
*(double*)retp = r;
}}
char* c = *(char* *)(*args++);
Int* d = *(Int* *)(*args++);
void* ret = (char*)b + 1;
- FPRINTF(out,"void* f(void*,double*,char*,Int*):(0x%p,0x%p,0x%p,0x%p)",a,b,c,d);
+ fprintf(out,"void* f(void*,double*,char*,Int*):(0x%p,0x%p,0x%p,0x%p)",a,b,c,d);
fflush(out);
*(void* *)retp = ret;
}}
uint c = *(unsigned int *)(*args++);
ulong d = *(unsigned long *)(*args++);
uchar r = (uchar)-1;
- FPRINTF(out,"uchar f(uchar,ushort,uint,ulong):(%u,%u,%u,%lu)",a,b,c,d);
+ fprintf(out,"uchar f(uchar,ushort,uint,ulong):(%u,%u,%u,%lu)",a,b,c,d);
fflush(out);
*(ffi_arg *)retp = r;
}}
double c = *(double*)(*args++);
double d = *(double*)(*args++);
double r=a+b+c+d;
- FPRINTF(out,"double f(int,int,double,double):(%d,%d,%g,%g)",a,b,c,d);
+ fprintf(out,"double f(int,int,double,double):(%d,%d,%g,%g)",a,b,c,d);
fflush(out);
*(double*)retp = r;
}}
double d = *(double*)(*args++);
int e = *(int*)(*args++);
double r=a+b+c+d+e;
- FPRINTF(out,"double f(int,int,int,double,int):(%d,%d,%d,%g,%d)",a,b,c,d,e);
+ fprintf(out,"double f(int,int,int,double,int):(%d,%d,%d,%g,%d)",a,b,c,d,e);
fflush(out);
*(double*)retp = r;
}}
int c = *(int*)(*args++);
double d = *(double*)(*args++);
double r=a+b+c+d;
- FPRINTF(out,"double f(int,double,int,double):(%d,%g,%d,%g)",a,b,c,d);
+ fprintf(out,"double f(int,double,int,double):(%d,%g,%d,%g)",a,b,c,d);
fflush(out);
*(double*)retp = r;
}}
double b = *(double*)(*args++);
int c = *(int*)(*args++);
double r=a+b+c;
- FPRINTF(out,"double f(float,double,int):(%g,%g,%d)",a,b,c);
+ fprintf(out,"double f(float,double,int):(%g,%g,%d)",a,b,c);
fflush(out);
*(double*)retp = r;
}}
char c = *(char*)(*args++);
double d = *(double*)(*args++);
ushort r = (ushort)(a + b + c + d);
- FPRINTF(out,"ushort f(char,double,char,double):('%c',%g,'%c',%g)",a,b,c,d);
+ fprintf(out,"ushort f(char,double,char,double):('%c',%g,'%c',%g)",a,b,c,d);
fflush(out);
*(ffi_arg *)retp = r;
}}
long long d = *(long long *)(*args++);
int e = *(int*)(*args++);
long long r = (long long)(int)a + (long long)(int)b + (long long)(int)c + d + (long long)e;
- FPRINTF(out,"long long f(int,int,int,long long,int):(%d,%d,%d,0x%lx%08lx,%d)",a,b,c,(long)(d>>32),(long)(d&0xffffffff),e);
+ fprintf(out,"long long f(int,int,int,long long,int):(%d,%d,%d,0x%lx%08lx,%d)",a,b,c,(long)(d>>32),(long)(d&0xffffffff),e);
fflush(out);
*(long long *)retp = r;
}}
long long b = *(long long *)(*args++);
int c = *(int*)(*args++);
long long r = (long long)(int)a + b + (long long)c;
- FPRINTF(out,"long long f(float,long long,int):(%g,0x%lx%08lx,0x%lx)",a,(long)(b>>32),(long)(b&0xffffffff),(long)c);
+ fprintf(out,"long long f(float,long long,int):(%g,0x%lx%08lx,0x%lx)",a,(long)(b>>32),(long)(b&0xffffffff),(long)c);
fflush(out);
*(long long *)retp = r;
}}
{float a = *(float*)(*args++);
int z = *(int*)(*args++);
float r=a+z;
- FPRINTF(out,"float f(float,int):(%g,%d)",a,z);
+ fprintf(out,"float f(float,int):(%g,%d)",a,z);
fflush(out);
*(float*)retp = r;
}}
float b = *(float*)(*args++);
int z = *(int*)(*args++);
float r=a+b+z;
- FPRINTF(out,"float f(2*float,int):(%g,%g,%d)",a,b,z);
+ fprintf(out,"float f(2*float,int):(%g,%g,%d)",a,b,z);
fflush(out);
*(float*)retp = r;
}}
float c = *(float*)(*args++);
int z = *(int*)(*args++);
float r=a+b+c+z;
- FPRINTF(out,"float f(3*float,int):(%g,%g,%g,%d)",a,b,c,z);
+ fprintf(out,"float f(3*float,int):(%g,%g,%g,%d)",a,b,c,z);
fflush(out);
*(float*)retp = r;
}}
float d = *(float*)(*args++);
int z = *(int*)(*args++);
float r=a+b+c+d+z;
- FPRINTF(out,"float f(4*float,int):(%g,%g,%g,%g,%d)",a,b,c,d,z);
+ fprintf(out,"float f(4*float,int):(%g,%g,%g,%g,%d)",a,b,c,d,z);
fflush(out);
*(float*)retp = r;
}}
float g = *(float*)(*args++);
int z = *(int*)(*args++);
float r=a+b+c+d+e+f+g+z;
- FPRINTF(out,"float f(7*float,int):(%g,%g,%g,%g,%g,%g,%g,%d)",a,b,c,d,e,f,g,z);
+ fprintf(out,"float f(7*float,int):(%g,%g,%g,%g,%g,%g,%g,%d)",a,b,c,d,e,f,g,z);
fflush(out);
*(float*)retp = r;
}}
float h = *(float*)(*args++);
int z = *(int*)(*args++);
float r=a+b+c+d+e+f+g+h+z;
- FPRINTF(out,"float f(8*float,int):(%g,%g,%g,%g,%g,%g,%g,%g,%d)",a,b,c,d,e,f,g,h,z);
+ fprintf(out,"float f(8*float,int):(%g,%g,%g,%g,%g,%g,%g,%g,%d)",a,b,c,d,e,f,g,h,z);
fflush(out);
*(float*)retp = r;
}}
float l = *(float*)(*args++);
int z = *(int*)(*args++);
float r=a+b+c+d+e+f+g+h+i+j+k+l+z;
- FPRINTF(out,"float f(12*float,int):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%d)",a,b,c,d,e,f,g,h,i,j,k,l,z);
+ fprintf(out,"float f(12*float,int):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%d)",a,b,c,d,e,f,g,h,i,j,k,l,z);
fflush(out);
*(float*)retp = r;
}}
float m = *(float*)(*args++);
int z = *(int*)(*args++);
float r=a+b+c+d+e+f+g+h+i+j+k+l+m+z;
- FPRINTF(out,"float f(13*float,int):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%d)",a,b,c,d,e,f,g,h,i,j,k,l,m,z);
+ fprintf(out,"float f(13*float,int):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%d)",a,b,c,d,e,f,g,h,i,j,k,l,m,z);
fflush(out);
*(float*)retp = r;
}}
{double a = *(double*)(*args++);
int z = *(int*)(*args++);
double r=a+z;
- FPRINTF(out,"double f(double,int):(%g,%d)",a,z);
+ fprintf(out,"double f(double,int):(%g,%d)",a,z);
fflush(out);
*(double*)retp = r;
}}
double b = *(double*)(*args++);
int z = *(int*)(*args++);
double r=a+b+z;
- FPRINTF(out,"double f(2*double,int):(%g,%g,%d)",a,b,z);
+ fprintf(out,"double f(2*double,int):(%g,%g,%d)",a,b,z);
fflush(out);
*(double*)retp = r;
}}
double c = *(double*)(*args++);
int z = *(int*)(*args++);
double r=a+b+c+z;
- FPRINTF(out,"double f(3*double,int):(%g,%g,%g,%d)",a,b,c,z);
+ fprintf(out,"double f(3*double,int):(%g,%g,%g,%d)",a,b,c,z);
fflush(out);
*(double*)retp = r;
}}
double d = *(double*)(*args++);
int z = *(int*)(*args++);
double r=a+b+c+d+z;
- FPRINTF(out,"double f(4*double,int):(%g,%g,%g,%g,%d)",a,b,c,d,z);
+ fprintf(out,"double f(4*double,int):(%g,%g,%g,%g,%d)",a,b,c,d,z);
fflush(out);
*(double*)retp = r;
}}
double g = *(double*)(*args++);
int z = *(int*)(*args++);
double r=a+b+c+d+e+f+g+z;
- FPRINTF(out,"double f(7*double,int):(%g,%g,%g,%g,%g,%g,%g,%d)",a,b,c,d,e,f,g,z);
+ fprintf(out,"double f(7*double,int):(%g,%g,%g,%g,%g,%g,%g,%d)",a,b,c,d,e,f,g,z);
fflush(out);
*(double*)retp = r;
}}
double h = *(double*)(*args++);
int z = *(int*)(*args++);
double r=a+b+c+d+e+f+g+h+z;
- FPRINTF(out,"double f(8*double,int):(%g,%g,%g,%g,%g,%g,%g,%g,%d)",a,b,c,d,e,f,g,h,z);
+ fprintf(out,"double f(8*double,int):(%g,%g,%g,%g,%g,%g,%g,%g,%d)",a,b,c,d,e,f,g,h,z);
fflush(out);
*(double*)retp = r;
}}
double l = *(double*)(*args++);
int z = *(int*)(*args++);
double r=a+b+c+d+e+f+g+h+i+j+k+l+z;
- FPRINTF(out,"double f(12*double,int):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%d)",a,b,c,d,e,f,g,h,i,j,k,l,z);
+ fprintf(out,"double f(12*double,int):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%d)",a,b,c,d,e,f,g,h,i,j,k,l,z);
fflush(out);
*(double*)retp = r;
}}
double m = *(double*)(*args++);
int z = *(int*)(*args++);
double r=a+b+c+d+e+f+g+h+i+j+k+l+m+z;
- FPRINTF(out,"double f(13*double,int):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%d)",a,b,c,d,e,f,g,h,i,j,k,l,m,z);
+ fprintf(out,"double f(13*double,int):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%d)",a,b,c,d,e,f,g,h,i,j,k,l,m,z);
fflush(out);
*(double*)retp = r;
}}
{
if (data != (void*)&S1_v) { fprintf(out,"wrong data for S1_v\n"); exit(1); }
{Size1 r = Size1_1;
- FPRINTF(out,"Size1 f(void):");
+ fprintf(out,"Size1 f(void):");
fflush(out);
*(Size1*)retp = r;
}}
{
if (data != (void*)&S2_v) { fprintf(out,"wrong data for S2_v\n"); exit(1); }
{Size2 r = Size2_1;
- FPRINTF(out,"Size2 f(void):");
+ fprintf(out,"Size2 f(void):");
fflush(out);
*(Size2*)retp = r;
}}
{
if (data != (void*)&S3_v) { fprintf(out,"wrong data for S3_v\n"); exit(1); }
{Size3 r = Size3_1;
- FPRINTF(out,"Size3 f(void):");
+ fprintf(out,"Size3 f(void):");
fflush(out);
*(Size3*)retp = r;
}}
{
if (data != (void*)&S4_v) { fprintf(out,"wrong data for S4_v\n"); exit(1); }
{Size4 r = Size4_1;
- FPRINTF(out,"Size4 f(void):");
+ fprintf(out,"Size4 f(void):");
fflush(out);
*(Size4*)retp = r;
}}
{
if (data != (void*)&S7_v) { fprintf(out,"wrong data for S7_v\n"); exit(1); }
{Size7 r = Size7_1;
- FPRINTF(out,"Size7 f(void):");
+ fprintf(out,"Size7 f(void):");
fflush(out);
*(Size7*)retp = r;
}}
{
if (data != (void*)&S8_v) { fprintf(out,"wrong data for S8_v\n"); exit(1); }
{Size8 r = Size8_1;
- FPRINTF(out,"Size8 f(void):");
+ fprintf(out,"Size8 f(void):");
fflush(out);
*(Size8*)retp = r;
}}
{
if (data != (void*)&S12_v) { fprintf(out,"wrong data for S12_v\n"); exit(1); }
{Size12 r = Size12_1;
- FPRINTF(out,"Size12 f(void):");
+ fprintf(out,"Size12 f(void):");
fflush(out);
*(Size12*)retp = r;
}}
{
if (data != (void*)&S15_v) { fprintf(out,"wrong data for S15_v\n"); exit(1); }
{Size15 r = Size15_1;
- FPRINTF(out,"Size15 f(void):");
+ fprintf(out,"Size15 f(void):");
fflush(out);
*(Size15*)retp = r;
}}
{
if (data != (void*)&S16_v) { fprintf(out,"wrong data for S16_v\n"); exit(1); }
{Size16 r = Size16_1;
- FPRINTF(out,"Size16 f(void):");
+ fprintf(out,"Size16 f(void):");
fflush(out);
*(Size16*)retp = r;
}}
Int c = *(Int*)(*args++);
Int r;
r.x = a.x + b.x + c.x;
- FPRINTF(out,"Int f(Int,Int,Int):({%d},{%d},{%d})",a.x,b.x,c.x);
+ fprintf(out,"Int f(Int,Int,Int):({%d},{%d},{%d})",a.x,b.x,c.x);
fflush(out);
*(Int*)retp = r;
}}
Char c = *(Char*)(*args++);
Char r;
r.x = (a.x + c.x)/2;
- FPRINTF(out,"Char f(Char,double,Char):({'%c'},%g,{'%c'})",a.x,b,c.x);
+ fprintf(out,"Char f(Char,double,Char):({'%c'},%g,{'%c'})",a.x,b,c.x);
fflush(out);
*(Char*)retp = r;
}}
double c = *(double*)(*args++);
Float r;
r.x = a.x + b + c;
- FPRINTF(out,"Float f(Float,float,double):({%g},%g,%g)",a.x,b,c);
+ fprintf(out,"Float f(Float,float,double):({%g},%g,%g)",a.x,b,c);
fflush(out);
*(Float*)retp = r;
}}
double c = *(double*)(*args++);
Double r;
r.x = a + b.x + c;
- FPRINTF(out,"Double f(float,Double,double):(%g,{%g},%g)",a,b.x,c);
+ fprintf(out,"Double f(float,Double,double):(%g,{%g},%g)",a,b.x,c);
fflush(out);
*(Double*)retp = r;
}}
double c = *(double*)(*args++);
Double r;
r.x = a.x + b + c;
- FPRINTF(out,"Double f(Double,float,double):({%g},%g,%g)",a.x,b,c);
+ fprintf(out,"Double f(Double,float,double):({%g},%g,%g)",a.x,b,c);
fflush(out);
*(Double*)retp = r;
}}
J c = *(J*)(*args++);
J r;
r.l1 = a.l1+c.l1; r.l2 = a.l2+b+c.l2;
- FPRINTF(out,"J f(J,int,J):({%ld,%ld},%d,{%ld,%ld})",a.l1,a.l2,b,c.l1,c.l2);
+ fprintf(out,"J f(J,int,J):({%ld,%ld},%d,{%ld,%ld})",a.l1,a.l2,b,c.l1,c.l2);
fflush(out);
*(J*)retp = r;
}}
T c = *(T*)(*args++);
T r;
r.c[0]='b'; r.c[1]=c.c[1]; r.c[2]=c.c[2];
- FPRINTF(out,"T f(T,char,T):({\"%c%c%c\"},'%c',{\"%c%c%c\"})",a.c[0],a.c[1],a.c[2],b,c.c[0],c.c[1],c.c[2]);
+ fprintf(out,"T f(T,char,T):({\"%c%c%c\"},'%c',{\"%c%c%c\"})",a.c[0],a.c[1],a.c[2],b,c.c[0],c.c[1],c.c[2]);
fflush(out);
*(T*)retp = r;
}}
X r;
r = xr;
r.c1 = b;
- FPRINTF(out,"X f(B,char,double,B):({%g,{%d,%d,%d}},'%c',%g,{%g,{%d,%d,%d}})",
+ fprintf(out,"X f(B,char,double,B):({%g,{%d,%d,%d}},'%c',%g,{%g,{%d,%d,%d}})",
a.d,a.i[0],a.i[1],a.i[2],b,c,d.d,d.i[0],d.i[1],d.i[2]);
fflush(out);
*(X*)retp = r;
{K b = *(K*)(*args++);
long c = *(long*)(*args++);
long r = b.l1 + b.l2 + b.l3 + b.l4 + c;
- FPRINTF(out,"long f(K,long):(%ld,%ld,%ld,%ld,%ld)",b.l1,b.l2,b.l3,b.l4,c);
+ fprintf(out,"long f(K,long):(%ld,%ld,%ld,%ld,%ld)",b.l1,b.l2,b.l3,b.l4,c);
fflush(out);
*(ffi_arg*)retp = r;
}}
K b = *(K*)(*args++);
long c = *(long*)(*args++);
long r = a1 + b.l1 + b.l2 + b.l3 + b.l4 + c;
- FPRINTF(out,"long f(long,K,long):(%ld,%ld,%ld,%ld,%ld,%ld)",a1,b.l1,b.l2,b.l3,b.l4,c);
+ fprintf(out,"long f(long,K,long):(%ld,%ld,%ld,%ld,%ld,%ld)",a1,b.l1,b.l2,b.l3,b.l4,c);
fflush(out);
*(ffi_arg*)retp = r;
}}
K b = *(K*)(*args++);
long c = *(long*)(*args++);
long r = a1 + a2 + b.l1 + b.l2 + b.l3 + b.l4 + c;
- FPRINTF(out,"long f(2*long,K,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a1,a2,b.l1,b.l2,b.l3,b.l4,c);
+ fprintf(out,"long f(2*long,K,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a1,a2,b.l1,b.l2,b.l3,b.l4,c);
fflush(out);
*(ffi_arg*)retp = r;
}}
K b = *(K*)(*args++);
long c = *(long*)(*args++);
long r = a1 + a2 + a3 + b.l1 + b.l2 + b.l3 + b.l4 + c;
- FPRINTF(out,"long f(3*long,K,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a1,a2,a3,b.l1,b.l2,b.l3,b.l4,c);
+ fprintf(out,"long f(3*long,K,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a1,a2,a3,b.l1,b.l2,b.l3,b.l4,c);
fflush(out);
*(ffi_arg*)retp = r;
}}
K b = *(K*)(*args++);
long c = *(long*)(*args++);
long r = a1 + a2 + a3 + a4 + b.l1 + b.l2 + b.l3 + b.l4 + c;
- FPRINTF(out,"long f(4*long,K,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a1,a2,a3,a4,b.l1,b.l2,b.l3,b.l4,c);
+ fprintf(out,"long f(4*long,K,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a1,a2,a3,a4,b.l1,b.l2,b.l3,b.l4,c);
fflush(out);
*(ffi_arg*)retp = r;
}}
K b = *(K*)(*args++);
long c = *(long*)(*args++);
long r = a1 + a2 + a3 + a4 + a5 + b.l1 + b.l2 + b.l3 + b.l4 + c;
- FPRINTF(out,"long f(5*long,K,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a1,a2,a3,a4,a5,b.l1,b.l2,b.l3,b.l4,c);
+ fprintf(out,"long f(5*long,K,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a1,a2,a3,a4,a5,b.l1,b.l2,b.l3,b.l4,c);
fflush(out);
*(ffi_arg*)retp = r;
}}
K b = *(K*)(*args++);
long c = *(long*)(*args++);
long r = a1 + a2 + a3 + a4 + a5 + a6 + b.l1 + b.l2 + b.l3 + b.l4 + c;
- FPRINTF(out,"long f(6*long,K,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a1,a2,a3,a4,a5,a6,b.l1,b.l2,b.l3,b.l4,c);
+ fprintf(out,"long f(6*long,K,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a1,a2,a3,a4,a5,a6,b.l1,b.l2,b.l3,b.l4,c);
fflush(out);
*(ffi_arg*)retp = r;
}}
long u = *(long*)(*args++);
L z = *(L*)(*args++);
float r = a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p+q+s+t+u+z.l1+z.l2+z.l3+z.l4+z.l5+z.l6;
- FPRINTF(out,"float f(17*float,3*int,L):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,s,t,u,z.l1,z.l2,z.l3,z.l4,z.l5,z.l6);
+ fprintf(out,"float f(17*float,3*int,L):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,s,t,u,z.l1,z.l2,z.l3,z.l4,z.l5,z.l6);
fflush(out);
*(float*)retp = r;
}}
long u = *(long*)(*args++);
L z = *(L*)(*args++);
double r = a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p+q+s+t+u+z.l1+z.l2+z.l3+z.l4+z.l5+z.l6;
- FPRINTF(out,"double f(17*double,3*int,L):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,s,t,u,z.l1,z.l2,z.l3,z.l4,z.l5,z.l6);
+ fprintf(out,"double f(17*double,3*int,L):(%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%g,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,s,t,u,z.l1,z.l2,z.l3,z.l4,z.l5,z.l6);
fflush(out);
*(double*)retp = r;
}}
long long b = *(long long *)(*args++);
long c = *(long*)(*args++);
long long r = (long long) (a1 + a2) + b + c;
- FPRINTF(out,"long long f(2*long,long long,long):(%ld,%ld,0x%lx%08lx,%ld)",a1,a2,(long)(b>>32),(long)(b&0xffffffff),c);
+ fprintf(out,"long long f(2*long,long long,long):(%ld,%ld,0x%lx%08lx,%ld)",a1,a2,(long)(b>>32),(long)(b&0xffffffff),c);
fflush(out);
*(long long *)retp = r;
}}
long long b = *(long long *)(*args++);
long c = *(long*)(*args++);
long long r = (long long) (a1 + a2 + a3) + b + c;
- FPRINTF(out,"long long f(3*long,long long,long):(%ld,%ld,%ld,0x%lx%08lx,%ld)",a1,a2,a3,(long)(b>>32),(long)(b&0xffffffff),c);
+ fprintf(out,"long long f(3*long,long long,long):(%ld,%ld,%ld,0x%lx%08lx,%ld)",a1,a2,a3,(long)(b>>32),(long)(b&0xffffffff),c);
fflush(out);
*(long long *)retp = r;
}}
long long b = *(long long *)(*args++);
long c = *(long*)(*args++);
long long r = (long long) (a1 + a2 + a3 + a4) + b + c;
- FPRINTF(out,"long long f(4*long,long long,long):(%ld,%ld,%ld,%ld,0x%lx%08lx,%ld)",a1,a2,a3,a4,(long)(b>>32),(long)(b&0xffffffff),c);
+ fprintf(out,"long long f(4*long,long long,long):(%ld,%ld,%ld,%ld,0x%lx%08lx,%ld)",a1,a2,a3,a4,(long)(b>>32),(long)(b&0xffffffff),c);
fflush(out);
*(long long *)retp = r;
}}
long long b = *(long long *)(*args++);
long c = *(long*)(*args++);
long long r = (long long) (a1 + a2 + a3 + a4 + a5) + b + c;
- FPRINTF(out,"long long f(5*long,long long,long):(%ld,%ld,%ld,%ld,%ld,0x%lx%08lx,%ld)",a1,a2,a3,a4,a5,(long)(b>>32),(long)(b&0xffffffff),c);
+ fprintf(out,"long long f(5*long,long long,long):(%ld,%ld,%ld,%ld,%ld,0x%lx%08lx,%ld)",a1,a2,a3,a4,a5,(long)(b>>32),(long)(b&0xffffffff),c);
fflush(out);
*(long long *)retp = r;
}}
long long b = *(long long *)(*args++);
long c = *(long*)(*args++);
long long r = (long long) (a1 + a2 + a3 + a4 + a5 + a6) + b + c;
- FPRINTF(out,"long long f(6*long,long long,long):(%ld,%ld,%ld,%ld,%ld,%ld,0x%lx%08lx,%ld)",a1,a2,a3,a4,a5,a6,(long)(b>>32),(long)(b&0xffffffff),c);
+ fprintf(out,"long long f(6*long,long long,long):(%ld,%ld,%ld,%ld,%ld,%ld,0x%lx%08lx,%ld)",a1,a2,a3,a4,a5,a6,(long)(b>>32),(long)(b&0xffffffff),c);
fflush(out);
*(long long *)retp = r;
}}
long long b = *(long long *)(*args++);
long c = *(long*)(*args++);
long long r = (long long) (a1 + a2 + a3 + a4 + a5 + a6 + a7) + b + c;
- FPRINTF(out,"long long f(7*long,long long,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld,0x%lx%08lx,%ld)",a1,a2,a3,a4,a5,a6,a7,(long)(b>>32),(long)(b&0xffffffff),c);
+ fprintf(out,"long long f(7*long,long long,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld,0x%lx%08lx,%ld)",a1,a2,a3,a4,a5,a6,a7,(long)(b>>32),(long)(b&0xffffffff),c);
fflush(out);
*(long long *)retp = r;
}}
double b = *(double*)(*args++);
long c = *(long*)(*args++);
double r = (double) (a1 + a2) + b + c;
- FPRINTF(out,"double f(2*long,double,long):(%ld,%ld,%g,%ld)",a1,a2,b,c);
+ fprintf(out,"double f(2*long,double,long):(%ld,%ld,%g,%ld)",a1,a2,b,c);
fflush(out);
*(double*)retp = r;
}}
double b = *(double*)(*args++);
long c = *(long*)(*args++);
double r = (double) (a1 + a2 + a3) + b + c;
- FPRINTF(out,"double f(3*long,double,long):(%ld,%ld,%ld,%g,%ld)",a1,a2,a3,b,c);
+ fprintf(out,"double f(3*long,double,long):(%ld,%ld,%ld,%g,%ld)",a1,a2,a3,b,c);
fflush(out);
*(double*)retp = r;
}}
double b = *(double*)(*args++);
long c = *(long*)(*args++);
double r = (double) (a1 + a2 + a3 + a4) + b + c;
- FPRINTF(out,"double f(4*long,double,long):(%ld,%ld,%ld,%ld,%g,%ld)",a1,a2,a3,a4,b,c);
+ fprintf(out,"double f(4*long,double,long):(%ld,%ld,%ld,%ld,%g,%ld)",a1,a2,a3,a4,b,c);
fflush(out);
*(double*)retp = r;
}}
double b = *(double*)(*args++);
long c = *(long*)(*args++);
double r = (double) (a1 + a2 + a3 + a4 + a5) + b + c;
- FPRINTF(out,"double f(5*long,double,long):(%ld,%ld,%ld,%ld,%ld,%g,%ld)",a1,a2,a3,a4,a5,b,c);
+ fprintf(out,"double f(5*long,double,long):(%ld,%ld,%ld,%ld,%ld,%g,%ld)",a1,a2,a3,a4,a5,b,c);
fflush(out);
*(double*)retp = r;
}}
double b = *(double*)(*args++);
long c = *(long*)(*args++);
double r = (double) (a1 + a2 + a3 + a4 + a5 + a6) + b + c;
- FPRINTF(out,"double f(6*long,double,long):(%ld,%ld,%ld,%ld,%ld,%ld,%g,%ld)",a1,a2,a3,a4,a5,a6,b,c);
+ fprintf(out,"double f(6*long,double,long):(%ld,%ld,%ld,%ld,%ld,%ld,%g,%ld)",a1,a2,a3,a4,a5,a6,b,c);
fflush(out);
*(double*)retp = r;
}}
double b = *(double*)(*args++);
long c = *(long*)(*args++);
double r = (double) (a1 + a2 + a3 + a4 + a5 + a6 + a7) + b + c;
- FPRINTF(out,"double f(7*long,double,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld,%g,%ld)",a1,a2,a3,a4,a5,a6,a7,b,c);
+ fprintf(out,"double f(7*long,double,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld,%g,%ld)",a1,a2,a3,a4,a5,a6,a7,b,c);
fflush(out);
*(double*)retp = r;
}}
ir = ((int (*) (void)) callback_code) ();
}
FREE_CALLBACK();
- FPRINTF(out,"->%d\n",ir);
+ fprintf(out,"->%d\n",ir);
fflush(out);
#endif
ir = ((int (*) (int)) callback_code) (i1);
}
FREE_CALLBACK();
- FPRINTF(out,"->%d\n",ir);
+ fprintf(out,"->%d\n",ir);
fflush(out);
#endif
ir = ((int (*) (int,int)) callback_code) (i1,i2);
}
FREE_CALLBACK();
- FPRINTF(out,"->%d\n",ir);
+ fprintf(out,"->%d\n",ir);
fflush(out);
#endif
ir = ((int (*) (int,int,int,int)) callback_code) (i1,i2,i3,i4);
}
FREE_CALLBACK();
- FPRINTF(out,"->%d\n",ir);
+ fprintf(out,"->%d\n",ir);
fflush(out);
#endif
ir = ((int (*) (int,int,int,int,int,int,int,int)) callback_code) (i1,i2,i3,i4,i5,i6,i7,i8);
}
FREE_CALLBACK();
- FPRINTF(out,"->%d\n",ir);
+ fprintf(out,"->%d\n",ir);
fflush(out);
#endif
ir = ((int (*) (int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int)) callback_code) (i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11,i12,i13,i14,i15,i16);
}
FREE_CALLBACK();
- FPRINTF(out,"->%d\n",ir);
+ fprintf(out,"->%d\n",ir);
fflush(out);
#endif
}
fr = ((float (*) (float)) callback_code) (f1);
}
FREE_CALLBACK();
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
#endif
fr = ((float (*) (float,float)) callback_code) (f1,f2);
}
FREE_CALLBACK();
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
#endif
fr = ((float (*) (float,float,float,float)) callback_code) (f1,f2,f3,f4);
}
FREE_CALLBACK();
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
#endif
fr = ((float (*) (float,float,float,float,float,float,float,float)) callback_code) (f1,f2,f3,f4,f5,f6,f7,f8);
}
FREE_CALLBACK();
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
#endif
fr = ((float (*) (float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float)) callback_code) (f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16);
}
FREE_CALLBACK();
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
#endif
fr = ((float (*) (float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float)) callback_code) (f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16,f17,f18,f19,f20,f21,f22,f23,f24);
}
FREE_CALLBACK();
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
#endif
dr = ((double (*) (double)) callback_code) (d1);
}
FREE_CALLBACK();
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
dr = ((double (*) (double,double)) callback_code) (d1,d2);
}
FREE_CALLBACK();
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
dr = ((double (*) (double,double,double,double)) callback_code) (d1,d2,d3,d4);
}
FREE_CALLBACK();
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
dr = ((double (*) (double,double,double,double,double,double,double,double)) callback_code) (d1,d2,d3,d4,d5,d6,d7,d8);
}
FREE_CALLBACK();
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
dr = ((double (*) (double,double,double,double,double,double,double,double,double,double,double,double,double,double,double,double)) callback_code) (d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13,d14,d15,d16);
}
FREE_CALLBACK();
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
}
vpr = ((void* (*) (void*,double*,char*,Int*)) callback_code) (&uc1,&d2,str3,&I4);
}
FREE_CALLBACK();
- FPRINTF(out,"->0x%p\n",vpr);
+ fprintf(out,"->0x%p\n",vpr);
fflush(out);
#endif
}
ucr = ((uchar (*) (uchar,ushort,uint,ulong)) callback_code) (uc1,us2,ui3,ul4);
}
FREE_CALLBACK();
- FPRINTF(out,"->%u\n",ucr);
+ fprintf(out,"->%u\n",ucr);
fflush(out);
#endif
dr = ((double (*) (int,int,double,double)) callback_code) (i1,i2,d3,d4);
}
FREE_CALLBACK();
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 23
dr = d_idid(i1,d2,i3,d4);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
#if (!defined(DGTEST)) || DGTEST == 24
dr = d_fdi(f1,d2,i3);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
#if (!defined(DGTEST)) || DGTEST == 25
usr = us_cdcd(c1,d2,c3,d4);
- FPRINTF(out,"->%u\n",usr);
+ fprintf(out,"->%u\n",usr);
fflush(out);
usr = 0; clear_traces();
ALLOC_CALLBACK();
#if (!defined(DGTEST)) || DGTEST == 26
llr = ll_iiilli(i1,i2,i3,ll1,i13);
- FPRINTF(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
fflush(out);
llr = 0; clear_traces();
ALLOC_CALLBACK();
llr = ((long long (*) (int,int,int,long long,int)) callback_code) (i1,i2,i3,ll1,i13);
}
FREE_CALLBACK();
- FPRINTF(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 27
llr = ll_flli(f13,ll1,i13);
- FPRINTF(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
fflush(out);
llr = 0; clear_traces();
ALLOC_CALLBACK();
llr = ((long long (*) (float,long long,int)) callback_code) (f13,ll1,i13);
}
FREE_CALLBACK();
- FPRINTF(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 28
fr = f_fi(f1,i9);
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
fr = 0.0; clear_traces();
ALLOC_CALLBACK();
fr = ((float (*) (float,int)) callback_code) (f1,i9);
}
FREE_CALLBACK();
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 29
fr = f_f2i(f1,f2,i9);
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
fr = 0.0; clear_traces();
ALLOC_CALLBACK();
fr = ((float (*) (float,float,int)) callback_code) (f1,f2,i9);
}
FREE_CALLBACK();
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 30
fr = f_f3i(f1,f2,f3,i9);
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
fr = 0.0; clear_traces();
ALLOC_CALLBACK();
fr = ((float (*) (float,float,float,int)) callback_code) (f1,f2,f3,i9);
}
FREE_CALLBACK();
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 31
fr = f_f4i(f1,f2,f3,f4,i9);
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
fr = 0.0; clear_traces();
ALLOC_CALLBACK();
fr = ((float (*) (float,float,float,float,int)) callback_code) (f1,f2,f3,f4,i9);
}
FREE_CALLBACK();
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 32
fr = f_f7i(f1,f2,f3,f4,f5,f6,f7,i9);
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
fr = 0.0; clear_traces();
ALLOC_CALLBACK();
fr = ((float (*) (float,float,float,float,float,float,float,int)) callback_code) (f1,f2,f3,f4,f5,f6,f7,i9);
}
FREE_CALLBACK();
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 33
fr = f_f8i(f1,f2,f3,f4,f5,f6,f7,f8,i9);
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
fr = 0.0; clear_traces();
ALLOC_CALLBACK();
fr = ((float (*) (float,float,float,float,float,float,float,float,int)) callback_code) (f1,f2,f3,f4,f5,f6,f7,f8,i9);
}
FREE_CALLBACK();
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 34
fr = f_f13i(f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,i9);
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
fr = 0.0; clear_traces();
ALLOC_CALLBACK();
fr = ((float (*) (float,float,float,float,float,float,float,float,float,float,float,float,float,int)) callback_code) (f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,i9);
}
FREE_CALLBACK();
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 35
dr = d_di(d1,i9);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
dr = ((double (*) (double,int)) callback_code) (d1,i9);
}
FREE_CALLBACK();
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 36
dr = d_d2i(d1,d2,i9);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
dr = ((double (*) (double,double,int)) callback_code) (d1,d2,i9);
}
FREE_CALLBACK();
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 37
dr = d_d3i(d1,d2,d3,i9);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
dr = ((double (*) (double,double,double,int)) callback_code) (d1,d2,d3,i9);
}
FREE_CALLBACK();
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 38
dr = d_d4i(d1,d2,d3,d4,i9);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
dr = ((double (*) (double,double,double,double,int)) callback_code) (d1,d2,d3,d4,i9);
}
FREE_CALLBACK();
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 39
dr = d_d7i(d1,d2,d3,d4,d5,d6,d7,i9);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
dr = ((double (*) (double,double,double,double,double,double,double,int)) callback_code) (d1,d2,d3,d4,d5,d6,d7,i9);
}
FREE_CALLBACK();
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 40
dr = d_d8i(d1,d2,d3,d4,d5,d6,d7,d8,i9);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
dr = ((double (*) (double,double,double,double,double,double,double,double,int)) callback_code) (d1,d2,d3,d4,d5,d6,d7,d8,i9);
}
FREE_CALLBACK();
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 41
dr = d_d12i(d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,i9);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
dr = ((double (*) (double,double,double,double,double,double,double,double,double,double,double,double,int)) callback_code) (d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,i9);
}
FREE_CALLBACK();
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 42
dr = d_d13i(d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13,i9);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
dr = ((double (*) (double,double,double,double,double,double,double,double,double,double,double,double,double,int)) callback_code) (d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13,i9);
}
FREE_CALLBACK();
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
}
#if (!defined(DGTEST)) || DGTEST == 43
{
Size1 r = S1_v();
- FPRINTF(out,"->{%c}\n",r.x1);
+ fprintf(out,"->{%c}\n",r.x1);
fflush(out);
memset(&r,0,sizeof(r)); clear_traces();
ALLOC_CALLBACK();
r = ((Size1 (*) (void)) callback_code) ();
}
FREE_CALLBACK();
- FPRINTF(out,"->{%c}\n",r.x1);
+ fprintf(out,"->{%c}\n",r.x1);
fflush(out);
}
#endif
#if (!defined(DGTEST)) || DGTEST == 44
{
Size2 r = S2_v();
- FPRINTF(out,"->{%c%c}\n",r.x1,r.x2);
+ fprintf(out,"->{%c%c}\n",r.x1,r.x2);
fflush(out);
memset(&r,0,sizeof(r)); clear_traces();
ALLOC_CALLBACK();
r = ((Size2 (*) (void)) callback_code) ();
}
FREE_CALLBACK();
- FPRINTF(out,"->{%c%c}\n",r.x1,r.x2);
+ fprintf(out,"->{%c%c}\n",r.x1,r.x2);
fflush(out);
}
#endif
#if (!defined(DGTEST)) || DGTEST == 45
{
Size3 r = S3_v();
- FPRINTF(out,"->{%c%c%c}\n",r.x1,r.x2,r.x3);
+ fprintf(out,"->{%c%c%c}\n",r.x1,r.x2,r.x3);
fflush(out);
memset(&r,0,sizeof(r)); clear_traces();
ALLOC_CALLBACK();
r = ((Size3 (*) (void)) callback_code) ();
}
FREE_CALLBACK();
- FPRINTF(out,"->{%c%c%c}\n",r.x1,r.x2,r.x3);
+ fprintf(out,"->{%c%c%c}\n",r.x1,r.x2,r.x3);
fflush(out);
}
#endif
#if (!defined(DGTEST)) || DGTEST == 46
{
Size4 r = S4_v();
- FPRINTF(out,"->{%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4);
+ fprintf(out,"->{%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4);
fflush(out);
memset(&r,0,sizeof(r)); clear_traces();
ALLOC_CALLBACK();
r = ((Size4 (*) (void)) callback_code) ();
}
FREE_CALLBACK();
- FPRINTF(out,"->{%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4);
+ fprintf(out,"->{%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4);
fflush(out);
}
#endif
#if (!defined(DGTEST)) || DGTEST == 47
{
Size7 r = S7_v();
- FPRINTF(out,"->{%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7);
+ fprintf(out,"->{%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7);
fflush(out);
memset(&r,0,sizeof(r)); clear_traces();
ALLOC_CALLBACK();
r = ((Size7 (*) (void)) callback_code) ();
}
FREE_CALLBACK();
- FPRINTF(out,"->{%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7);
+ fprintf(out,"->{%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7);
fflush(out);
}
#endif
#if (!defined(DGTEST)) || DGTEST == 48
{
Size8 r = S8_v();
- FPRINTF(out,"->{%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8);
+ fprintf(out,"->{%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8);
fflush(out);
memset(&r,0,sizeof(r)); clear_traces();
ALLOC_CALLBACK();
r = ((Size8 (*) (void)) callback_code) ();
}
FREE_CALLBACK();
- FPRINTF(out,"->{%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8);
+ fprintf(out,"->{%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8);
fflush(out);
}
#endif
#if (!defined(DGTEST)) || DGTEST == 49
{
Size12 r = S12_v();
- FPRINTF(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12);
+ fprintf(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12);
fflush(out);
memset(&r,0,sizeof(r)); clear_traces();
ALLOC_CALLBACK();
r = ((Size12 (*) (void)) callback_code) ();
}
FREE_CALLBACK();
- FPRINTF(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12);
+ fprintf(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12);
fflush(out);
}
#endif
#if (!defined(DGTEST)) || DGTEST == 50
{
Size15 r = S15_v();
- FPRINTF(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12,r.x13,r.x14,r.x15);
+ fprintf(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12,r.x13,r.x14,r.x15);
fflush(out);
memset(&r,0,sizeof(r)); clear_traces();
ALLOC_CALLBACK();
r = ((Size15 (*) (void)) callback_code) ();
}
FREE_CALLBACK();
- FPRINTF(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12,r.x13,r.x14,r.x15);
+ fprintf(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12,r.x13,r.x14,r.x15);
fflush(out);
}
#endif
#if (!defined(DGTEST)) || DGTEST == 51
{
Size16 r = S16_v();
- FPRINTF(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12,r.x13,r.x14,r.x15,r.x16);
+ fprintf(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12,r.x13,r.x14,r.x15,r.x16);
fflush(out);
memset(&r,0,sizeof(r)); clear_traces();
ALLOC_CALLBACK();
r = ((Size16 (*) (void)) callback_code) ();
}
FREE_CALLBACK();
- FPRINTF(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12,r.x13,r.x14,r.x15,r.x16);
+ fprintf(out,"->{%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c}\n",r.x1,r.x2,r.x3,r.x4,r.x5,r.x6,r.x7,r.x8,r.x9,r.x10,r.x11,r.x12,r.x13,r.x14,r.x15,r.x16);
fflush(out);
}
#endif
#if (!defined(DGTEST)) || DGTEST == 52
Ir = I_III(I1,I2,I3);
- FPRINTF(out,"->{%d}\n",Ir.x);
+ fprintf(out,"->{%d}\n",Ir.x);
fflush(out);
Ir.x = 0; clear_traces();
ALLOC_CALLBACK();
Ir = ((Int (*) (Int,Int,Int)) callback_code) (I1,I2,I3);
}
FREE_CALLBACK();
- FPRINTF(out,"->{%d}\n",Ir.x);
+ fprintf(out,"->{%d}\n",Ir.x);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 53
Cr = C_CdC(C1,d2,C3);
- FPRINTF(out,"->{'%c'}\n",Cr.x);
+ fprintf(out,"->{'%c'}\n",Cr.x);
fflush(out);
Cr.x = '\0'; clear_traces();
ALLOC_CALLBACK();
Cr = ((Char (*) (Char,double,Char)) callback_code) (C1,d2,C3);
}
FREE_CALLBACK();
- FPRINTF(out,"->{'%c'}\n",Cr.x);
+ fprintf(out,"->{'%c'}\n",Cr.x);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 54
Fr = F_Ffd(F1,f2,d3);
- FPRINTF(out,"->{%g}\n",Fr.x);
+ fprintf(out,"->{%g}\n",Fr.x);
fflush(out);
Fr.x = 0.0; clear_traces();
ALLOC_CALLBACK();
Fr = ((Float (*) (Float,float,double)) callback_code) (F1,f2,d3);
}
FREE_CALLBACK();
- FPRINTF(out,"->{%g}\n",Fr.x);
+ fprintf(out,"->{%g}\n",Fr.x);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 55
Dr = D_fDd(f1,D2,d3);
- FPRINTF(out,"->{%g}\n",Dr.x);
+ fprintf(out,"->{%g}\n",Dr.x);
fflush(out);
Dr.x = 0.0; clear_traces();
ALLOC_CALLBACK();
Dr = ((Double (*) (float,Double,double)) callback_code) (f1,D2,d3);
}
FREE_CALLBACK();
- FPRINTF(out,"->{%g}\n",Dr.x);
+ fprintf(out,"->{%g}\n",Dr.x);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 56
Dr = D_Dfd(D1,f2,d3);
- FPRINTF(out,"->{%g}\n",Dr.x);
+ fprintf(out,"->{%g}\n",Dr.x);
fflush(out);
Dr.x = 0.0; clear_traces();
ALLOC_CALLBACK();
Dr = ((Double (*) (Double,float,double)) callback_code) (D1,f2,d3);
}
FREE_CALLBACK();
- FPRINTF(out,"->{%g}\n",Dr.x);
+ fprintf(out,"->{%g}\n",Dr.x);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 57
Jr = J_JiJ(J1,i2,J2);
- FPRINTF(out,"->{%ld,%ld}\n",Jr.l1,Jr.l2);
+ fprintf(out,"->{%ld,%ld}\n",Jr.l1,Jr.l2);
fflush(out);
Jr.l1 = Jr.l2 = 0; clear_traces();
ALLOC_CALLBACK();
Jr = ((J (*) (J,int,J)) callback_code) (J1,i2,J2);
}
FREE_CALLBACK();
- FPRINTF(out,"->{%ld,%ld}\n",Jr.l1,Jr.l2);
+ fprintf(out,"->{%ld,%ld}\n",Jr.l1,Jr.l2);
fflush(out);
#endif
#ifndef SKIP_EXTRA_STRUCTS
#if (!defined(DGTEST)) || DGTEST == 58
Tr = T_TcT(T1,' ',T2);
- FPRINTF(out,"->{\"%c%c%c\"}\n",Tr.c[0],Tr.c[1],Tr.c[2]);
+ fprintf(out,"->{\"%c%c%c\"}\n",Tr.c[0],Tr.c[1],Tr.c[2]);
fflush(out);
Tr.c[0] = Tr.c[1] = Tr.c[2] = 0; clear_traces();
ALLOC_CALLBACK();
Tr = ((T (*) (T,char,T)) callback_code) (T1,' ',T2);
}
FREE_CALLBACK();
- FPRINTF(out,"->{\"%c%c%c\"}\n",Tr.c[0],Tr.c[1],Tr.c[2]);
+ fprintf(out,"->{\"%c%c%c\"}\n",Tr.c[0],Tr.c[1],Tr.c[2]);
fflush(out);
#endif
#ifndef SKIP_X
#if (!defined(DGTEST)) || DGTEST == 59
Xr = X_BcdB(B1,c2,d3,B2);
- FPRINTF(out,"->{\"%s\",'%c'}\n",Xr.c,Xr.c1);
+ fprintf(out,"->{\"%s\",'%c'}\n",Xr.c,Xr.c1);
fflush(out);
Xr.c[0]=Xr.c1='\0'; clear_traces();
ALLOC_CALLBACK();
Xr = ((X (*) (B,char,double,B)) callback_code) (B1,c2,d3,B2);
}
FREE_CALLBACK();
- FPRINTF(out,"->{\"%s\",'%c'}\n",Xr.c,Xr.c1);
+ fprintf(out,"->{\"%s\",'%c'}\n",Xr.c,Xr.c1);
fflush(out);
#endif
#endif
#if (!defined(DGTEST)) || DGTEST == 60
lr = l_l0K(K1,l9);
- FPRINTF(out,"->%ld\n",lr);
+ fprintf(out,"->%ld\n",lr);
fflush(out);
lr = 0; clear_traces();
ALLOC_CALLBACK();
lr = ((long (*) (K,long)) callback_code) (K1,l9);
}
FREE_CALLBACK();
- FPRINTF(out,"->%ld\n",lr);
+ fprintf(out,"->%ld\n",lr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 61
lr = l_l1K(l1,K1,l9);
- FPRINTF(out,"->%ld\n",lr);
+ fprintf(out,"->%ld\n",lr);
fflush(out);
lr = 0; clear_traces();
ALLOC_CALLBACK();
lr = ((long (*) (long,K,long)) callback_code) (l1,K1,l9);
}
FREE_CALLBACK();
- FPRINTF(out,"->%ld\n",lr);
+ fprintf(out,"->%ld\n",lr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 62
lr = l_l2K(l1,l2,K1,l9);
- FPRINTF(out,"->%ld\n",lr);
+ fprintf(out,"->%ld\n",lr);
fflush(out);
lr = 0; clear_traces();
ALLOC_CALLBACK();
lr = ((long (*) (long,long,K,long)) callback_code) (l1,l2,K1,l9);
}
FREE_CALLBACK();
- FPRINTF(out,"->%ld\n",lr);
+ fprintf(out,"->%ld\n",lr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 63
lr = l_l3K(l1,l2,l3,K1,l9);
- FPRINTF(out,"->%ld\n",lr);
+ fprintf(out,"->%ld\n",lr);
fflush(out);
lr = 0; clear_traces();
ALLOC_CALLBACK();
lr = ((long (*) (long,long,long,K,long)) callback_code) (l1,l2,l3,K1,l9);
}
FREE_CALLBACK();
- FPRINTF(out,"->%ld\n",lr);
+ fprintf(out,"->%ld\n",lr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 64
lr = l_l4K(l1,l2,l3,l4,K1,l9);
- FPRINTF(out,"->%ld\n",lr);
+ fprintf(out,"->%ld\n",lr);
fflush(out);
lr = 0; clear_traces();
ALLOC_CALLBACK();
lr = ((long (*) (long,long,long,long,K,long)) callback_code) (l1,l2,l3,l4,K1,l9);
}
FREE_CALLBACK();
- FPRINTF(out,"->%ld\n",lr);
+ fprintf(out,"->%ld\n",lr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 65
lr = l_l5K(l1,l2,l3,l4,l5,K1,l9);
- FPRINTF(out,"->%ld\n",lr);
+ fprintf(out,"->%ld\n",lr);
fflush(out);
lr = 0; clear_traces();
ALLOC_CALLBACK();
lr = ((long (*) (long,long,long,long,long,K,long)) callback_code) (l1,l2,l3,l4,l5,K1,l9);
}
FREE_CALLBACK();
- FPRINTF(out,"->%ld\n",lr);
+ fprintf(out,"->%ld\n",lr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 66
lr = l_l6K(l1,l2,l3,l4,l5,l6,K1,l9);
- FPRINTF(out,"->%ld\n",lr);
+ fprintf(out,"->%ld\n",lr);
fflush(out);
lr = 0; clear_traces();
ALLOC_CALLBACK();
lr = ((long (*) (long,long,long,long,long,long,K,long)) callback_code) (l1,l2,l3,l4,l5,l6,K1,l9);
}
FREE_CALLBACK();
- FPRINTF(out,"->%ld\n",lr);
+ fprintf(out,"->%ld\n",lr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 67
fr = f_f17l3L(f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16,f17,l6,l7,l8,L1);
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
fr = 0.0; clear_traces();
ALLOC_CALLBACK();
fr = ((float (*) (float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,long,long,long,L)) callback_code) (f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16,f17,l6,l7,l8,L1);
}
FREE_CALLBACK();
- FPRINTF(out,"->%g\n",fr);
+ fprintf(out,"->%g\n",fr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 68
dr = d_d17l3L(d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13,d14,d15,d16,d17,l6,l7,l8,L1);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
dr = ((double (*) (double,double,double,double,double,double,double,double,double,double,double,double,double,double,double,double,double,long,long,long,L)) callback_code) (d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13,d14,d15,d16,d17,l6,l7,l8,L1);
}
FREE_CALLBACK();
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 69
llr = ll_l2ll(l1,l2,ll1,l9);
- FPRINTF(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
fflush(out);
llr = 0; clear_traces();
ALLOC_CALLBACK();
llr = ((long long (*) (long,long,long long,long)) callback_code) (l1,l2,ll1,l9);
}
FREE_CALLBACK();
- FPRINTF(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 70
llr = ll_l3ll(l1,l2,l3,ll1,l9);
- FPRINTF(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
fflush(out);
llr = 0; clear_traces();
ALLOC_CALLBACK();
llr = ((long long (*) (long,long,long,long long,long)) callback_code) (l1,l2,l3,ll1,l9);
}
FREE_CALLBACK();
- FPRINTF(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 71
llr = ll_l4ll(l1,l2,l3,l4,ll1,l9);
- FPRINTF(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
fflush(out);
llr = 0; clear_traces();
ALLOC_CALLBACK();
llr = ((long long (*) (long,long,long,long,long long,long)) callback_code) (l1,l2,l3,l4,ll1,l9);
}
FREE_CALLBACK();
- FPRINTF(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 72
llr = ll_l5ll(l1,l2,l3,l4,l5,ll1,l9);
- FPRINTF(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
fflush(out);
llr = 0; clear_traces();
ALLOC_CALLBACK();
llr = ((long long (*) (long,long,long,long,long,long long,long)) callback_code) (l1,l2,l3,l4,l5,ll1,l9);
}
FREE_CALLBACK();
- FPRINTF(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 73
llr = ll_l6ll(l1,l2,l3,l4,l5,l6,ll1,l9);
- FPRINTF(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
fflush(out);
llr = 0; clear_traces();
ALLOC_CALLBACK();
llr = ((long long (*) (long,long,long,long,long,long,long long,long)) callback_code) (l1,l2,l3,l4,l5,l6,ll1,l9);
}
FREE_CALLBACK();
- FPRINTF(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 74
llr = ll_l7ll(l1,l2,l3,l4,l5,l6,l7,ll1,l9);
- FPRINTF(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
fflush(out);
llr = 0; clear_traces();
ALLOC_CALLBACK();
llr = ((long long (*) (long,long,long,long,long,long,long,long long,long)) callback_code) (l1,l2,l3,l4,l5,l6,l7,ll1,l9);
}
FREE_CALLBACK();
- FPRINTF(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
+ fprintf(out,"->0x%lx%08lx\n",(long)(llr>>32),(long)(llr&0xffffffff));
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 75
dr = d_l2d(l1,l2,ll1,l9);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
dr = ((double (*) (long,long,double,long)) callback_code) (l1,l2,ll1,l9);
}
FREE_CALLBACK();
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 76
dr = d_l3d(l1,l2,l3,ll1,l9);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
dr = ((double (*) (long,long,long,double,long)) callback_code) (l1,l2,l3,ll1,l9);
}
FREE_CALLBACK();
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 77
dr = d_l4d(l1,l2,l3,l4,ll1,l9);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
dr = ((double (*) (long,long,long,long,double,long)) callback_code) (l1,l2,l3,l4,ll1,l9);
}
FREE_CALLBACK();
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 78
dr = d_l5d(l1,l2,l3,l4,l5,ll1,l9);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
dr = ((double (*) (long,long,long,long,long,double,long)) callback_code) (l1,l2,l3,l4,l5,ll1,l9);
}
FREE_CALLBACK();
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 79
dr = d_l6d(l1,l2,l3,l4,l5,l6,ll1,l9);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
dr = ((double (*) (long,long,long,long,long,long,double,long)) callback_code) (l1,l2,l3,l4,l5,l6,ll1,l9);
}
FREE_CALLBACK();
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 80
dr = d_l7d(l1,l2,l3,l4,l5,l6,l7,ll1,l9);
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
dr = ((double (*) (long,long,long,long,long,long,long,double,long)) callback_code) (l1,l2,l3,l4,l5,l6,l7,ll1,l9);
}
FREE_CALLBACK();
- FPRINTF(out,"->%g\n",dr);
+ fprintf(out,"->%g\n",dr);
fflush(out);
#endif
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
+ * the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
T T1={{'t','h','e'}},T2={{'f','o','x'}};
X X1={"abcdefghijklmnopqrstuvwxyzABCDEF",'G'}, X2={"123",'9'}, X3={"return-return-return",'R'};
+#if defined(__GNUC__)
+#define __STDCALL__ __attribute__((stdcall))
+#define __THISCALL__ __attribute__((thiscall))
+#define __FASTCALL__ __attribute__((fastcall))
+#define __MSABI__ __attribute__((ms_abi))
+#else
+#define __STDCALL__ __stdcall
+#define __THISCALL__ __thiscall
+#define __FASTCALL__ __fastcall
+#endif
+
+#ifndef ABI_ATTR
+#define ABI_ATTR
+#endif
+
/* void tests */
-void v_v (void)
+void ABI_ATTR v_v (void)
{
fprintf(out,"void f(void):\n");
fflush(out);
}
/* int tests */
-int i_v (void)
+int ABI_ATTR i_v (void)
{
int r=99;
fprintf(out,"int f(void):");
fflush(out);
return r;
}
-int i_i (int a)
+int ABI_ATTR i_i (int a)
{
int r=a+1;
fprintf(out,"int f(int):(%d)",a);
fflush(out);
return r;
}
-int i_i2 (int a, int b)
+int ABI_ATTR i_i2 (int a, int b)
{
int r=a+b;
fprintf(out,"int f(2*int):(%d,%d)",a,b);
fflush(out);
return r;
}
-int i_i4 (int a, int b, int c, int d)
+int ABI_ATTR i_i4 (int a, int b, int c, int d)
{
int r=a+b+c+d;
fprintf(out,"int f(4*int):(%d,%d,%d,%d)",a,b,c,d);
fflush(out);
return r;
}
-int i_i8 (int a, int b, int c, int d, int e, int f, int g, int h)
+int ABI_ATTR i_i8 (int a, int b, int c, int d, int e, int f, int g, int h)
{
int r=a+b+c+d+e+f+g+h;
fprintf(out,"int f(8*int):(%d,%d,%d,%d,%d,%d,%d,%d)",a,b,c,d,e,f,g,h);
fflush(out);
return r;
}
-int i_i16 (int a, int b, int c, int d, int e, int f, int g, int h,
+int ABI_ATTR i_i16 (int a, int b, int c, int d, int e, int f, int g, int h,
int i, int j, int k, int l, int m, int n, int o, int p)
{
int r=a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p;
}
/* float tests */
-float f_f (float a)
+float ABI_ATTR f_f (float a)
{
float r=a+1.0f;
fprintf(out,"float f(float):(%g)",a);
fflush(out);
return r;
}
-float f_f2 (float a, float b)
+float ABI_ATTR f_f2 (float a, float b)
{
float r=a+b;
fprintf(out,"float f(2*float):(%g,%g)",a,b);
fflush(out);
return r;
}
-float f_f4 (float a, float b, float c, float d)
+float ABI_ATTR f_f4 (float a, float b, float c, float d)
{
float r=a+b+c+d;
fprintf(out,"float f(4*float):(%g,%g,%g,%g)",a,b,c,d);
fflush(out);
return r;
}
-float f_f8 (float a, float b, float c, float d, float e, float f,
+float ABI_ATTR f_f8 (float a, float b, float c, float d, float e, float f,
float g, float h)
{
float r=a+b+c+d+e+f+g+h;
fflush(out);
return r;
}
-float f_f16 (float a, float b, float c, float d, float e, float f, float g, float h,
+float ABI_ATTR f_f16 (float a, float b, float c, float d, float e, float f, float g, float h,
float i, float j, float k, float l, float m, float n, float o, float p)
{
float r=a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p;
fflush(out);
return r;
}
-float f_f24 (float a, float b, float c, float d, float e, float f, float g, float h,
+float ABI_ATTR f_f24 (float a, float b, float c, float d, float e, float f, float g, float h,
float i, float j, float k, float l, float m, float n, float o, float p,
float q, float s, float t, float u, float v, float w, float x, float y)
{
}
/* double tests */
-double d_d (double a)
+double ABI_ATTR d_d (double a)
{
double r=a+1.0;
fprintf(out,"double f(double):(%g)",a);
fflush(out);
return r;
}
-double d_d2 (double a, double b)
+double ABI_ATTR d_d2 (double a, double b)
{
double r=a+b;
fprintf(out,"double f(2*double):(%g,%g)",a,b);
fflush(out);
return r;
}
-double d_d4 (double a, double b, double c, double d)
+double ABI_ATTR d_d4 (double a, double b, double c, double d)
{
double r=a+b+c+d;
fprintf(out,"double f(4*double):(%g,%g,%g,%g)",a,b,c,d);
fflush(out);
return r;
}
-double d_d8 (double a, double b, double c, double d, double e, double f,
+double ABI_ATTR d_d8 (double a, double b, double c, double d, double e, double f,
double g, double h)
{
double r=a+b+c+d+e+f+g+h;
fflush(out);
return r;
}
-double d_d16 (double a, double b, double c, double d, double e, double f,
+double ABI_ATTR d_d16 (double a, double b, double c, double d, double e, double f,
double g, double h, double i, double j, double k, double l,
double m, double n, double o, double p)
{
}
/* pointer tests */
-void* vp_vpdpcpsp (void* a, double* b, char* c, Int* d)
+void* ABI_ATTR vp_vpdpcpsp (void* a, double* b, char* c, Int* d)
{
void* ret = (char*)b + 1;
fprintf(out,"void* f(void*,double*,char*,Int*):(0x%p,0x%p,0x%p,0x%p)",a,b,c,d);
}
/* mixed number tests */
-uchar uc_ucsil (uchar a, ushort b, uint c, ulong d)
+uchar ABI_ATTR uc_ucsil (uchar a, ushort b, uint c, ulong d)
{
uchar r = (uchar)-1;
fprintf(out,"uchar f(uchar,ushort,uint,ulong):(%u,%u,%u,%lu)",a,b,c,d);
fflush(out);
return r;
}
-double d_iidd (int a, int b, double c, double d)
+double ABI_ATTR d_iidd (int a, int b, double c, double d)
{
double r = a+b+c+d;
fprintf(out,"double f(int,int,double,double):(%d,%d,%g,%g)",a,b,c,d);
fflush(out);
return r;
}
-double d_iiidi (int a, int b, int c, double d, int e)
+double ABI_ATTR d_iiidi (int a, int b, int c, double d, int e)
{
double r = a+b+c+d+e;
fprintf(out,"double f(int,int,int,double,int):(%d,%d,%d,%g,%d)",a,b,c,d,e);
fflush(out);
return r;
}
-double d_idid (int a, double b, int c, double d)
+double ABI_ATTR d_idid (int a, double b, int c, double d)
{
double r = a+b+c+d;
fprintf(out,"double f(int,double,int,double):(%d,%g,%d,%g)",a,b,c,d);
fflush(out);
return r;
}
-double d_fdi (float a, double b, int c)
+double ABI_ATTR d_fdi (float a, double b, int c)
{
double r = a+b+c;
fprintf(out,"double f(float,double,int):(%g,%g,%d)",a,b,c);
fflush(out);
return r;
}
-ushort us_cdcd (char a, double b, char c, double d)
+ushort ABI_ATTR us_cdcd (char a, double b, char c, double d)
{
ushort r = (ushort)(a + b + c + d);
fprintf(out,"ushort f(char,double,char,double):('%c',%g,'%c',%g)",a,b,c,d);
return r;
}
-long long ll_iiilli (int a, int b, int c, long long d, int e)
+long long ABI_ATTR ll_iiilli (int a, int b, int c, long long d, int e)
{
long long r = (long long)(int)a+(long long)(int)b+(long long)(int)c+d+(long long)(int)e;
fprintf(out,"long long f(int,int,int,long long,int):(%d,%d,%d,0x%lx%08lx,%d)",a,b,c,(long)(d>>32),(long)(d&0xffffffff),e);
fflush(out);
return r;
}
-long long ll_flli (float a, long long b, int c)
+long long ABI_ATTR ll_flli (float a, long long b, int c)
{
long long r = (long long)(int)a + b + (long long)c;
fprintf(out,"long long f(float,long long,int):(%g,0x%lx%08lx,0x%lx)",a,(long)(b>>32),(long)(b&0xffffffff),(long)c);
return r;
}
-float f_fi (float a, int z)
+float ABI_ATTR f_fi (float a, int z)
{
float r = a+z;
fprintf(out,"float f(float,int):(%g,%d)",a,z);
fflush(out);
return r;
}
-float f_f2i (float a, float b, int z)
+float ABI_ATTR f_f2i (float a, float b, int z)
{
float r = a+b+z;
fprintf(out,"float f(2*float,int):(%g,%g,%d)",a,b,z);
fflush(out);
return r;
}
-float f_f3i (float a, float b, float c, int z)
+float ABI_ATTR f_f3i (float a, float b, float c, int z)
{
float r = a+b+c+z;
fprintf(out,"float f(3*float,int):(%g,%g,%g,%d)",a,b,c,z);
fflush(out);
return r;
}
-float f_f4i (float a, float b, float c, float d, int z)
+float ABI_ATTR f_f4i (float a, float b, float c, float d, int z)
{
float r = a+b+c+d+z;
fprintf(out,"float f(4*float,int):(%g,%g,%g,%g,%d)",a,b,c,d,z);
fflush(out);
return r;
}
-float f_f7i (float a, float b, float c, float d, float e, float f, float g,
+float ABI_ATTR f_f7i (float a, float b, float c, float d, float e, float f, float g,
int z)
{
float r = a+b+c+d+e+f+g+z;
fflush(out);
return r;
}
-float f_f8i (float a, float b, float c, float d, float e, float f, float g,
+float ABI_ATTR f_f8i (float a, float b, float c, float d, float e, float f, float g,
float h, int z)
{
float r = a+b+c+d+e+f+g+h+z;
fflush(out);
return r;
}
-float f_f12i (float a, float b, float c, float d, float e, float f, float g,
+float ABI_ATTR f_f12i (float a, float b, float c, float d, float e, float f, float g,
float h, float i, float j, float k, float l, int z)
{
float r = a+b+c+d+e+f+g+h+i+j+k+l+z;
fflush(out);
return r;
}
-float f_f13i (float a, float b, float c, float d, float e, float f, float g,
+float ABI_ATTR f_f13i (float a, float b, float c, float d, float e, float f, float g,
float h, float i, float j, float k, float l, float m, int z)
{
float r = a+b+c+d+e+f+g+h+i+j+k+l+m+z;
return r;
}
-double d_di (double a, int z)
+double ABI_ATTR d_di (double a, int z)
{
double r = a+z;
fprintf(out,"double f(double,int):(%g,%d)",a,z);
fflush(out);
return r;
}
-double d_d2i (double a, double b, int z)
+double ABI_ATTR d_d2i (double a, double b, int z)
{
double r = a+b+z;
fprintf(out,"double f(2*double,int):(%g,%g,%d)",a,b,z);
fflush(out);
return r;
}
-double d_d3i (double a, double b, double c, int z)
+double ABI_ATTR d_d3i (double a, double b, double c, int z)
{
double r = a+b+c+z;
fprintf(out,"double f(3*double,int):(%g,%g,%g,%d)",a,b,c,z);
fflush(out);
return r;
}
-double d_d4i (double a, double b, double c, double d, int z)
+double ABI_ATTR d_d4i (double a, double b, double c, double d, int z)
{
double r = a+b+c+d+z;
fprintf(out,"double f(4*double,int):(%g,%g,%g,%g,%d)",a,b,c,d,z);
fflush(out);
return r;
}
-double d_d7i (double a, double b, double c, double d, double e, double f,
+double ABI_ATTR d_d7i (double a, double b, double c, double d, double e, double f,
double g, int z)
{
double r = a+b+c+d+e+f+g+z;
fflush(out);
return r;
}
-double d_d8i (double a, double b, double c, double d, double e, double f,
+double ABI_ATTR d_d8i (double a, double b, double c, double d, double e, double f,
double g, double h, int z)
{
double r = a+b+c+d+e+f+g+h+z;
fflush(out);
return r;
}
-double d_d12i (double a, double b, double c, double d, double e, double f,
+double ABI_ATTR d_d12i (double a, double b, double c, double d, double e, double f,
double g, double h, double i, double j, double k, double l,
int z)
{
fflush(out);
return r;
}
-double d_d13i (double a, double b, double c, double d, double e, double f,
+double ABI_ATTR d_d13i (double a, double b, double c, double d, double e, double f,
double g, double h, double i, double j, double k, double l,
double m, int z)
{
}
/* small structure return tests */
-Size1 S1_v (void)
+Size1 ABI_ATTR S1_v (void)
{
fprintf(out,"Size1 f(void):");
fflush(out);
return Size1_1;
}
-Size2 S2_v (void)
+Size2 ABI_ATTR S2_v (void)
{
fprintf(out,"Size2 f(void):");
fflush(out);
return Size2_1;
}
-Size3 S3_v (void)
+Size3 ABI_ATTR S3_v (void)
{
fprintf(out,"Size3 f(void):");
fflush(out);
return Size3_1;
}
-Size4 S4_v (void)
+Size4 ABI_ATTR S4_v (void)
{
fprintf(out,"Size4 f(void):");
fflush(out);
return Size4_1;
}
-Size7 S7_v (void)
+Size7 ABI_ATTR S7_v (void)
{
fprintf(out,"Size7 f(void):");
fflush(out);
return Size7_1;
}
-Size8 S8_v (void)
+Size8 ABI_ATTR S8_v (void)
{
fprintf(out,"Size8 f(void):");
fflush(out);
return Size8_1;
}
-Size12 S12_v (void)
+Size12 ABI_ATTR S12_v (void)
{
fprintf(out,"Size12 f(void):");
fflush(out);
return Size12_1;
}
-Size15 S15_v (void)
+Size15 ABI_ATTR S15_v (void)
{
fprintf(out,"Size15 f(void):");
fflush(out);
return Size15_1;
}
-Size16 S16_v (void)
+Size16 ABI_ATTR S16_v (void)
{
fprintf(out,"Size16 f(void):");
fflush(out);
}
/* structure tests */
-Int I_III (Int a, Int b, Int c)
+Int ABI_ATTR I_III (Int a, Int b, Int c)
{
Int r;
r.x = a.x + b.x + c.x;
fflush(out);
return r;
}
-Char C_CdC (Char a, double b, Char c)
+Char ABI_ATTR C_CdC (Char a, double b, Char c)
{
Char r;
r.x = (a.x + c.x)/2;
fflush(out);
return r;
}
-Float F_Ffd (Float a, float b, double c)
+Float ABI_ATTR F_Ffd (Float a, float b, double c)
{
Float r;
r.x = (float) (a.x + b + c);
fflush(out);
return r;
}
-Double D_fDd (float a, Double b, double c)
+Double ABI_ATTR D_fDd (float a, Double b, double c)
{
Double r;
r.x = a + b.x + c;
fflush(out);
return r;
}
-Double D_Dfd (Double a, float b, double c)
+Double ABI_ATTR D_Dfd (Double a, float b, double c)
{
Double r;
r.x = a.x + b + c;
fflush(out);
return r;
}
-J J_JiJ (J a, int b, J c)
+J ABI_ATTR J_JiJ (J a, int b, J c)
{
J r;
r.l1 = a.l1+c.l1; r.l2 = a.l2+b+c.l2;
fflush(out);
return r;
}
-T T_TcT (T a, char b, T c)
+T ABI_ATTR T_TcT (T a, char b, T c)
{
T r;
r.c[0]='b'; r.c[1]=c.c[1]; r.c[2]=c.c[2];
fflush(out);
return r;
}
-X X_BcdB (B a, char b, double c, B d)
+X ABI_ATTR X_BcdB (B a, char b, double c, B d)
{
static X xr={"return val",'R'};
X r;
and partially on the stack. Different ABIs pass between 4 and 8 arguments
(or none) in general-purpose argument registers. */
-long l_l0K (K b, long c)
+long ABI_ATTR l_l0K (K b, long c)
{
long r = b.l1 + b.l2 + b.l3 + b.l4 + c;
fprintf(out,"long f(K,long):(%ld,%ld,%ld,%ld,%ld)",b.l1,b.l2,b.l3,b.l4,c);
fflush(out);
return r;
}
-long l_l1K (long a1, K b, long c)
+long ABI_ATTR l_l1K (long a1, K b, long c)
{
long r = a1 + b.l1 + b.l2 + b.l3 + b.l4 + c;
fprintf(out,"long f(long,K,long):(%ld,%ld,%ld,%ld,%ld,%ld)",a1,b.l1,b.l2,b.l3,b.l4,c);
fflush(out);
return r;
}
-long l_l2K (long a1, long a2, K b, long c)
+long ABI_ATTR l_l2K (long a1, long a2, K b, long c)
{
long r = a1 + a2 + b.l1 + b.l2 + b.l3 + b.l4 + c;
fprintf(out,"long f(2*long,K,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a1,a2,b.l1,b.l2,b.l3,b.l4,c);
fflush(out);
return r;
}
-long l_l3K (long a1, long a2, long a3, K b, long c)
+long ABI_ATTR l_l3K (long a1, long a2, long a3, K b, long c)
{
long r = a1 + a2 + a3 + b.l1 + b.l2 + b.l3 + b.l4 + c;
fprintf(out,"long f(3*long,K,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a1,a2,a3,b.l1,b.l2,b.l3,b.l4,c);
fflush(out);
return r;
}
-long l_l4K (long a1, long a2, long a3, long a4, K b, long c)
+long ABI_ATTR l_l4K (long a1, long a2, long a3, long a4, K b, long c)
{
long r = a1 + a2 + a3 + a4 + b.l1 + b.l2 + b.l3 + b.l4 + c;
fprintf(out,"long f(4*long,K,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a1,a2,a3,a4,b.l1,b.l2,b.l3,b.l4,c);
fflush(out);
return r;
}
-long l_l5K (long a1, long a2, long a3, long a4, long a5, K b, long c)
+long ABI_ATTR l_l5K (long a1, long a2, long a3, long a4, long a5, K b, long c)
{
long r = a1 + a2 + a3 + a4 + a5 + b.l1 + b.l2 + b.l3 + b.l4 + c;
fprintf(out,"long f(5*long,K,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a1,a2,a3,a4,a5,b.l1,b.l2,b.l3,b.l4,c);
fflush(out);
return r;
}
-long l_l6K (long a1, long a2, long a3, long a4, long a5, long a6, K b, long c)
+long ABI_ATTR l_l6K (long a1, long a2, long a3, long a4, long a5, long a6, K b, long c)
{
long r = a1 + a2 + a3 + a4 + a5 + a6 + b.l1 + b.l2 + b.l3 + b.l4 + c;
fprintf(out,"long f(6*long,K,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld,%ld)",a1,a2,a3,a4,a5,a6,b.l1,b.l2,b.l3,b.l4,c);
/* These tests is crafted on the knowledge that for all known ABIs:
* 17 > number of floating-point argument registers,
* 3 < number of general-purpose argument registers < 3 + 6. */
-float f_f17l3L (float a, float b, float c, float d, float e, float f, float g,
+float ABI_ATTR f_f17l3L (float a, float b, float c, float d, float e, float f, float g,
float h, float i, float j, float k, float l, float m, float n,
float o, float p, float q,
long s, long t, long u, L z)
fflush(out);
return r;
}
-double d_d17l3L (double a, double b, double c, double d, double e, double f,
+double ABI_ATTR d_d17l3L (double a, double b, double c, double d, double e, double f,
double g, double h, double i, double j, double k, double l,
double m, double n, double o, double p, double q,
long s, long t, long u, L z)
return r;
}
-long long ll_l2ll (long a1, long a2, long long b, long c)
+long long ABI_ATTR ll_l2ll (long a1, long a2, long long b, long c)
{
long long r = (long long) (a1 + a2) + b + c;
fprintf(out,"long long f(2*long,long long,long):(%ld,%ld,0x%lx%08lx,%ld)",a1,a2,(long)(b>>32),(long)(b&0xffffffff),c);
fflush(out);
return r;
}
-long long ll_l3ll (long a1, long a2, long a3, long long b, long c)
+long long ABI_ATTR ll_l3ll (long a1, long a2, long a3, long long b, long c)
{
long long r = (long long) (a1 + a2 + a3) + b + c;
fprintf(out,"long long f(3*long,long long,long):(%ld,%ld,%ld,0x%lx%08lx,%ld)",a1,a2,a3,(long)(b>>32),(long)(b&0xffffffff),c);
fflush(out);
return r;
}
-long long ll_l4ll (long a1, long a2, long a3, long a4, long long b, long c)
+long long ABI_ATTR ll_l4ll (long a1, long a2, long a3, long a4, long long b, long c)
{
long long r = (long long) (a1 + a2 + a3 + a4) + b + c;
fprintf(out,"long long f(4*long,long long,long):(%ld,%ld,%ld,%ld,0x%lx%08lx,%ld)",a1,a2,a3,a4,(long)(b>>32),(long)(b&0xffffffff),c);
fflush(out);
return r;
}
-long long ll_l5ll (long a1, long a2, long a3, long a4, long a5, long long b, long c)
+long long ABI_ATTR ll_l5ll (long a1, long a2, long a3, long a4, long a5, long long b, long c)
{
long long r = (long long) (a1 + a2 + a3 + a4 + a5) + b + c;
fprintf(out,"long long f(5*long,long long,long):(%ld,%ld,%ld,%ld,%ld,0x%lx%08lx,%ld)",a1,a2,a3,a4,a5,(long)(b>>32),(long)(b&0xffffffff),c);
fflush(out);
return r;
}
-long long ll_l6ll (long a1, long a2, long a3, long a4, long a5, long a6, long long b, long c)
+long long ABI_ATTR ll_l6ll (long a1, long a2, long a3, long a4, long a5, long a6, long long b, long c)
{
long long r = (long long) (a1 + a2 + a3 + a4 + a5 + a6) + b + c;
fprintf(out,"long long f(6*long,long long,long):(%ld,%ld,%ld,%ld,%ld,%ld,0x%lx%08lx,%ld)",a1,a2,a3,a4,a5,a6,(long)(b>>32),(long)(b&0xffffffff),c);
fflush(out);
return r;
}
-long long ll_l7ll (long a1, long a2, long a3, long a4, long a5, long a6, long a7, long long b, long c)
+long long ABI_ATTR ll_l7ll (long a1, long a2, long a3, long a4, long a5, long a6, long a7, long long b, long c)
{
long long r = (long long) (a1 + a2 + a3 + a4 + a5 + a6 + a7) + b + c;
fprintf(out,"long long f(7*long,long long,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld,0x%lx%08lx,%ld)",a1,a2,a3,a4,a5,a6,a7,(long)(b>>32),(long)(b&0xffffffff),c);
return r;
}
-double d_l2d (long a1, long a2, double b, long c)
+double ABI_ATTR d_l2d (long a1, long a2, double b, long c)
{
double r = (double) (a1 + a2) + b + c;
fprintf(out,"double f(2*long,double,long):(%ld,%ld,%g,%ld)",a1,a2,b,c);
fflush(out);
return r;
}
-double d_l3d (long a1, long a2, long a3, double b, long c)
+double ABI_ATTR d_l3d (long a1, long a2, long a3, double b, long c)
{
double r = (double) (a1 + a2 + a3) + b + c;
fprintf(out,"double f(3*long,double,long):(%ld,%ld,%ld,%g,%ld)",a1,a2,a3,b,c);
fflush(out);
return r;
}
-double d_l4d (long a1, long a2, long a3, long a4, double b, long c)
+double ABI_ATTR d_l4d (long a1, long a2, long a3, long a4, double b, long c)
{
double r = (double) (a1 + a2 + a3 + a4) + b + c;
fprintf(out,"double f(4*long,double,long):(%ld,%ld,%ld,%ld,%g,%ld)",a1,a2,a3,a4,b,c);
fflush(out);
return r;
}
-double d_l5d (long a1, long a2, long a3, long a4, long a5, double b, long c)
+double ABI_ATTR d_l5d (long a1, long a2, long a3, long a4, long a5, double b, long c)
{
double r = (double) (a1 + a2 + a3 + a4 + a5) + b + c;
fprintf(out,"double f(5*long,double,long):(%ld,%ld,%ld,%ld,%ld,%g,%ld)",a1,a2,a3,a4,a5,b,c);
fflush(out);
return r;
}
-double d_l6d (long a1, long a2, long a3, long a4, long a5, long a6, double b, long c)
+double ABI_ATTR d_l6d (long a1, long a2, long a3, long a4, long a5, long a6, double b, long c)
{
double r = (double) (a1 + a2 + a3 + a4 + a5 + a6) + b + c;
fprintf(out,"double f(6*long,double,long):(%ld,%ld,%ld,%ld,%ld,%ld,%g,%ld)",a1,a2,a3,a4,a5,a6,b,c);
fflush(out);
return r;
}
-double d_l7d (long a1, long a2, long a3, long a4, long a5, long a6, long a7, double b, long c)
+double ABI_ATTR d_l7d (long a1, long a2, long a3, long a4, long a5, long a6, long a7, double b, long c)
{
double r = (double) (a1 + a2 + a3 + a4 + a5 + a6 + a7) + b + c;
fprintf(out,"double f(7*long,double,long):(%ld,%ld,%ld,%ld,%ld,%ld,%ld,%g,%ld)",a1,a2,a3,a4,a5,a6,a7,b,c);