开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多国语言处理 > 信息检索与抽取 > 查看源码
tests.c
资源名称：swarm-2.2.tar.gz　[点击查看]
上传用户：shenzhenrh
上传日期：2013-05-12
资源大小：2904k
文件大小：21k
源码类别：

信息检索与抽取

开发平台：

Unix_Linux

tests.c：源码内容
  1. #ifndef _tests_c /*-*- C -*-*/
  2. #define _tests_c
  3. /**
  4.   Copyright 1993 Bill Triggs, <Bill.Triggs@inrialpes.fr>
  6.   This is free software distributed under the GNU General Public
  7.   Licence described in the file COPYING. Contact the author if
  8.   you don't have this or can't live with it. There is ABSOLUTELY
  9.   NO WARRANTY, explicit or implied, on this software.
  10. **/
  11. /*----------------------------------------------------------------------
  12.   Some test routines for avcall foreign function interface.
  13.   The coverage is entirely random, this just contains some of the things
  14.   that I think are likely to break.
  16.   We really need to add some more pointer (void* / char* / func*) tests
  17.   and some varargs ones, and also try to test structure alignment more
  18.   throughly.
  19.  ----------------------------------------------------------------------*/
  20. #include <stdio.h>
  21. #include <string.h>
  22. #include "avcall.h"
  23. FILE* out;
  25. /* NB since K&R C always passes chars and shorts as ints and floats as doubles,
  26.  * unprototyped ANSI-C functions must do the same, eg:
  27.  * - foo(x) float x; { ... } passes x as a double & converts it to a float internally.
  28.  * - foo(float x) { ... } passes x as a float.
  29.  */
  30. #if defined(__STDC__) || defined(__GNUC__) || defined(__cplusplus)
  31. #define _ ,
  32. #define _P(ARGS,TYPES) (TYPES)
  33. #else
  34. #define _ ;
  35. #define _P(ARGS,TYPES) ARGS TYPES;
  36. #endif
  38. #if defined(__hppa__) && defined(__GNUC__)
  39. #if (__GNUC__ == 2 && __GNUC_MINOR__ < 6)
  40. /* gcc-2.5.2 bugs prevent the T test from working. */
  41. #define SKIP_T
  42. #endif
  43. #endif
  44. #if defined(__m68k__) && defined(__GNUC__)
  45. /* "gcc-2.6.3 -freg-struct-return" returns  T = struct { char c[3]; }  (which
  46.  * has size 4 !) in memory, in contrast to  struct { char a,b,c; }  and
  47.  * struct { char c[4]; }  and  struct { char a,b,c,d; }  which have the same
  48.  * size and the same alignment but are returned in registers. I don't know why.
  49.  */
  50. #define SKIP_T
  51. #endif
  53. #if defined(AMIGA)
  54. /* We don't test passing arguments in registers yet.
  55.  * -1 means passing an argument in the stack instead of a register.
  56.  */
  57. #define AV_ARG_REGNUM -1
  58. #endif
  60. #define uchar unsigned char
  61. #define ushort unsigned short
  62. #define uint unsigned int
  63. #define ulong unsigned long
  65. typedef struct { char x; } Char;
  66. typedef struct { short x; } Short;
  67. typedef struct { int x; } Int;
  68. typedef struct { long x; } Long;
  69. typedef struct { float x; } Float;
  70. typedef struct { double x; } Double;
  71. typedef struct { char c; float f; } A;
  72. typedef struct { double d; int i[3]; } B;
  73. typedef struct { long l1; long l2; } J;
  74. typedef struct { char c[3]; } T;
  75. typedef struct { char c[33],c1; } X;
  77. char c1='a', c2=127, c3=(char)128, c4=(char)255, c5=-1;
  78. short s1=32767, s2=(short)32768, s3=3, s4=4, s5=5, s6=6, s7=7, s8=8, s9=9;
  79. int i1=1, i2=2, i3=3, i4=4, i5=5, i6=6, i7=7, i8=8, i9=9,
  80.     i10=11, i11=12, i12=13, i13=14, i14=15, i15=16, i16=17;
  81. long l1=1, l2=2, l3=3, l4=4, l5=5, l6=6, l7=7, l8=8, l9=9;
  82. #ifdef HAVE_LONGLONG
  83. long long ll1 = 3875056143130689530LL;
  84. #endif
  85. float f1=0.1, f2=0.2, f3=0.3, f4=0.4, f5=0.5, f6=0.6, f7=0.7, f8=0.8, f9=0.9,
  86.       f10=1.1, f11=1.2, f12=1.3, f13=1.4, f14=1.5, f15=1.6, f16=1.7;
  87. double d1=0.1, d2=0.2, d3=0.3, d4=0.4, d5=0.5, d6=0.6, d7=0.7, d8=0.8, d9=0.9,
  88.        d10=1.1, d11=1.2, d12=1.3, d13=1.4, d14=1.5, d15=1.6, d16=1.7;
  90. uchar uc1='a', uc2=127, uc3=128, uc4=255, uc5=-1;
  91. ushort us1=1, us2=2, us3=3, us4=4, us5=5, us6=6, us7=7, us8=8, us9=9;
  92. uint ui1=1, ui2=2, ui3=3, ui4=4, ui5=5, ui6=6, ui7=7, ui8=8, ui9=9;
  93. ulong ul1=1, ul2=2, ul3=3, ul4=4, ul5=5, ul6=6, ul7=7, ul8=8, ul9=9;
  95. char *str1="hello",str2[]="goodbye",*str3="still here?";
  96. Char C1={'A'}, C2={'B'}, C3={'C'}, C4={'377'}, C5={-1};
  97. Short S1={1}, S2={2}, S3={3}, S4={4}, S5={5}, S6={6}, S7={7}, S8={8}, S9={9};
  98. Int I1={1}, I2={2}, I3={3}, I4={4}, I5={5}, I6={6}, I7={7}, I8={8}, I9={9};
  99. Float F1={0.1}, F2={0.2}, F3={0.3}, F4={0.4}, F5={0.5}, F6={0.6}, F7={0.7}, F8={0.8}, F9={0.9};
  100. Double D1={0.1}, D2={0.2}, D3={0.3}, D4={0.4}, D5={0.5}, D6={0.6}, D7={0.7}, D8={0.8}, D9={0.9};
  102. A A1={'a',0.1},A2={'b',0.2},A3={'377',0.3};
  103. B B1={0.1,{1,2,3}},B2={0.2,{5,4,3}};
  104. J J1={47,11},J2={73,55};
  105. T T1={"the"},T2={"fox"};
  106. X X1={"abcdefghijklmnopqrstuvwxyzABCDEF",'G'}, X2={"123",'9'}, X3={"return-return-return",'R'};
  108. void v_v()
  109. {
  110.   fprintf(out,"void f(void):n");
  111.   fflush(out);
  112. }
  113. int i_v()
  114. {
  115.   int r=99;
  116.   fprintf(out,"int f(void):");
  117.   fflush(out);
  118.   return r;
  119. }
  120. int i_i _P((a), int a)
  121. {
  122.   int r=a+1;
  123.   fprintf(out,"int f(int):(%d)",a);
  124.   fflush(out);
  125.   return r;
  126. }
  127. int i_i2 _P((a,b), int a _ int b)
  128. {
  129.   int r=a+b;
  130.   fprintf(out,"int f(2*int):(%d,%d)",a,b);
  131.   fflush(out);
  132.   return r;
  133. }
  134. int i_i4 _P((a,b,c,d), int a _ int b _ int c _ int d)
  135. {
  136.   int r=a+b+c+d;
  137.   fprintf(out,"int f(4*int):(%d,%d,%d,%d)",a,b,c,d);
  138.   fflush(out);
  139.   return r;
  140. }
  141. int i_i8 _P((a,b,c,d,e,f,g,h),
  142.     int a _ int b _ int c _ int d _ int e _ int f _ int g _ int h)
  143. {
  144.   int r=a+b+c+d+e+f+g+h;
  145.   fprintf(out,"int f(8*int):(%d,%d,%d,%d,%d,%d,%d,%d)",a,b,c,d,e,f,g,h);
  146.   fflush(out);
  147.   return r;
  148. }
  149. int i_i16 _P((a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p),
  150.      int a _ int b _ int c _ int d _ int e _ int f _ int g _ int h
  151.      _ int i _ int j _ int k _ int l _ int m _ int n _ int o _ int p)
  152. {
  153.   int r=a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p;
  154.   fprintf(out,"int f(16*int):(%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d)",
  155.   a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p);
  156.   fflush(out);
  157.   return r;
  158. }
  160. float f_f _P((a), float a)
  161. {
  162.   float r=a+1.0;
  163.   fprintf(out,"float f(float):(%g)",a);
  164.   fflush(out);
  165.   return r;
  166. }
  167. float f_f2 _P((a,b), float a _ float b)
  168. {
  169.   float r=a+b;
  170.   fprintf(out,"float f(2*float):(%g,%g)",a,b);
  171.   fflush(out);
  172.   return r;
  173. }
  174. float f_f4 _P((a,b,c,d), float a _ float b _ float c _ float d)
  175. {
  176.   float r=a+b+c+d;
  177.   fprintf(out,"float f(4*float):(%g,%g,%g,%g)",a,b,c,d);
  178.   fflush(out);
  179.   return r;
  180. }
  181. float f_f8 _P((a,b,c,d,e,f,g,h), float a _ float b _ float c _ float d _ float e _ float f
  182.       _ float g _ float h)
  183. {
  184.   float r=a+b+c+d+e+f+g+h;
  185.   fprintf(out,"float f(8*float):(%g,%g,%g,%g,%g,%g,%g,%g)",a,b,c,d,e,f,g,h);
  186.   fflush(out);
  187.   return r;
  188. }
  189. float f_f16 _P((a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p),
  190.        float a _ float b _ float c _ float d _ float e _ float f _ float g _ float h
  191.        _ float i _ float j _ float k _ float l _ float m _ float n _ float o _ float p)
  192. {
  193.   float r=a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p;
  194.   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);
  195.   fflush(out);
  196.   return r;
  197. }
  199. double d_d _P((a), double a)
  200. {
  201.   double r=a+1.0;
  202.   fprintf(out,"double f(double):(%g)",a);
  203.   fflush(out);
  204.   return r;
  205. }
  206. double d_d2 _P((a,b), double a _ double b)
  207. {
  208.   double r=a+b;
  209.   fprintf(out,"double f(2*double):(%g,%g)",a,b);
  210.   fflush(out);
  211.   return r;
  212. }
  213. double d_d4 _P((a,b,c,d), double a _ double b _ double c _ double d)
  214. {
  215.   double r=a+b+c+d;
  216.   fprintf(out,"double f(4*double):(%g,%g,%g,%g)",a,b,c,d);
  217.   fflush(out);
  218.   return r;
  219. }
  220. double d_d8 _P((a,b,c,d,e,f,g,h),
  221.        double a _ double b _ double c _ double d _ double e _ double f
  222.        _ double g _ double h)
  223. {
  224.   double r=a+b+c+d+e+f+g+h;
  225.   fprintf(out,"double f(8*double):(%g,%g,%g,%g,%g,%g,%g,%g)",a,b,c,d,e,f,g,h);
  226.   fflush(out);
  227.   return r;
  228. }
  229. double d_d16 _P((a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p),
  230. double a _ double b _ double c _ double d _ double e _ double f
  231. _ double g _ double h _ double i _ double j _ double k _ double l
  232. _ double m _ double n _ double o _ double p)
  233. {
  234.   double r=a+b+c+d+e+f+g+h+i+j+k+l+m+n+o+p;
  235.   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);
  236.   fflush(out);
  237.   return r;
  238. }
  240. void* vp_vpdpcpsp _P((a,b,c,d), void* a _ double* b _ char* c _ Int* d)
  241. {
  242.   void* ret = (char*)b + 1;
  243.   fprintf(out,"void* f(void*,double*,char*,Int*):(0x%lx,0x%lx,0x%lx,0x%lx)",(long)a,(long)b,(long)c,(long)d);
  244.   fflush(out);
  245.   return ret;
  246. }
  248. uchar uc_ucsil _P((a,b,c,d), uchar a _ ushort b _ uint c _ ulong d)
  249. {
  250.   uchar r = -1;
  251.   fprintf(out,"uchar f(uchar,ushort,uint,ulong):(%u,%u,%u,%u)",a,b,c,d);
  252.   fflush(out);
  253.   return r;
  254. }
  256. double d_iidd _P((a,b,c,d), int a _ int b _ double c _ double d)
  257. {
  258.   double r = a+b+c+d;
  259.   fprintf(out,"double f(int,int,double,double):(%d,%d,%g,%g)",a,b,c,d);
  260.   fflush(out);
  261.   return r;
  262. }
  263. double d_idid _P((a,b,c,d), int a _ double b _ int c _ double d)
  264. {
  265.   double r = a+b+c+d;
  266.   fprintf(out,"double f(int,double,int,double):(%d,%g,%d,%g)",a,b,c,d);
  267.   fflush(out);
  268.   return r;
  269. }
  270. ushort us_cdcd _P((a,b,c,d), char a _ double b _ char c _ double d)
  271. {
  272.   ushort r = (ushort)(a + b + c + d);
  273.   fprintf(out,"ushort f(char,double,char,double):('%c',%g,'%c',%g)",a,b,c,d);
  274.   fflush(out);
  275.   return r;
  276. }
  278. #ifdef HAVE_LONGLONG
  279. long long ll_flli _P((a,b,c), float a _ long long b _ int c)
  280. {
  281.   long long r = (long long)(int)a + b + (long long)c;
  282.   fprintf(out,"long long f(float,long long,int):(%g,0x%lx%08lx,0x%lx)",a,(long)(b>>32),(long)(b&0xffffffff),(long)c);
  283.   fflush(out);
  284.   return r;
  285. }
  286. #endif
  288. Int I_III _P((a,b,c), Int a _ Int b _ Int c)
  289. {
  290.   Int r;
  291.   r.x = a.x + b.x + c.x;
  292.   fprintf(out,"Int f(Int,Int,Int):({%d},{%d},{%d})",a.x,b.x,c.x);
  293.   fflush(out);
  294.   return r;
  295. }
  296. #ifndef SKIP_EXTRA_STRUCTS
  297. Char C_CdC _P((a,b,c), Char a _ double b _ Char c)
  298. {
  299.   Char r;
  300.   r.x = (a.x + c.x)/2;
  301.   fprintf(out,"Char f(Char,double,Char):({'%c'},%g,{'%c'})",a.x,b,c.x);
  302.   fflush(out);
  303.   return r;
  304. }
  305. Float F_Ffd _P((a,b,c), Float a _ float b _ double c)
  306. {
  307.   Float r;
  308.   r.x = a.x + b + c;
  309.   fprintf(out,"Float f(Float,float,double):({%g},%g,%g)",a.x,b,c);
  310.   fflush(out);
  311.   return r;
  312. }
  313. Double D_fDd _P((a,b,c), float a _ Double b _ double c)
  314. {
  315.   Double r;
  316.   r.x = a + b.x + c;
  317.   fprintf(out,"Double f(float,Double,double):(%g,{%g},%g)",a,b.x,c);
  318.   fflush(out);
  319.   return r;
  320. }
  321. #endif
  322. J J_JiJ _P((a,b,c), J a _ int b _ J c)
  323. {
  324.   J r;
  325.   r.l1 = a.l1+c.l1; r.l2 = a.l2+b+c.l2;
  326.   fprintf(out,"J f(J,int,J):({%d,%d},%d,{%d,%d})",a.l1,a.l2,b,c.l1,c.l2);
  327.   fflush(out);
  328.   return r;
  329. }
  330. #ifndef SKIP_EXTRA_STRUCTS
  331. T T_TcT _P((a,b,c), T a _ char b _ T c)
  332. {
  333.   T r;
  334.   r.c[0]='b'; r.c[1]=c.c[1]; r.c[2]=c.c[2];
  335.   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]);
  336.   fflush(out);
  337.   return r;
  338. }
  339. X X_BcdB _P((a,b,c,d), B a _ char b _ double c _ B d)
  340. {
  341.   static X xr={"return val",'R'};
  342.   X r;
  343.   r = xr;
  344.   r.c1 = b;
  345.   fprintf(out,"X f(B,char,double,B):({%g,{%d,%d,%d}},'%c',%g,{%g,{%d,%d,%d}})",
  346.   a.d,a.i[0],a.i[1],a.i[2],b,c,d.d,d.i[0],d.i[1],d.i[2]);
  347.   fflush(out);
  348.   return r;
  349. }
  350. #endif
  352. /*
  353.  * The way we run these tests - first call the function directly, then
  354.  * through av_call() - there is the danger that arguments or results seem
  355.  * to be passed correctly, but what we are seeing are in fact the vestiges
  356.  * (traces) or the previous call. This may seriously fake the test.
  357.  * Avoid this by clearing the registers between the first and the second call.
  358.  */
  359. long clear_traces_i _P((a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p),
  360.   long a _ long b _ long c _ long d _ long e _ long f _ long g _ long h _
  361.   long i _ long j _ long k _ long l _ long m _ long n _ long o _ long p)
  362. { return 0; }
  363. float clear_traces_f _P((a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p),
  364.   float a _ float b _ float c _ float d _ float e _ float f _ float g _
  365.   float h _ float i _ float j _ float k _ float l _ float m _ float n _
  366.   float o _ float p)
  367. { return 0.0; }
  368. double clear_traces_d _P((a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p),
  369.   double a _ double b _ double c _ double d _ double e _ double f _ double g _
  370.   double h _ double i _ double j _ double k _ double l _ double m _ double n _
  371.   double o _ double p)
  372. { return 0.0; }
  373. J clear_traces_J ()
  374. { J j; j.l1 = j.l2 = 0; return j; }
  375. void clear_traces()
  376. { clear_traces_i(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);
  377.   clear_traces_f(0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0);
  378.   clear_traces_d(0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0);
  379.   clear_traces_J();
  380. }
  382. void
  383.   void_tests()
  384. {
  385.   av_alist a;
  386.   v_v();
  387.   clear_traces();
  388.   av_start_void(a,v_v);
  389.   av_call(a);
  390.   return;
  391. }
  392. void
  393.   int_tests()
  394. {
  395.   av_alist a;
  396.   int ir;
  398.   ir = i_v();
  399.   fprintf(out,"->%dn",ir);
  400.   fflush(out);
  401.   ir = 0; clear_traces();
  402.   av_start_int(a,i_v,&ir);
  403.   av_call(a);
  404.   fprintf(out,"->%dn",ir);
  405.   fflush(out);
  407.   ir = i_i(i1);
  408.   fprintf(out,"->%dn",ir);
  409.   fflush(out);
  410.   ir = 0; clear_traces();
  411.   av_start_int(a,i_i,&ir);
  412.   av_int(a,i1);
  413.   av_call(a);
  414.   fprintf(out,"->%dn",ir);
  415.   fflush(out);
  417.   ir = i_i2(i1,i2);
  418.   fprintf(out,"->%dn",ir);
  419.   fflush(out);
  420.   ir = 0; clear_traces();
  421.   av_start_int(a,i_i2,&ir);
  422.   av_int(a,i1);
  423.   av_int(a,i2);
  424.   av_call(a);
  425.   fprintf(out,"->%dn",ir);
  426.   fflush(out);
  428.   ir = i_i4(i1,i2,i3,i4);
  429.   fprintf(out,"->%dn",ir);
  430.   fflush(out);
  431.   ir = 0; clear_traces();
  432.   av_start_int(a,i_i4,&ir);
  433.   av_int(a,i1);
  434.   av_int(a,i2);
  435.   av_int(a,i3);
  436.   av_int(a,i4);
  437.   av_call(a);
  438.   fprintf(out,"->%dn",ir);
  439.   fflush(out);
  441.   ir = i_i8(i1,i2,i3,i4,i5,i6,i7,i8);
  442.   fprintf(out,"->%dn",ir);
  443.   fflush(out);
  444.   ir = 0; clear_traces();
  445.   av_start_int(a,i_i8,&ir);
  446.   av_int(a,i1);
  447.   av_int(a,i2);
  448.   av_int(a,i3);
  449.   av_int(a,i4);
  450.   av_int(a,i5);
  451.   av_int(a,i6);
  452.   av_int(a,i7);
  453.   av_int(a,i8);
  454.   av_call(a);
  455.   fprintf(out,"->%dn",ir);
  456.   fflush(out);
  458.   ir = i_i16(i1,i2,i3,i4,i5,i6,i7,i8,i9,i10,i11,i12,i13,i14,i15,i16);
  459.   fprintf(out,"->%dn",ir);
  460.   fflush(out);
  461.   ir = 0; clear_traces();
  462.   av_start_int(a,i_i16,&ir);
  463.   av_int(a,i1);
  464.   av_int(a,i2);
  465.   av_int(a,i3);
  466.   av_int(a,i4);
  467.   av_int(a,i5);
  468.   av_int(a,i6);
  469.   av_int(a,i7);
  470.   av_int(a,i8);
  471.   av_int(a,i9);
  472.   av_int(a,i10);
  473.   av_int(a,i11);
  474.   av_int(a,i12);
  475.   av_int(a,i13);
  476.   av_int(a,i14);
  477.   av_int(a,i15);
  478.   av_int(a,i16);
  479.   av_call(a);
  480.   fprintf(out,"->%dn",ir);
  481.   fflush(out);
  483.   return;
  484. }
  485. void
  486.   float_tests()
  487. {
  488.   av_alist a;
  489.   float fr;
  491.   fr = f_f(f1);
  492.   fprintf(out,"->%gn",fr);
  493.   fflush(out);
  494.   fr = 0.0; clear_traces();
  495.   av_start_float(a,f_f,&fr);
  496.   av_float(a,f1);
  497.   av_call(a);
  498.   fprintf(out,"->%gn",fr);
  499.   fflush(out);
  501.   fr = f_f2(f1,f2);
  502.   fprintf(out,"->%gn",fr);
  503.   fflush(out);
  504.   fr = 0.0; clear_traces();
  505.   av_start_float(a,f_f2,&fr);
  506.   av_float(a,f1);
  507.   av_float(a,f2);
  508.   av_call(a);
  509.   fprintf(out,"->%gn",fr);
  510.   fflush(out);
  512.   fr = f_f4(f1,f2,f3,f4);
  513.   fprintf(out,"->%gn",fr);
  514.   fflush(out);
  515.   fr = 0.0; clear_traces();
  516.   av_start_float(a,f_f4,&fr);
  517.   av_float(a,f1);
  518.   av_float(a,f2);
  519.   av_float(a,f3);
  520.   av_float(a,f4);
  521.   av_call(a);
  522.   fprintf(out,"->%gn",fr);
  523.   fflush(out);
  525.   fr = f_f8(f1,f2,f3,f4,f5,f6,f7,f8);
  526.   fprintf(out,"->%gn",fr);
  527.   fflush(out);
  528.   fr = 0.0; clear_traces();
  529.   av_start_float(a,f_f8,&fr);
  530.   av_float(a,f1);
  531.   av_float(a,f2);
  532.   av_float(a,f3);
  533.   av_float(a,f4);
  534.   av_float(a,f5);
  535.   av_float(a,f6);
  536.   av_float(a,f7);
  537.   av_float(a,f8);
  538.   av_call(a);
  539.   fprintf(out,"->%gn",fr);
  540.   fflush(out);
  542.   fr = f_f16(f1,f2,f3,f4,f5,f6,f7,f8,f9,f10,f11,f12,f13,f14,f15,f16);
  543.   fprintf(out,"->%gn",fr);
  544.   fflush(out);
  545.   fr = 0.0; clear_traces();
  546.   av_start_float(a,f_f16,&fr);
  547.   av_float(a,f1);
  548.   av_float(a,f2);
  549.   av_float(a,f3);
  550.   av_float(a,f4);
  551.   av_float(a,f5);
  552.   av_float(a,f6);
  553.   av_float(a,f7);
  554.   av_float(a,f8);
  555.   av_float(a,f9);
  556.   av_float(a,f10);
  557.   av_float(a,f11);
  558.   av_float(a,f12);
  559.   av_float(a,f13);
  560.   av_float(a,f14);
  561.   av_float(a,f15);
  562.   av_float(a,f16);
  563.   av_call(a);
  564.   fprintf(out,"->%gn",fr);
  565.   fflush(out);
  566. }
  567. void
  568.   double_tests()
  569. {
  570.   av_alist a;
  571.   double dr;
  573.   dr = d_d(d1);
  574.   fprintf(out,"->%gn",dr);
  575.   fflush(out);
  576.   dr = 0.0; clear_traces();
  577.   av_start_double(a,d_d,&dr);
  578.   av_double(a,d1);
  579.   av_call(a);
  580.   fprintf(out,"->%gn",dr);
  581.   fflush(out);
  583.   dr = d_d2(d1,d2);
  584.   fprintf(out,"->%gn",dr);
  585.   fflush(out);
  586.   dr = 0.0; clear_traces();
  587.   av_start_double(a,d_d2,&dr);
  588.   av_double(a,d1);
  589.   av_double(a,d2);
  590.   av_call(a);
  591.   fprintf(out,"->%gn",dr);
  592.   fflush(out);
  594.   dr = d_d4(d1,d2,d3,d4);
  595.   fprintf(out,"->%gn",dr);
  596.   fflush(out);
  597.   dr = 0.0; clear_traces();
  598.   av_start_double(a,d_d4,&dr);
  599.   av_double(a,d1);
  600.   av_double(a,d2);
  601.   av_double(a,d3);
  602.   av_double(a,d4);
  603.   av_call(a);
  604.   fprintf(out,"->%gn",dr);
  605.   fflush(out);
  607.   dr = d_d8(d1,d2,d3,d4,d5,d6,d7,d8);
  608.   fprintf(out,"->%gn",dr);
  609.   fflush(out);
  610.   dr = 0.0; clear_traces();
  611.   av_start_double(a,d_d8,&dr);
  612.   av_double(a,d1);
  613.   av_double(a,d2);
  614.   av_double(a,d3);
  615.   av_double(a,d4);
  616.   av_double(a,d5);
  617.   av_double(a,d6);
  618.   av_double(a,d7);
  619.   av_double(a,d8);
  620.   av_call(a);
  621.   fprintf(out,"->%gn",dr);
  622.   fflush(out);
  624.   dr = d_d16(d1,d2,d3,d4,d5,d6,d7,d8,d9,d10,d11,d12,d13,d14,d15,d16);
  625.   fprintf(out,"->%gn",dr);
  626.   fflush(out);
  627.   dr = 0.0; clear_traces();
  628.   av_start_double(a,d_d16,&dr);
  629.   av_double(a,d1);
  630.   av_double(a,d2);
  631.   av_double(a,d3);
  632.   av_double(a,d4);
  633.   av_double(a,d5);
  634.   av_double(a,d6);
  635.   av_double(a,d7);
  636.   av_double(a,d8);
  637.   av_double(a,d9);
  638.   av_double(a,d10);
  639.   av_double(a,d11);
  640.   av_double(a,d12);
  641.   av_double(a,d13);
  642.   av_double(a,d14);
  643.   av_double(a,d15);
  644.   av_double(a,d16);
  645.   av_call(a);
  646.   fprintf(out,"->%gn",dr);
  647.   fflush(out);
  649.   return;
  650. }
  651. void
  652.   mixed_number_tests()
  653. {
  654.   av_alist a;
  655.   uchar ucr;
  656.   ushort usr;
  657.   double dr;
  658. #ifdef HAVE_LONGLONG
  659.   long long llr;
  660. #endif
  662.   /* Unsigned types.
  663.    */
  664.   ucr = uc_ucsil(uc1,us2,ui3,ul4);
  665.   fprintf(out,"->%un",ucr);
  666.   fflush(out);
  667.   ucr = 0; clear_traces();
  668.   av_start_uchar(a,uc_ucsil,&ucr);
  669.   av_uchar(a,uc1);
  670.   av_ushort(a,us2);
  671.   av_uint(a,ui3);
  672.   av_ulong(a,ul4);
  673.   av_call(a);
  674.   fprintf(out,"->%un",ucr);
  675.   fflush(out);
  677.   /* Mixed int & float types.
  678.    */
  679.   dr = d_iidd(i1,i2,d3,d4);
  680.   fprintf(out,"->%gn",dr);
  681.   fflush(out);
  682.   dr = 0.0; clear_traces();
  683.   av_start_double(a,d_iidd,&dr);
  684.   av_int(a,i1);
  685.   av_int(a,i2);
  686.   av_double(a,d3);
  687.   av_double(a,d4);
  688.   av_call(a);
  689.   fprintf(out,"->%gn",dr);
  690.   fflush(out);
  692.   dr = d_idid(i1,d2,i3,d4);
  693.   fprintf(out,"->%gn",dr);
  694.   fflush(out);
  695.   dr = 0.0; clear_traces();
  696.   av_start_double(a,d_idid,&dr);
  697.   av_int(a,i1);
  698.   av_double(a,d2);
  699.   av_int(a,i3);
  700.   av_double(a,d4);
  701.   av_call(a);
  702.   fprintf(out,"->%gn",dr);
  703.   fflush(out);
  705.   usr = us_cdcd(c1,d2,c3,d4);
  706.   fprintf(out,"->%un",usr);
  707.   fflush(out);
  708.   usr = 0; clear_traces();
  709.   av_start_ushort(a,us_cdcd,&usr);
  710.   av_char(a,c1);
  711.   av_double(a,d2);
  712.   av_char(a,c3);
  713.   av_double(a,d4);
  714.   av_call(a);
  715.   fprintf(out,"->%un",usr);
  716.   fflush(out);
  718. #ifdef HAVE_LONGLONG
  719.   /* Long long types.
  720.    */
  721.   llr = ll_flli(f13,ll1,i13);
  722.   fprintf(out,"->0x%lx%08lxn",(long)(llr>>32),(long)(llr&0xffffffff));
  723.   fflush(out);
  724.   llr = 0; clear_traces();
  725.   av_start_longlong(a,ll_flli,&llr);
  726.   av_float(a,f13);
  727.   av_longlong(a,ll1);
  728.   av_int(a,i13);
  729.   av_call(a);
  730.   fprintf(out,"->0x%lx%08lxn",(long)(llr>>32),(long)(llr&0xffffffff));
  731.   fflush(out);
  732. #endif
  734.   return;
  735. }
  736. void
  737.   pointer_tests()
  738. {
  739.   av_alist a;
  740.   void* vpr;
  742.   vpr = vp_vpdpcpsp(&uc1,&d2,str3,&I4);
  743.   fprintf(out,"->0x%lxn",(long)vpr);
  744.   fflush(out);
  745.   vpr = 0; clear_traces();
  746.   av_start_ptr(a,vp_vpdpcpsp,void*,&vpr);
  747.   av_ptr(a,void*,&uc1);
  748.   av_ptr(a,double*,&d2);
  749.   av_ptr(a,char*,str3);
  750.   av_ptr(a,Int*,&I4);
  751.   av_call(a);
  752.   fprintf(out,"->0x%lxn",(long)vpr);
  753.   fflush(out);
  755.   return;
  756. }
  757. void
  758.   structure_tests()
  759. {
  760.   av_alist a;
  761.   Int Ir;
  762.   Char Cr;
  763.   Float Fr;
  764.   Double Dr;
  765.   J Jr;
  766.   T Tr;
  767.   X Xr;
  769.   Ir = I_III(I1,I2,I3);
  770.   fprintf(out,"->{%d}n",Ir.x);
  771.   fflush(out);
  772.   Ir.x = 0; clear_traces();
  773.   av_start_struct(a,I_III,Int,1,&Ir);
  774.   av_struct(a,Int,I1);
  775.   av_struct(a,Int,I2);
  776.   av_struct(a,Int,I3);
  777.   av_call(a);
  778.   fprintf(out,"->{%d}n",Ir.x);
  779.   fflush(out);
  781. #ifndef SKIP_EXTRA_STRUCTS
  782.   Cr = C_CdC(C1,d2,C3);
  783.   fprintf(out,"->{'%c'}n",Cr.x);
  784.   fflush(out);
  785.   Cr.x = ''; clear_traces();
  786.   av_start_struct(a,C_CdC,Char,1,&Cr);
  787.   av_struct(a,Char,C1);
  788.   av_double(a,d2);
  789.   av_struct(a,Char,C3);
  790.   av_call(a);
  791.   fprintf(out,"->{'%c'}n",Cr.x);
  792.   fflush(out);
  794. #if 0
  795.   Fr = F_Ffd(F1,f2,d3);
  796.   fprintf(out,"->{%g}n",Fr.x);
  797.   fflush(out);
  798.   Fr.x = 0.0; clear_traces();
  799.   av_start_struct(a,F_Ffd,Float,av_word_splittable_1(float),&Fr);
  800.   av_struct(a,Float,F1);
  801.   av_float(a,f2);
  802.   av_double(a,d3);
  803.   av_call(a);
  804.   fprintf(out,"->{%g}n",Fr.x);
  805.   fflush(out);
  806. #endif
  807.   
  808.   Dr = D_fDd(f1,D2,d3);
  809.   fprintf(out,"->{%g}n",Dr.x);
  810.   fflush(out);
  811.   Dr.x = 0.0; clear_traces();
  812.   av_start_struct(a,D_fDd,Double,av_word_splittable_1(double),&Dr);
  813.   av_float(a,f1);
  814.   av_struct(a,Double,D2);
  815.   av_double(a,d3);
  816.   av_call(a);
  817.   fprintf(out,"->{%g}n",Dr.x);
  818.   fflush(out);
  819. #endif
  821.   Jr = J_JiJ(J1,i2,J2);
  822.   fprintf(out,"->{%d,%d}n",Jr.l1,Jr.l2);
  823.   fflush(out);
  824.   Jr.l1 = Jr.l2 = 0; clear_traces();
  825.   av_start_struct(a,J_JiJ,J,av_word_splittable_2(long,long),&Jr);
  826.   av_struct(a,J,J1);
  827.   av_int(a,i2);
  828.   av_struct(a,J,J2);
  829.   av_call(a);
  830.   fprintf(out,"->{%d,%d}n",Jr.l1,Jr.l2);
  831.   fflush(out);
  833. #ifndef SKIP_EXTRA_STRUCTS
  834. #ifndef SKIP_T
  835.   Tr = T_TcT(T1,' ',T2);
  836.   fprintf(out,"->{"%c%c%c"}n",Tr.c[0],Tr.c[1],Tr.c[2]);
  837.   fflush(out);
  838.   Tr.c[0] = Tr.c[1] = Tr.c[2] = 0; clear_traces();
  839.   av_start_struct(a,T_TcT,T,1,&Tr);
  840.   av_struct(a,T,T1);
  841.   av_char(a,' ');
  842.   av_struct(a,T,T2);
  843.   av_call(a);
  844.   fprintf(out,"->{"%c%c%c"}n",Tr.c[0],Tr.c[1],Tr.c[2]);
  845.   fflush(out);
  846. #endif
  848.   Xr = X_BcdB(B1,c2,d3,B2);
  849.   fprintf(out,"->{"%s",'%c'}n",Xr.c,Xr.c1);
  850.   fflush(out);
  851.   Xr.c[0]=Xr.c1=''; clear_traces();
  852.   av_start_struct(a,X_BcdB,X,0,&Xr);
  853.   av_struct(a,B,B1);
  854.   av_char(a,c2);
  855.   av_double(a,d3);
  856.   av_struct(a,B,B2);
  857.   av_call(a);
  858.   fprintf(out,"->{"%s",'%c'}n",Xr.c,Xr.c1);
  859.   fflush(out);
  860. #endif
  862.   return;
  863. }
  864. int
  865.   main()
  866. {
  867.   out = stdout;
  868.   void_tests();
  869.   int_tests();
  870.   float_tests();
  871.   double_tests();
  872.   mixed_number_tests();
  873.   pointer_tests();
  874.   structure_tests();
  876.   exit(0);
  877. }
  879. #endif /*_tests_c */