[deliverable/binutils-gdb.git] / gdb / testsuite / gdb.base / callfuncs.c

/* Support program for testing gdb's ability to call functions
   in the inferior, pass appropriate arguments to those functions,
   and get the returned result. */

#ifdef NO_PROTOTYPES
#define PARAMS(paramlist) ()
#else
#define PARAMS(paramlist) paramlist
#endif

# include <stdlib.h>
# include <string.h>

char char_val1 = 'a';
char char_val2 = 'b';

short short_val1 = 10;
short short_val2 = -23;

int int_val1 = 87;
int int_val2 = -26;

long long_val1 = 789;
long long_val2 = -321;

float float_val1 = 3.14159;
float float_val2 = -2.3765;

double double_val1 = 45.654;
double double_val2 = -67.66;

#define DELTA (0.001)

char *string_val1 = (char *)"string 1";
char *string_val2 = (char *)"string 2";

char char_array_val1[] = "carray 1";
char char_array_val2[] = "carray 2";

struct struct1 {
  char c;
  short s;
  int i;
  long l;
  float f;
  double d;
  char a[4];
} struct_val1 = { 'x', 87, 76, 51, 2.1234, 9.876, "foo" };

/* Some functions that can be passed as arguments to other test
   functions, or called directly. */
#ifdef PROTOTYPES
int add (int a, int b)
#else
int add (a, b) int a, b;
#endif
{
  return (a + b);
}

#ifdef PROTOTYPES
int doubleit (int a)
#else
int doubleit (a) int a;
#endif
{
  return (a + a);
}

int (*func_val1) PARAMS((int,int)) = add;
int (*func_val2) PARAMS((int)) = doubleit;

/* An enumeration and functions that test for specific values. */

enum enumtype { enumval1, enumval2, enumval3 };
enum enumtype enum_val1 = enumval1;
enum enumtype enum_val2 = enumval2;
enum enumtype enum_val3 = enumval3;

#ifdef PROTOTYPES
int t_enum_value1 (enum enumtype enum_arg)
#else
int t_enum_value1 (enum_arg) enum enumtype enum_arg;
#endif
{
  return (enum_arg == enum_val1);
}

#ifdef PROTOTYPES
int t_enum_value2 (enum enumtype enum_arg)
#else
int t_enum_value2 (enum_arg) enum enumtype enum_arg;
#endif
{
  return (enum_arg == enum_val2);
}

#ifdef PROTOTYPES
int t_enum_value3 (enum enumtype enum_arg)
#else
int t_enum_value3 (enum_arg) enum enumtype enum_arg;
#endif
{
  return (enum_arg == enum_val3);
}

/* A function that takes a vector of integers (along with an explicit
   count) and returns their sum. */

#ifdef PROTOTYPES
int sum_args (int argc, int argv[])
#else
int sum_args (argc, argv) int argc; int argv[];
#endif
{
  int sumval = 0;
  int idx;

  for (idx = 0; idx < argc; idx++)
    {
      sumval += argv[idx];
    }
  return (sumval);
}

/* Test that we can call functions that take structs and return
   members from that struct */

#ifdef PROTOTYPES
char   t_structs_c (struct struct1 tstruct) { return (tstruct.c); }
short  t_structs_s (struct struct1 tstruct) { return (tstruct.s); }
int    t_structs_i (struct struct1 tstruct) { return (tstruct.i); }
long   t_structs_l (struct struct1 tstruct) { return (tstruct.l); }
float  t_structs_f (struct struct1 tstruct) { return (tstruct.f); }
double t_structs_d (struct struct1 tstruct) { return (tstruct.d); }
char  *t_structs_a (struct struct1 tstruct)
{
  static char buf[8];
  strcpy (buf, tstruct.a);
  return buf;
}
#else
char   t_structs_c (tstruct) struct struct1 tstruct; { return (tstruct.c); }
short  t_structs_s (tstruct) struct struct1 tstruct; { return (tstruct.s); }
int    t_structs_i (tstruct) struct struct1 tstruct; { return (tstruct.i); }
long   t_structs_l (tstruct) struct struct1 tstruct; { return (tstruct.l); }
float  t_structs_f (tstruct) struct struct1 tstruct; { return (tstruct.f); }
double t_structs_d (tstruct) struct struct1 tstruct; { return (tstruct.d); }
char  *t_structs_a (tstruct) struct struct1 tstruct;
{
  static char buf[8];
  strcpy (buf, tstruct.a);
  return buf;
}
#endif

