in js/src/ctypes/libffi/testsuite/libffi.bhaible/test-callback.c [1255:2884]
int main (void)
{
void* callback_code;
void* callback_writable;
#define ALLOC_CALLBACK() \
callback_writable = ffi_closure_alloc(sizeof(ffi_closure),&callback_code); \
if (!callback_writable) abort()
#define PREP_CALLBACK(cif,simulator,data) \
if (ffi_prep_closure_loc(callback_writable,&(cif),simulator,data,callback_code) != FFI_OK) abort()
#define FREE_CALLBACK() \
ffi_closure_free(callback_writable)
ffi_type_char = (char)(-1) < 0 ? ffi_type_schar : ffi_type_uchar;
out = stdout;
#if (!defined(DGTEST)) || DGTEST == 1
/* void tests */
v_v();
clear_traces();
ALLOC_CALLBACK();
{
ffi_cif cif;
FFI_PREP_CIF_NOARGS(cif,ffi_type_void);
PREP_CALLBACK(cif,v_v_simulator,(void*)&v_v);
((void (ABI_ATTR *) (void)) callback_code) ();
}
FREE_CALLBACK();
#endif
/* int tests */
{ int ir;
#if (!defined(DGTEST)) || DGTEST == 2
ir = i_v();
fprintf(out,"->%d\n",ir);
fflush(out);
ir = 0; clear_traces();
ALLOC_CALLBACK();
{
ffi_cif cif;
FFI_PREP_CIF_NOARGS(cif,ffi_type_sint);
PREP_CALLBACK(cif,i_v_simulator,(void*)&i_v);
ir = ((int (ABI_ATTR *) (void)) callback_code) ();
}
FREE_CALLBACK();
fprintf(out,"->%d\n",ir);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 3
ir = i_i(i1);
fprintf(out,"->%d\n",ir);
fflush(out);
ir = 0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_sint };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_sint);
PREP_CALLBACK(cif,i_i_simulator,(void*)&i_i);
ir = ((int (ABI_ATTR *) (int)) callback_code) (i1);
}
FREE_CALLBACK();
fprintf(out,"->%d\n",ir);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 4
ir = i_i2(i1,i2);
fprintf(out,"->%d\n",ir);
fflush(out);
ir = 0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_sint, &ffi_type_sint };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_sint);
PREP_CALLBACK(cif,i_i2_simulator,(void*)&i_i2);
ir = ((int (ABI_ATTR *) (int,int)) callback_code) (i1,i2);
}
FREE_CALLBACK();
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);
fflush(out);
ir = 0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_sint);
PREP_CALLBACK(cif,i_i4_simulator,(void*)&i_i4);
ir = ((int (ABI_ATTR *) (int,int,int,int)) callback_code) (i1,i2,i3,i4);
}
FREE_CALLBACK();
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);
fflush(out);
ir = 0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_sint);
PREP_CALLBACK(cif,i_i8_simulator,(void*)&i_i8);
ir = ((int (ABI_ATTR *) (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);
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);
fflush(out);
ir = 0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_sint };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_sint);
PREP_CALLBACK(cif,i_i16_simulator,(void*)&i_i16);
ir = ((int (ABI_ATTR *) (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);
fflush(out);
#endif
}
/* float tests */
{ float fr;
#if (!defined(DGTEST)) || DGTEST == 8
fr = f_f(f1);
fprintf(out,"->%g\n",fr);
fflush(out);
fr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_float };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_float);
PREP_CALLBACK(cif,f_f_simulator,(void*)&f_f);
fr = ((float (ABI_ATTR *) (float)) callback_code) (f1);
}
FREE_CALLBACK();
fprintf(out,"->%g\n",fr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 9
fr = f_f2(f1,f2);
fprintf(out,"->%g\n",fr);
fflush(out);
fr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_float);
PREP_CALLBACK(cif,f_f2_simulator,(void*)&f_f2);
fr = ((float (ABI_ATTR *) (float,float)) callback_code) (f1,f2);
}
FREE_CALLBACK();
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);
fflush(out);
fr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_float);
PREP_CALLBACK(cif,f_f4_simulator,(void*)&f_f4);
fr = ((float (ABI_ATTR *) (float,float,float,float)) callback_code) (f1,f2,f3,f4);
}
FREE_CALLBACK();
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);
fflush(out);
fr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_float);
PREP_CALLBACK(cif,f_f8_simulator,(void*)&f_f8);
fr = ((float (ABI_ATTR *) (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);
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);
fflush(out);
fr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_float);
PREP_CALLBACK(cif,f_f16_simulator,(void*)&f_f16);
fr = ((float (ABI_ATTR *) (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);
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);
fflush(out);
fr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_float);
PREP_CALLBACK(cif,f_f24_simulator,(void*)&f_f24);
fr = ((float (ABI_ATTR *) (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);
fflush(out);
#endif
}
/* double tests */
{ double dr;
#if (!defined(DGTEST)) || DGTEST == 14
dr = d_d(d1);
fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_double };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_double);
PREP_CALLBACK(cif,d_d_simulator,(void*)&d_d);
dr = ((double (ABI_ATTR *) (double)) callback_code) (d1);
}
FREE_CALLBACK();
fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 15
dr = d_d2(d1,d2);
fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_double);
PREP_CALLBACK(cif,d_d2_simulator,(void*)&d_d2);
dr = ((double (ABI_ATTR *) (double,double)) callback_code) (d1,d2);
}
FREE_CALLBACK();
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);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_double);
PREP_CALLBACK(cif,d_d4_simulator,(void*)&d_d4);
dr = ((double (ABI_ATTR *) (double,double,double,double)) callback_code) (d1,d2,d3,d4);
}
FREE_CALLBACK();
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);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_double);
PREP_CALLBACK(cif,d_d8_simulator,(void*)&d_d8);
dr = ((double (ABI_ATTR *) (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);
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);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_double);
PREP_CALLBACK(cif,d_d16_simulator,(void*)&d_d16);
dr = ((double (ABI_ATTR *) (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);
fflush(out);
#endif
}
/* pointer tests */
{ void* vpr;
#if (!defined(DGTEST)) || DGTEST == 19
vpr = vp_vpdpcpsp(&uc1,&d2,str3,&I4);
fprintf(out,"->0x%p\n",vpr);
fflush(out);
vpr = 0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_pointer, &ffi_type_pointer, &ffi_type_pointer, &ffi_type_pointer };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_pointer);
PREP_CALLBACK(cif,vp_vpdpcpsp_simulator,(void*)&vp_vpdpcpsp);
vpr = ((void* (ABI_ATTR *) (void*,double*,char*,Int*)) callback_code) (&uc1,&d2,str3,&I4);
}
FREE_CALLBACK();
fprintf(out,"->0x%p\n",vpr);
fflush(out);
#endif
}
/* mixed number tests */
{ uchar ucr;
ushort usr;
float fr;
double dr;
long long llr;
#if (!defined(DGTEST)) || DGTEST == 20
ucr = uc_ucsil(uc1,us2,ui3,ul4);
fprintf(out,"->%u\n",ucr);
fflush(out);
ucr = 0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_uchar, &ffi_type_ushort, &ffi_type_uint, &ffi_type_ulong };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_uchar);
PREP_CALLBACK(cif,uc_ucsil_simulator,(void*)&uc_ucsil);
ucr = ((uchar (ABI_ATTR *) (uchar,ushort,uint,ulong)) callback_code) (uc1,us2,ui3,ul4);
}
FREE_CALLBACK();
fprintf(out,"->%u\n",ucr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 21
dr = d_iidd(i1,i2,d3,d4);
fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_sint, &ffi_type_sint, &ffi_type_double, &ffi_type_double };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_double);
PREP_CALLBACK(cif,d_iidd_simulator,(void*)&d_iidd);
dr = ((double (ABI_ATTR *) (int,int,double,double)) callback_code) (i1,i2,d3,d4);
}
FREE_CALLBACK();
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);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_double, &ffi_type_sint };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_double);
PREP_CALLBACK(cif,d_iiidi_simulator,(void*)&d_iiidi);
dr = ((double (ABI_ATTR *) (int,int,int,double,int)) callback_code) (i1,i2,i3,d4,i5);
}
FREE_CALLBACK();
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);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_sint, &ffi_type_double, &ffi_type_sint, &ffi_type_double };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_double);
PREP_CALLBACK(cif,d_idid_simulator,(void*)&d_idid);
dr = ((double (ABI_ATTR *) (int,double,int,double)) callback_code) (i1,d2,i3,d4);
}
FREE_CALLBACK();
fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 24
dr = d_fdi(f1,d2,i3);
fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_double, &ffi_type_sint };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_double);
PREP_CALLBACK(cif,d_fdi_simulator,(void*)&d_fdi);
dr = ((double (ABI_ATTR *) (float,double,int)) callback_code) (f1,d2,i3);
}
FREE_CALLBACK();
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);
fflush(out);
usr = 0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_char, &ffi_type_double, &ffi_type_char, &ffi_type_double };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_ushort);
PREP_CALLBACK(cif,us_cdcd_simulator,(void*)&us_cdcd);
usr = ((ushort (ABI_ATTR *) (char,double,char,double)) callback_code) (c1,d2,c3,d4);
}
FREE_CALLBACK();
fprintf(out,"->%u\n",usr);
fflush(out);
#endif
#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));
fflush(out);
llr = 0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_sint, &ffi_type_sint, &ffi_type_sint, &ffi_type_slonglong, &ffi_type_sint };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_slonglong);
PREP_CALLBACK(cif,ll_iiilli_simulator,(void*)&ll_iiilli);
llr = ((long long (ABI_ATTR *) (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));
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));
fflush(out);
llr = 0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_slonglong, &ffi_type_sint };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_slonglong);
PREP_CALLBACK(cif,ll_flli_simulator,(void*)&ll_flli);
llr = ((long long (ABI_ATTR *) (float,long long,int)) callback_code) (f13,ll1,i13);
}
FREE_CALLBACK();
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);
fflush(out);
fr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_sint };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_float);
PREP_CALLBACK(cif,f_fi_simulator,(void*)&f_fi);
fr = ((float (ABI_ATTR *) (float,int)) callback_code) (f1,i9);
}
FREE_CALLBACK();
fprintf(out,"->%g\n",fr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 29
fr = f_f2i(f1,f2,i9);
fprintf(out,"->%g\n",fr);
fflush(out);
fr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float, &ffi_type_sint };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_float);
PREP_CALLBACK(cif,f_f2i_simulator,(void*)&f_f2i);
fr = ((float (ABI_ATTR *) (float,float,int)) callback_code) (f1,f2,i9);
}
FREE_CALLBACK();
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);
fflush(out);
fr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_sint };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_float);
PREP_CALLBACK(cif,f_f3i_simulator,(void*)&f_f3i);
fr = ((float (ABI_ATTR *) (float,float,float,int)) callback_code) (f1,f2,f3,i9);
}
FREE_CALLBACK();
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);
fflush(out);
fr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_sint };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_float);
PREP_CALLBACK(cif,f_f4i_simulator,(void*)&f_f4i);
fr = ((float (ABI_ATTR *) (float,float,float,float,int)) callback_code) (f1,f2,f3,f4,i9);
}
FREE_CALLBACK();
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);
fflush(out);
fr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_sint };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_float);
PREP_CALLBACK(cif,f_f7i_simulator,(void*)&f_f7i);
fr = ((float (ABI_ATTR *) (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);
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);
fflush(out);
fr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_sint };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_float);
PREP_CALLBACK(cif,f_f8i_simulator,(void*)&f_f8i);
fr = ((float (ABI_ATTR *) (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);
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);
fflush(out);
fr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_sint };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_float);
PREP_CALLBACK(cif,f_f13i_simulator,(void*)&f_f13i);
fr = ((float (ABI_ATTR *) (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);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 35
dr = d_di(d1,i9);
fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_sint };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_double);
PREP_CALLBACK(cif,d_di_simulator,(void*)&d_di);
dr = ((double (ABI_ATTR *) (double,int)) callback_code) (d1,i9);
}
FREE_CALLBACK();
fprintf(out,"->%g\n",dr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 36
dr = d_d2i(d1,d2,i9);
fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double, &ffi_type_sint };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_double);
PREP_CALLBACK(cif,d_d2i_simulator,(void*)&d_d2i);
dr = ((double (ABI_ATTR *) (double,double,int)) callback_code) (d1,d2,i9);
}
FREE_CALLBACK();
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);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_sint };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_double);
PREP_CALLBACK(cif,d_d3i_simulator,(void*)&d_d3i);
dr = ((double (ABI_ATTR *) (double,double,double,int)) callback_code) (d1,d2,d3,i9);
}
FREE_CALLBACK();
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);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_sint };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_double);
PREP_CALLBACK(cif,d_d4i_simulator,(void*)&d_d4i);
dr = ((double (ABI_ATTR *) (double,double,double,double,int)) callback_code) (d1,d2,d3,d4,i9);
}
FREE_CALLBACK();
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);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_sint };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_double);
PREP_CALLBACK(cif,d_d7i_simulator,(void*)&d_d7i);
dr = ((double (ABI_ATTR *) (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);
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);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_sint };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_double);
PREP_CALLBACK(cif,d_d8i_simulator,(void*)&d_d8i);
dr = ((double (ABI_ATTR *) (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);
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);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_sint };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_double);
PREP_CALLBACK(cif,d_d12i_simulator,(void*)&d_d12i);
dr = ((double (ABI_ATTR *) (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);
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);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_sint };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_double);
PREP_CALLBACK(cif,d_d13i_simulator,(void*)&d_d13i);
dr = ((double (ABI_ATTR *) (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);
fflush(out);
#endif
}
/* small structure return tests */
#if (!defined(DGTEST)) || DGTEST == 43
{
Size1 r = S1_v();
fprintf(out,"->{%c}\n",r.x1);
fflush(out);
memset(&r,0,sizeof(r)); clear_traces();
ALLOC_CALLBACK();
{
ffi_type* ffi_type_Size1_elements[] = { &ffi_type_char, NULL };
ffi_type ffi_type_Size1;
ffi_type_Size1.type = FFI_TYPE_STRUCT;
ffi_type_Size1.size = sizeof(Size1);
ffi_type_Size1.alignment = alignof_slot(Size1);
ffi_type_Size1.elements = ffi_type_Size1_elements;
ffi_cif cif;
FFI_PREP_CIF_NOARGS(cif,ffi_type_Size1);
PREP_CALLBACK(cif,S1_v_simulator,(void*)&S1_v);
r = ((Size1 (ABI_ATTR *) (void)) callback_code) ();
}
FREE_CALLBACK();
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);
fflush(out);
memset(&r,0,sizeof(r)); clear_traces();
ALLOC_CALLBACK();
{
ffi_type* ffi_type_Size2_elements[] = { &ffi_type_char, &ffi_type_char, NULL };
ffi_type ffi_type_Size2;
ffi_type_Size2.type = FFI_TYPE_STRUCT;
ffi_type_Size2.size = sizeof(Size2);
ffi_type_Size2.alignment = alignof_slot(Size2);
ffi_type_Size2.elements = ffi_type_Size2_elements;
ffi_cif cif;
FFI_PREP_CIF_NOARGS(cif,ffi_type_Size2);
PREP_CALLBACK(cif,S2_v_simulator,(void*)&S2_v);
r = ((Size2 (ABI_ATTR *) (void)) callback_code) ();
}
FREE_CALLBACK();
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);
fflush(out);
memset(&r,0,sizeof(r)); clear_traces();
ALLOC_CALLBACK();
{
ffi_type* ffi_type_Size3_elements[] = { &ffi_type_char, &ffi_type_char, &ffi_type_char, NULL };
ffi_type ffi_type_Size3;
ffi_type_Size3.type = FFI_TYPE_STRUCT;
ffi_type_Size3.size = sizeof(Size3);
ffi_type_Size3.alignment = alignof_slot(Size3);
ffi_type_Size3.elements = ffi_type_Size3_elements;
ffi_cif cif;
FFI_PREP_CIF_NOARGS(cif,ffi_type_Size3);
PREP_CALLBACK(cif,S3_v_simulator,(void*)&S3_v);
r = ((Size3 (ABI_ATTR *) (void)) callback_code) ();
}
FREE_CALLBACK();
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);
fflush(out);
memset(&r,0,sizeof(r)); clear_traces();
ALLOC_CALLBACK();
{
ffi_type* ffi_type_Size4_elements[] = { &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, NULL };
ffi_type ffi_type_Size4;
ffi_type_Size4.type = FFI_TYPE_STRUCT;
ffi_type_Size4.size = sizeof(Size4);
ffi_type_Size4.alignment = alignof_slot(Size4);
ffi_type_Size4.elements = ffi_type_Size4_elements;
ffi_cif cif;
FFI_PREP_CIF_NOARGS(cif,ffi_type_Size4);
PREP_CALLBACK(cif,S4_v_simulator,(void*)&S4_v);
r = ((Size4 (ABI_ATTR *) (void)) callback_code) ();
}
FREE_CALLBACK();
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);
fflush(out);
memset(&r,0,sizeof(r)); clear_traces();
ALLOC_CALLBACK();
{
ffi_type* ffi_type_Size7_elements[] = { &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, NULL };
ffi_type ffi_type_Size7;
ffi_type_Size7.type = FFI_TYPE_STRUCT;
ffi_type_Size7.size = sizeof(Size7);
ffi_type_Size7.alignment = alignof_slot(Size7);
ffi_type_Size7.elements = ffi_type_Size7_elements;
ffi_cif cif;
FFI_PREP_CIF_NOARGS(cif,ffi_type_Size7);
PREP_CALLBACK(cif,S7_v_simulator,(void*)&S7_v);
r = ((Size7 (ABI_ATTR *) (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);
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);
fflush(out);
memset(&r,0,sizeof(r)); clear_traces();
ALLOC_CALLBACK();
{
ffi_type* ffi_type_Size8_elements[] = { &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, NULL };
ffi_type ffi_type_Size8;
ffi_type_Size8.type = FFI_TYPE_STRUCT;
ffi_type_Size8.size = sizeof(Size8);
ffi_type_Size8.alignment = alignof_slot(Size8);
ffi_type_Size8.elements = ffi_type_Size8_elements;
ffi_cif cif;
FFI_PREP_CIF_NOARGS(cif,ffi_type_Size8);
PREP_CALLBACK(cif,S8_v_simulator,(void*)&S8_v);
r = ((Size8 (ABI_ATTR *) (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);
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);
fflush(out);
memset(&r,0,sizeof(r)); clear_traces();
ALLOC_CALLBACK();
{
ffi_type* ffi_type_Size12_elements[] = { &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, NULL };
ffi_type ffi_type_Size12;
ffi_type_Size12.type = FFI_TYPE_STRUCT;
ffi_type_Size12.size = sizeof(Size12);
ffi_type_Size12.alignment = alignof_slot(Size12);
ffi_type_Size12.elements = ffi_type_Size12_elements;
ffi_cif cif;
FFI_PREP_CIF_NOARGS(cif,ffi_type_Size12);
PREP_CALLBACK(cif,S12_v_simulator,(void*)&S12_v);
r = ((Size12 (ABI_ATTR *) (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);
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);
fflush(out);
memset(&r,0,sizeof(r)); clear_traces();
ALLOC_CALLBACK();
{
ffi_type* ffi_type_Size15_elements[] = { &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, NULL };
ffi_type ffi_type_Size15;
ffi_type_Size15.type = FFI_TYPE_STRUCT;
ffi_type_Size15.size = sizeof(Size15);
ffi_type_Size15.alignment = alignof_slot(Size15);
ffi_type_Size15.elements = ffi_type_Size15_elements;
ffi_cif cif;
FFI_PREP_CIF_NOARGS(cif,ffi_type_Size15);
PREP_CALLBACK(cif,S15_v_simulator,(void*)&S15_v);
r = ((Size15 (ABI_ATTR *) (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);
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);
fflush(out);
memset(&r,0,sizeof(r)); clear_traces();
ALLOC_CALLBACK();
{
ffi_type* ffi_type_Size16_elements[] = { &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, &ffi_type_char, NULL };
ffi_type ffi_type_Size16;
ffi_type_Size16.type = FFI_TYPE_STRUCT;
ffi_type_Size16.size = sizeof(Size16);
ffi_type_Size16.alignment = alignof_slot(Size16);
ffi_type_Size16.elements = ffi_type_Size16_elements;
ffi_cif cif;
FFI_PREP_CIF_NOARGS(cif,ffi_type_Size16);
PREP_CALLBACK(cif,S16_v_simulator,(void*)&S16_v);
r = ((Size16 (ABI_ATTR *) (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);
fflush(out);
}
#endif
/* structure tests */
{ Int Ir;
Char Cr;
Float Fr;
Double Dr;
J Jr;
#ifndef SKIP_EXTRA_STRUCTS
T Tr;
X Xr;
#endif
#if (!defined(DGTEST)) || DGTEST == 52
Ir = I_III(I1,I2,I3);
fprintf(out,"->{%d}\n",Ir.x);
fflush(out);
Ir.x = 0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* ffi_type_Int_elements[] = { &ffi_type_sint, NULL };
ffi_type ffi_type_Int;
ffi_type_Int.type = FFI_TYPE_STRUCT;
ffi_type_Int.size = sizeof(Int);
ffi_type_Int.alignment = alignof_slot(Int);
ffi_type_Int.elements = ffi_type_Int_elements;
ffi_type* argtypes[] = { &ffi_type_Int, &ffi_type_Int, &ffi_type_Int };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_Int);
PREP_CALLBACK(cif,I_III_simulator,(void*)&I_III);
Ir = ((Int (ABI_ATTR *) (Int,Int,Int)) callback_code) (I1,I2,I3);
}
FREE_CALLBACK();
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);
fflush(out);
Cr.x = '\0'; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* ffi_type_Char_elements[] = { &ffi_type_char, NULL };
ffi_type ffi_type_Char;
ffi_type_Char.type = FFI_TYPE_STRUCT;
ffi_type_Char.size = sizeof(Char);
ffi_type_Char.alignment = alignof_slot(Char);
ffi_type_Char.elements = ffi_type_Char_elements;
ffi_type* argtypes[] = { &ffi_type_Char, &ffi_type_double, &ffi_type_Char };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_Char);
PREP_CALLBACK(cif,C_CdC_simulator,(void*)&C_CdC);
Cr = ((Char (ABI_ATTR *) (Char,double,Char)) callback_code) (C1,d2,C3);
}
FREE_CALLBACK();
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);
fflush(out);
Fr.x = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* ffi_type_Float_elements[] = { &ffi_type_float, NULL };
ffi_type ffi_type_Float;
ffi_type_Float.type = FFI_TYPE_STRUCT;
ffi_type_Float.size = sizeof(Float);
ffi_type_Float.alignment = alignof_slot(Float);
ffi_type_Float.elements = ffi_type_Float_elements;
ffi_type* argtypes[] = { &ffi_type_Float, &ffi_type_float, &ffi_type_double };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_Float);
PREP_CALLBACK(cif,F_Ffd_simulator,(void*)&F_Ffd);
Fr = ((Float (ABI_ATTR *) (Float,float,double)) callback_code) (F1,f2,d3);
}
FREE_CALLBACK();
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);
fflush(out);
Dr.x = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* ffi_type_Double_elements[] = { &ffi_type_double, NULL };
ffi_type ffi_type_Double;
ffi_type_Double.type = FFI_TYPE_STRUCT;
ffi_type_Double.size = sizeof(Double);
ffi_type_Double.alignment = alignof_slot(Double);
ffi_type_Double.elements = ffi_type_Double_elements;
ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_Double, &ffi_type_double };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_Double);
PREP_CALLBACK(cif,D_fDd_simulator,(void*)&D_fDd);
Dr = ((Double (ABI_ATTR *) (float,Double,double)) callback_code) (f1,D2,d3);
}
FREE_CALLBACK();
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);
fflush(out);
Dr.x = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* ffi_type_Double_elements[] = { &ffi_type_double, NULL };
ffi_type ffi_type_Double;
ffi_type_Double.type = FFI_TYPE_STRUCT;
ffi_type_Double.size = sizeof(Double);
ffi_type_Double.alignment = alignof_slot(Double);
ffi_type_Double.elements = ffi_type_Double_elements;
ffi_type* argtypes[] = { &ffi_type_Double, &ffi_type_float, &ffi_type_double };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_Double);
PREP_CALLBACK(cif,D_Dfd_simulator,(void*)&D_Dfd);
Dr = ((Double (ABI_ATTR *) (Double,float,double)) callback_code) (D1,f2,d3);
}
FREE_CALLBACK();
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);
fflush(out);
Jr.l1 = Jr.l2 = 0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* ffi_type_J_elements[] = { &ffi_type_slong, &ffi_type_slong, NULL };
ffi_type ffi_type_J;
ffi_type_J.type = FFI_TYPE_STRUCT;
ffi_type_J.size = sizeof(J);
ffi_type_J.alignment = alignof_slot(J);
ffi_type_J.elements = ffi_type_J_elements;
ffi_type* argtypes[] = { &ffi_type_J, &ffi_type_sint, &ffi_type_J };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_J);
PREP_CALLBACK(cif,J_JiJ_simulator,(void*)&J_JiJ);
Jr = ((J (ABI_ATTR *) (J,int,J)) callback_code) (J1,i2,J2);
}
FREE_CALLBACK();
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]);
fflush(out);
Tr.c[0] = Tr.c[1] = Tr.c[2] = 0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* ffi_type_T_elements[] = { ??, NULL };
ffi_type ffi_type_T;
ffi_type_T.type = FFI_TYPE_STRUCT;
ffi_type_T.size = sizeof(T);
ffi_type_T.alignment = alignof_slot(T);
ffi_type_T.elements = ffi_type_T_elements;
ffi_type* argtypes[] = { &ffi_type_T, &ffi_type_char, &ffi_type_T };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_T);
PREP_CALLBACK(cif,T_TcT_simulator,(void*)&T_TcT);
Tr = ((T (ABI_ATTR *) (T,char,T)) callback_code) (T1,' ',T2);
}
FREE_CALLBACK();
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);
fflush(out);
Xr.c[0]=Xr.c1='\0'; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* ffi_type_X_elements[] = { ??, NULL };
ffi_type ffi_type_X;
ffi_type_X.type = FFI_TYPE_STRUCT;
ffi_type_X.size = sizeof(X);
ffi_type_X.alignment = alignof_slot(X);
ffi_type_X.elements = ffi_type_X_elements;
ffi_type* argtypes[] = { &ffi_type_X, &ffi_type_char, &ffi_type_double, &ffi_type_X };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_X);
PREP_CALLBACK(cif,X_BcdB_simulator,(void*)&X_BcdB);
Xr = ((X (ABI_ATTR *) (B,char,double,B)) callback_code) (B1,c2,d3,B2);
}
FREE_CALLBACK();
fprintf(out,"->{\"%s\",'%c'}\n",Xr.c,Xr.c1);
fflush(out);
#endif
#endif
#endif
}
/* gpargs boundary tests */
{
ffi_type* ffi_type_K_elements[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, NULL };
ffi_type ffi_type_K;
ffi_type* ffi_type_L_elements[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, NULL };
ffi_type ffi_type_L;
long lr;
long long llr;
float fr;
double dr;
ffi_type_K.type = FFI_TYPE_STRUCT;
ffi_type_K.size = sizeof(K);
ffi_type_K.alignment = alignof_slot(K);
ffi_type_K.elements = ffi_type_K_elements;
ffi_type_L.type = FFI_TYPE_STRUCT;
ffi_type_L.size = sizeof(L);
ffi_type_L.alignment = alignof_slot(L);
ffi_type_L.elements = ffi_type_L_elements;
#if (!defined(DGTEST)) || DGTEST == 60
lr = l_l0K(K1,l9);
fprintf(out,"->%ld\n",lr);
fflush(out);
lr = 0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_K, &ffi_type_slong };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_slong);
PREP_CALLBACK(cif,l_l0K_simulator,(void*)l_l0K);
lr = ((long (ABI_ATTR *) (K,long)) callback_code) (K1,l9);
}
FREE_CALLBACK();
fprintf(out,"->%ld\n",lr);
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 61
lr = l_l1K(l1,K1,l9);
fprintf(out,"->%ld\n",lr);
fflush(out);
lr = 0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_K, &ffi_type_slong };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_slong);
PREP_CALLBACK(cif,l_l1K_simulator,(void*)l_l1K);
lr = ((long (ABI_ATTR *) (long,K,long)) callback_code) (l1,K1,l9);
}
FREE_CALLBACK();
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);
fflush(out);
lr = 0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_K, &ffi_type_slong };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_slong);
PREP_CALLBACK(cif,l_l2K_simulator,(void*)l_l2K);
lr = ((long (ABI_ATTR *) (long,long,K,long)) callback_code) (l1,l2,K1,l9);
}
FREE_CALLBACK();
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);
fflush(out);
lr = 0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_K, &ffi_type_slong };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_slong);
PREP_CALLBACK(cif,l_l3K_simulator,(void*)l_l3K);
lr = ((long (ABI_ATTR *) (long,long,long,K,long)) callback_code) (l1,l2,l3,K1,l9);
}
FREE_CALLBACK();
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);
fflush(out);
lr = 0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_K, &ffi_type_slong };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_slong);
PREP_CALLBACK(cif,l_l4K_simulator,(void*)l_l4K);
lr = ((long (ABI_ATTR *) (long,long,long,long,K,long)) callback_code) (l1,l2,l3,l4,K1,l9);
}
FREE_CALLBACK();
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);
fflush(out);
lr = 0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_K, &ffi_type_slong };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_slong);
PREP_CALLBACK(cif,l_l5K_simulator,(void*)l_l5K);
lr = ((long (ABI_ATTR *) (long,long,long,long,long,K,long)) callback_code) (l1,l2,l3,l4,l5,K1,l9);
}
FREE_CALLBACK();
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);
fflush(out);
lr = 0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_K, &ffi_type_slong };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_slong);
PREP_CALLBACK(cif,l_l6K_simulator,(void*)l_l6K);
lr = ((long (ABI_ATTR *) (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);
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);
fflush(out);
fr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_float, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_L };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_float);
PREP_CALLBACK(cif,f_f17l3L_simulator,(void*)&f_f17l3L);
fr = ((float (ABI_ATTR *) (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);
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);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_double, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_L };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_double);
PREP_CALLBACK(cif,d_d17l3L_simulator,(void*)&d_d17l3L);
dr = ((double (ABI_ATTR *) (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);
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));
fflush(out);
llr = 0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slonglong, &ffi_type_slong };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_slonglong);
PREP_CALLBACK(cif,ll_l2ll_simulator,(void*)ll_l2ll);
llr = ((long long (ABI_ATTR *) (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));
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));
fflush(out);
llr = 0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slonglong, &ffi_type_slong };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_slonglong);
PREP_CALLBACK(cif,ll_l3ll_simulator,(void*)ll_l3ll);
llr = ((long long (ABI_ATTR *) (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));
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));
fflush(out);
llr = 0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slonglong, &ffi_type_slong };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_slonglong);
PREP_CALLBACK(cif,ll_l4ll_simulator,(void*)ll_l4ll);
llr = ((long long (ABI_ATTR *) (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));
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));
fflush(out);
llr = 0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slonglong, &ffi_type_slong };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_slonglong);
PREP_CALLBACK(cif,ll_l5ll_simulator,(void*)ll_l5ll);
llr = ((long long (ABI_ATTR *) (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));
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));
fflush(out);
llr = 0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slonglong, &ffi_type_slong };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_slonglong);
PREP_CALLBACK(cif,ll_l6ll_simulator,(void*)ll_l6ll);
llr = ((long long (ABI_ATTR *) (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));
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));
fflush(out);
llr = 0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slonglong, &ffi_type_slong };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_slonglong);
PREP_CALLBACK(cif,ll_l7ll_simulator,(void*)ll_l7ll);
llr = ((long long (ABI_ATTR *) (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));
fflush(out);
#endif
#if (!defined(DGTEST)) || DGTEST == 75
dr = d_l2d(l1,l2,ll1,l9);
fprintf(out,"->%g\n",dr);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_double, &ffi_type_slong };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_double);
PREP_CALLBACK(cif,d_l2d_simulator,(void*)d_l2d);
dr = ((double (ABI_ATTR *) (long,long,double,long)) callback_code) (l1,l2,ll1,l9);
}
FREE_CALLBACK();
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);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_double, &ffi_type_slong };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_double);
PREP_CALLBACK(cif,d_l3d_simulator,(void*)d_l3d);
dr = ((double (ABI_ATTR *) (long,long,long,double,long)) callback_code) (l1,l2,l3,ll1,l9);
}
FREE_CALLBACK();
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);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_double, &ffi_type_slong };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_double);
PREP_CALLBACK(cif,d_l4d_simulator,(void*)d_l4d);
dr = ((double (ABI_ATTR *) (long,long,long,long,double,long)) callback_code) (l1,l2,l3,l4,ll1,l9);
}
FREE_CALLBACK();
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);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_double, &ffi_type_slong };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_double);
PREP_CALLBACK(cif,d_l5d_simulator,(void*)d_l5d);
dr = ((double (ABI_ATTR *) (long,long,long,long,long,double,long)) callback_code) (l1,l2,l3,l4,l5,ll1,l9);
}
FREE_CALLBACK();
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);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_double, &ffi_type_slong };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_double);
PREP_CALLBACK(cif,d_l6d_simulator,(void*)d_l6d);
dr = ((double (ABI_ATTR *) (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);
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);
fflush(out);
dr = 0.0; clear_traces();
ALLOC_CALLBACK();
{
ffi_type* argtypes[] = { &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_slong, &ffi_type_double, &ffi_type_slong };
ffi_cif cif;
FFI_PREP_CIF(cif,argtypes,ffi_type_double);
PREP_CALLBACK(cif,d_l7d_simulator,(void*)d_l7d);
dr = ((double (ABI_ATTR *) (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);
fflush(out);
#endif
}
exit(0);
}