/* Test that calling functions works if there are a lot of arguments.  */
#ifdef PROTOTYPES
int
sum10 (int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9)
#else
int
sum10 (i0, i1, i2, i3, i4, i5, i6, i7, i8, i9)
     int i0, i1, i2, i3, i4, i5, i6, i7, i8, i9;
#endif
{
  return i0 + i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8 + i9;
}

/* Test that args are passed in the right order. */
#ifdef PROTOTYPES
int
cmp10 (int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9)
#else
int
cmp10 (i0, i1, i2, i3, i4, i5, i6, i7, i8, i9)
  int i0, i1, i2, i3, i4, i5, i6, i7, i8, i9;
#endif
{
  return
    (i0 == 0) && (i1 == 1) && (i2 == 2) && (i3 == 3) && (i4 == 4) &&
    (i5 == 5) && (i6 == 6) && (i7 == 7) && (i8 == 8) && (i9 == 9);
}

/* Functions that expect specific values to be passed and return 
   either 0 or 1, depending upon whether the values were
   passed incorrectly or correctly, respectively. */

#ifdef PROTOTYPES
int t_char_values (char char_arg1, char char_arg2)
#else
int t_char_values (char_arg1, char_arg2)
char char_arg1, char_arg2;
#endif
{
  return ((char_arg1 == char_val1) && (char_arg2 == char_val2));
}

int
#ifdef PROTOTYPES
t_small_values (char arg1, short arg2, int arg3, char arg4, short arg5,
		char arg6, short arg7, int arg8, short arg9, short arg10)
#else
t_small_values (arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
     char arg1;
     short arg2;
     int arg3;
     char arg4;
     short arg5;
     char arg6;
     short arg7;
     int arg8;
     short arg9;
     short arg10;
#endif
{
  return arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10;
}

#ifdef PROTOTYPES
int t_short_values (short short_arg1, short short_arg2)
#else
int t_short_values (short_arg1, short_arg2)
     short short_arg1, short_arg2;
#endif
{
  return ((short_arg1 == short_val1) && (short_arg2 == short_val2));
}

#ifdef PROTOTYPES
int t_int_values (int int_arg1, int int_arg2)
#else
int t_int_values (int_arg1, int_arg2)
int int_arg1, int_arg2;
#endif
{
  return ((int_arg1 == int_val1) && (int_arg2 == int_val2));
}

#ifdef PROTOTYPES
int t_long_values (long long_arg1, long long_arg2)
#else
int t_long_values (long_arg1, long_arg2)
long long_arg1, long_arg2;
#endif
{
  return ((long_arg1 == long_val1) && (long_arg2 == long_val2));
}

/* NOTE: THIS FUNCTION MUST NOT BE PROTOTYPED!!!!!
   There must be one version of "t_float_values" (this one)
   that is not prototyped, and one (if supported) that is (following).
   That way GDB can be tested against both cases.  */
   
int t_float_values (float_arg1, float_arg2)
float float_arg1, float_arg2;
{
  return ((float_arg1 - float_val1) < DELTA
	  && (float_arg1 - float_val1) > -DELTA
	  && (float_arg2 - float_val2) < DELTA
	  && (float_arg2 - float_val2) > -DELTA);
}

int
#ifdef NO_PROTOTYPES
/* In this case we are just duplicating t_float_values, but that is the
   easiest way to deal with either ANSI or non-ANSI.  */
t_float_values2 (float_arg1, float_arg2)
     float float_arg1, float_arg2;
#else
t_float_values2 (float float_arg1, float float_arg2)
#endif
{
  return ((float_arg1 - float_val1) < DELTA
	  && (float_arg1 - float_val1) > -DELTA
	  && (float_arg2 - float_val2) < DELTA
	  && (float_arg2 - float_val2) > -DELTA);
}

#ifdef PROTOTYPES
int t_double_values (double double_arg1, double double_arg2)
#else
int t_double_values (double_arg1, double_arg2)
double double_arg1, double_arg2;
#endif
{
  return ((double_arg1 - double_val1) < DELTA
	  && (double_arg1 - double_val1) > -DELTA
	  && (double_arg2 - double_val2) < DELTA
	  && (double_arg2 - double_val2) > -DELTA);
}

#ifdef PROTOTYPES
int t_string_values (char *string_arg1, char *string_arg2)
#else
int t_string_values (string_arg1, string_arg2)
char *string_arg1, *string_arg2;
#endif
{
  return (!strcmp (string_arg1, string_val1) &&
	  !strcmp (string_arg2, string_val2));
}

#ifdef PROTOTYPES
int t_char_array_values (char char_array_arg1[], char char_array_arg2[])
#else
int t_char_array_values (char_array_arg1, char_array_arg2)
char char_array_arg1[], char_array_arg2[];
#endif
{
  return (!strcmp (char_array_arg1, char_array_val1) &&
	  !strcmp (char_array_arg2, char_array_val2));
}


/* This used to simply compare the function pointer arguments with
   known values for func_val1 and func_val2.  Doing so is valid ANSI
   code, but on some machines (RS6000, HPPA, others?) it may fail when
   called directly by GDB.

   In a nutshell, it's not possible for GDB to determine when the address
   of a function or the address of the function's stub/trampoline should
   be passed.

   So, to avoid GDB lossage in the common case, we perform calls through the
   various function pointers and compare the return values.  For the HPPA
   at least, this allows the common case to work.

   If one wants to try something more complicated, pass the address of
   a function accepting a "double" as one of its first 4 arguments.  Call
   that function indirectly through the function pointer.  This would fail
   on the HPPA.  */

#ifdef PROTOTYPES
int t_func_values (int (*func_arg1)(int, int), int (*func_arg2)(int))
#else
int t_func_values (func_arg1, func_arg2)
int (*func_arg1) PARAMS ((int, int));
int (*func_arg2) PARAMS ((int));
#endif
{
  return ((*func_arg1) (5,5)  == (*func_val1) (5,5)
          && (*func_arg2) (6) == (*func_val2) (6));
}

#ifdef PROTOTYPES
int t_call_add (int (*func_arg1)(int, int), int a, int b)
#else
int t_call_add (func_arg1, a, b)
int (*func_arg1) PARAMS ((int, int));
int a, b;
#endif
{
  return ((*func_arg1)(a, b));
}


/* Gotta have a main to be able to generate a linked, runnable
   executable, and also provide a useful place to set a breakpoint. */
extern void * malloc() ;
int main ()
{
#ifdef usestubs
  set_debug_traps();
  breakpoint();
#endif
  malloc(1);
  t_double_values(double_val1, double_val2);
  t_structs_c(struct_val1);
  return 0 ;
}
Commit	Line	Data
c906108c SS	1	/* Support program for testing gdb's ability to call functions
	2	in the inferior, pass appropriate arguments to those functions,
	3	and get the returned result. */
	4
	5	#ifdef NO_PROTOTYPES
	6	#define PARAMS(paramlist) ()
	7	#else
	8	#define PARAMS(paramlist) paramlist
	9	#endif
	10
085dd6e6 JM	11	# include <stdlib.h>
	12	# include <string.h>
	13
c906108c SS	14	char char_val1 = 'a';
	15	char char_val2 = 'b';
	16
	17	short short_val1 = 10;
	18	short short_val2 = -23;
	19
	20	int int_val1 = 87;
	21	int int_val2 = -26;
	22
	23	long long_val1 = 789;
	24	long long_val2 = -321;
	25
	26	float float_val1 = 3.14159;
	27	float float_val2 = -2.3765;
	28
	29	double double_val1 = 45.654;
	30	double double_val2 = -67.66;
	31
	32	#define DELTA (0.001)
	33
085dd6e6 JM	34	char string_val1 = (char )"string 1";
085dd6e6 JM	35	char string_val2 = (char )"string 2";
c906108c SS	36
	37	char char_array_val1[] = "carray 1";
	38	char char_array_val2[] = "carray 2";
	39
	40	struct struct1 {
	41	char c;
	42	short s;
	43	int i;
	44	long l;
	45	float f;
	46	double d;
	47	char a[4];
	48	} struct_val1 = { 'x', 87, 76, 51, 2.1234, 9.876, "foo" };
	49
	50	/* Some functions that can be passed as arguments to other test
	51	functions, or called directly. */
085dd6e6 JM	52	#ifdef PROTOTYPES
	53	int add (int a, int b)
	54	#else
	55	int add (a, b) int a, b;
	56	#endif
c906108c SS	57	{
	58	return (a + b);
	59	}
	60
085dd6e6 JM	61	#ifdef PROTOTYPES
	62	int doubleit (int a)
	63	#else
	64	int doubleit (a) int a;
	65	#endif
c906108c SS	66	{
	67	return (a + a);
	68	}
	69
	70	int (*func_val1) PARAMS((int,int)) = add;
	71	int (*func_val2) PARAMS((int)) = doubleit;
	72
	73	/* An enumeration and functions that test for specific values. */
	74
	75	enum enumtype { enumval1, enumval2, enumval3 };
	76	enum enumtype enum_val1 = enumval1;
	77	enum enumtype enum_val2 = enumval2;
	78	enum enumtype enum_val3 = enumval3;
	79
085dd6e6 JM	80	#ifdef PROTOTYPES
	81	int t_enum_value1 (enum enumtype enum_arg)
	82	#else
	83	int t_enum_value1 (enum_arg) enum enumtype enum_arg;
	84	#endif
c906108c SS	85	{
	86	return (enum_arg == enum_val1);
	87	}
	88
085dd6e6 JM	89	#ifdef PROTOTYPES
	90	int t_enum_value2 (enum enumtype enum_arg)
	91	#else
	92	int t_enum_value2 (enum_arg) enum enumtype enum_arg;
	93	#endif
c906108c SS	94	{
	95	return (enum_arg == enum_val2);
	96	}
	97
085dd6e6 JM	98	#ifdef PROTOTYPES
	99	int t_enum_value3 (enum enumtype enum_arg)
	100	#else
	101	int t_enum_value3 (enum_arg) enum enumtype enum_arg;
	102	#endif
c906108c SS	103	{
	104	return (enum_arg == enum_val3);
	105	}
	106
	107	/* A function that takes a vector of integers (along with an explicit
	108	count) and returns their sum. */
	109
085dd6e6 JM	110	#ifdef PROTOTYPES
	111	int sum_args (int argc, int argv[])
	112	#else
	113	int sum_args (argc, argv) int argc; int argv[];
	114	#endif
c906108c SS	115	{
	116	int sumval = 0;
	117	int idx;
	118
	119	for (idx = 0; idx < argc; idx++)
	120	{
	121	sumval += argv[idx];
	122	}
	123	return (sumval);
	124	}
	125
	126	/* Test that we can call functions that take structs and return
	127	members from that struct */
	128
085dd6e6 JM	129	#ifdef PROTOTYPES
	130	char t_structs_c (struct struct1 tstruct) { return (tstruct.c); }
	131	short t_structs_s (struct struct1 tstruct) { return (tstruct.s); }
	132	int t_structs_i (struct struct1 tstruct) { return (tstruct.i); }
	133	long t_structs_l (struct struct1 tstruct) { return (tstruct.l); }
	134	float t_structs_f (struct struct1 tstruct) { return (tstruct.f); }
	135	double t_structs_d (struct struct1 tstruct) { return (tstruct.d); }
184d0bc8 FN	136	char *t_structs_a (struct struct1 tstruct)
	137	{
	138	static char buf[8];
	139	strcpy (buf, tstruct.a);
	140	return buf;
	141	}
085dd6e6	142	#else
c906108c SS	143	char t_structs_c (tstruct) struct struct1 tstruct; { return (tstruct.c); }
	144	short t_structs_s (tstruct) struct struct1 tstruct; { return (tstruct.s); }
	145	int t_structs_i (tstruct) struct struct1 tstruct; { return (tstruct.i); }
	146	long t_structs_l (tstruct) struct struct1 tstruct; { return (tstruct.l); }
	147	float t_structs_f (tstruct) struct struct1 tstruct; { return (tstruct.f); }
	148	double t_structs_d (tstruct) struct struct1 tstruct; { return (tstruct.d); }
184d0bc8 FN	149	char *t_structs_a (tstruct) struct struct1 tstruct;
	150	{
	151	static char buf[8];
	152	strcpy (buf, tstruct.a);
	153	return buf;
	154	}
085dd6e6	155	#endif
c906108c SS	156
c906108c SS	157	/* Test that calling functions works if there are a lot of arguments. */
085dd6e6 JM	158	#ifdef PROTOTYPES
	159	int
	160	sum10 (int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9)
	161	#else
c906108c SS	162	int
	163	sum10 (i0, i1, i2, i3, i4, i5, i6, i7, i8, i9)
	164	int i0, i1, i2, i3, i4, i5, i6, i7, i8, i9;
085dd6e6	165	#endif
c906108c SS	166	{
	167	return i0 + i1 + i2 + i3 + i4 + i5 + i6 + i7 + i8 + i9;
	168	}
	169
	170	/* Test that args are passed in the right order. */
085dd6e6 JM	171	#ifdef PROTOTYPES
	172	int
	173	cmp10 (int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7, int i8, int i9)
	174	#else
c906108c SS	175	int
	176	cmp10 (i0, i1, i2, i3, i4, i5, i6, i7, i8, i9)
	177	int i0, i1, i2, i3, i4, i5, i6, i7, i8, i9;
085dd6e6	178	#endif
c906108c SS	179	{
	180	return
	181	(i0 == 0) && (i1 == 1) && (i2 == 2) && (i3 == 3) && (i4 == 4) &&
	182	(i5 == 5) && (i6 == 6) && (i7 == 7) && (i8 == 8) && (i9 == 9);
	183	}
	184
c906108c SS	185	/* Functions that expect specific values to be passed and return
	186	either 0 or 1, depending upon whether the values were
	187	passed incorrectly or correctly, respectively. */
	188
085dd6e6 JM	189	#ifdef PROTOTYPES
	190	int t_char_values (char char_arg1, char char_arg2)
	191	#else
c906108c SS	192	int t_char_values (char_arg1, char_arg2)
c906108c SS	193	char char_arg1, char_arg2;
085dd6e6	194	#endif
c906108c SS	195	{
	196	return ((char_arg1 == char_val1) && (char_arg2 == char_val2));
	197	}
	198
	199	int
085dd6e6 JM	200	#ifdef PROTOTYPES
	201	t_small_values (char arg1, short arg2, int arg3, char arg4, short arg5,
	202	char arg6, short arg7, int arg8, short arg9, short arg10)
	203	#else
c906108c SS	204	t_small_values (arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)
	205	char arg1;
	206	short arg2;
	207	int arg3;
	208	char arg4;
	209	short arg5;
	210	char arg6;
	211	short arg7;
	212	int arg8;
	213	short arg9;
	214	short arg10;
c906108c SS	215	#endif
	216	{
	217	return arg1 + arg2 + arg3 + arg4 + arg5 + arg6 + arg7 + arg8 + arg9 + arg10;
	218	}
	219
085dd6e6 JM	220	#ifdef PROTOTYPES
	221	int t_short_values (short short_arg1, short short_arg2)
	222	#else
c906108c	223	int t_short_values (short_arg1, short_arg2)
085dd6e6 JM	224	short short_arg1, short_arg2;
085dd6e6 JM	225	#endif
c906108c SS	226	{
	227	return ((short_arg1 == short_val1) && (short_arg2 == short_val2));
	228	}
	229
085dd6e6 JM	230	#ifdef PROTOTYPES
	231	int t_int_values (int int_arg1, int int_arg2)
	232	#else
c906108c SS	233	int t_int_values (int_arg1, int_arg2)
c906108c SS	234	int int_arg1, int_arg2;
085dd6e6	235	#endif
c906108c SS	236	{
	237	return ((int_arg1 == int_val1) && (int_arg2 == int_val2));
	238	}
	239
085dd6e6 JM	240	#ifdef PROTOTYPES
	241	int t_long_values (long long_arg1, long long_arg2)
	242	#else
c906108c SS	243	int t_long_values (long_arg1, long_arg2)
c906108c SS	244	long long_arg1, long_arg2;
085dd6e6	245	#endif
c906108c SS	246	{
	247	return ((long_arg1 == long_val1) && (long_arg2 == long_val2));
	248	}
	249
3bf40917 MS	250	/* NOTE: THIS FUNCTION MUST NOT BE PROTOTYPED!!!!!
	251	There must be one version of "t_float_values" (this one)
	252	that is not prototyped, and one (if supported) that is (following).
	253	That way GDB can be tested against both cases. */
	254
c906108c SS	255	int t_float_values (float_arg1, float_arg2)
	256	float float_arg1, float_arg2;
	257	{
	258	return ((float_arg1 - float_val1) < DELTA
	259	&& (float_arg1 - float_val1) > -DELTA
	260	&& (float_arg2 - float_val2) < DELTA
	261	&& (float_arg2 - float_val2) > -DELTA);
	262	}
	263
	264	int
3bf40917	265	#ifdef NO_PROTOTYPES
c906108c SS	266	/* In this case we are just duplicating t_float_values, but that is the
	267	easiest way to deal with either ANSI or non-ANSI. */
	268	t_float_values2 (float_arg1, float_arg2)
	269	float float_arg1, float_arg2;
3bf40917 MS	270	#else
3bf40917 MS	271	t_float_values2 (float float_arg1, float float_arg2)
c906108c SS	272	#endif
	273	{
	274	return ((float_arg1 - float_val1) < DELTA
	275	&& (float_arg1 - float_val1) > -DELTA
	276	&& (float_arg2 - float_val2) < DELTA
	277	&& (float_arg2 - float_val2) > -DELTA);
	278	}
	279
085dd6e6 JM	280	#ifdef PROTOTYPES
	281	int t_double_values (double double_arg1, double double_arg2)
	282	#else
c906108c SS	283	int t_double_values (double_arg1, double_arg2)
c906108c SS	284	double double_arg1, double_arg2;
085dd6e6	285	#endif
c906108c SS	286	{
	287	return ((double_arg1 - double_val1) < DELTA
	288	&& (double_arg1 - double_val1) > -DELTA
	289	&& (double_arg2 - double_val2) < DELTA
	290	&& (double_arg2 - double_val2) > -DELTA);
	291	}
	292
085dd6e6 JM	293	#ifdef PROTOTYPES
	294	int t_string_values (char string_arg1, char string_arg2)
	295	#else
c906108c SS	296	int t_string_values (string_arg1, string_arg2)
c906108c SS	297	char string_arg1, string_arg2;
085dd6e6	298	#endif
c906108c SS	299	{
	300	return (!strcmp (string_arg1, string_val1) &&
	301	!strcmp (string_arg2, string_val2));
	302	}
	303
085dd6e6 JM	304	#ifdef PROTOTYPES
	305	int t_char_array_values (char char_array_arg1[], char char_array_arg2[])
	306	#else
c906108c SS	307	int t_char_array_values (char_array_arg1, char_array_arg2)
c906108c SS	308	char char_array_arg1[], char_array_arg2[];
085dd6e6	309	#endif
c906108c SS	310	{
	311	return (!strcmp (char_array_arg1, char_array_val1) &&
	312	!strcmp (char_array_arg2, char_array_val2));
	313	}
	314
	315
	316	/* This used to simply compare the function pointer arguments with
	317	known values for func_val1 and func_val2. Doing so is valid ANSI
	318	code, but on some machines (RS6000, HPPA, others?) it may fail when
	319	called directly by GDB.
	320
	321	In a nutshell, it's not possible for GDB to determine when the address
	322	of a function or the address of the function's stub/trampoline should
	323	be passed.
	324
	325	So, to avoid GDB lossage in the common case, we perform calls through the
	326	various function pointers and compare the return values. For the HPPA
	327	at least, this allows the common case to work.
	328
	329	If one wants to try something more complicated, pass the address of
	330	a function accepting a "double" as one of its first 4 arguments. Call
	331	that function indirectly through the function pointer. This would fail
	332	on the HPPA. */
	333
085dd6e6 JM	334	#ifdef PROTOTYPES
	335	int t_func_values (int (func_arg1)(int, int), int (func_arg2)(int))
	336	#else
c906108c SS	337	int t_func_values (func_arg1, func_arg2)
	338	int (*func_arg1) PARAMS ((int, int));
	339	int (*func_arg2) PARAMS ((int));
085dd6e6	340	#endif
c906108c SS	341	{
	342	return ((func_arg1) (5,5) == (func_val1) (5,5)
	343	&& (func_arg2) (6) == (func_val2) (6));
	344	}
	345
085dd6e6 JM	346	#ifdef PROTOTYPES
	347	int t_call_add (int (*func_arg1)(int, int), int a, int b)
	348	#else
c906108c SS	349	int t_call_add (func_arg1, a, b)
	350	int (*func_arg1) PARAMS ((int, int));
	351	int a, b;
085dd6e6	352	#endif
c906108c SS	353	{
	354	return ((*func_arg1)(a, b));
	355	}
c7db355b PS	356
	357
	358	/* Gotta have a main to be able to generate a linked, runnable
	359	executable, and also provide a useful place to set a breakpoint. */
	360	extern void * malloc() ;
	361	int main ()
	362	{
	363	#ifdef usestubs
	364	set_debug_traps();
	365	breakpoint();
	366	#endif
	367	malloc(1);
	368	t_double_values(double_val1, double_val2);
	369	t_structs_c(struct_val1);
	370	return 0 ;
	371	}