[PATCH 15/16] GDB testsuite: drop non-prototype C function header variants

Andreas Arnez
2014-10-29T16:04:35Z

Remove many old-style function header variants in C source files of
the GDB test suite, using the 'unifdef' tool with '-DPROTOTYPES=1'.

gdb/testsuite/ChangeLog:

* gdb.base/annota1.c: Remove #ifdef PROTOTYPES, keep prototyped
variant.
* gdb.base/annota3.c: Likewise.
* gdb.base/async.c: Likewise.
* gdb.base/average.c: Likewise.
* gdb.base/call-ar-st.c: Likewise.
* gdb.base/call-rt-st.c: Likewise.
* gdb.base/call-sc.c: Likewise.
* gdb.base/call-strs.c: Likewise.
* gdb.base/callfuncs.c: Likewise.
* gdb.base/ending-run.c: Likewise.
* gdb.base/execd-prog.c: Likewise.
* gdb.base/exprs.c: Likewise.
* gdb.base/foll-exec.c: Likewise.
* gdb.base/foll-fork.c: Likewise.
* gdb.base/foll-vfork.c: Likewise.
* gdb.base/funcargs.c: Likewise.
* gdb.base/gcore.c: Likewise.
* gdb.base/jump.c: Likewise.
* gdb.base/langs0.c: Likewise.
* gdb.base/langs1.c: Likewise.
* gdb.base/langs2.c: Likewise.
* gdb.base/mips_pro.c: Likewise.
* gdb.base/nodebug.c: Likewise.
* gdb.base/opaque0.c: Likewise.
* gdb.base/opaque1.c: Likewise.
* gdb.base/recurse.c: Likewise.
* gdb.base/run.c: Likewise.
* gdb.base/scope0.c: Likewise.
* gdb.base/scope1.c: Likewise.
* gdb.base/setshow.c: Likewise.
* gdb.base/setvar.c: Likewise.
* gdb.base/shmain.c: Likewise.
* gdb.base/shr1.c: Likewise.
* gdb.base/shr2.c: Likewise.
* gdb.base/sigall.c: Likewise.
* gdb.base/signals.c: Likewise.
* gdb.base/so-indr-cl.c: Likewise.
* gdb.base/solib2.c: Likewise.
* gdb.base/structs.c: Likewise.
* gdb.base/sum.c: Likewise.
* gdb.base/vforked-prog.c: Likewise.
* gdb.base/watchpoint.c: Likewise.
* gdb.reverse/shr2.c: Likewise.
* gdb.reverse/until-reverse.c: Likewise.
* gdb.reverse/ur1.c: Likewise.
* gdb.reverse/watch-reverse.c: Likewise.
---
gdb/testsuite/gdb.base/annota1.c | 13 -
gdb/testsuite/gdb.base/annota3.c | 13 -
gdb/testsuite/gdb.base/async.c | 15 --
gdb/testsuite/gdb.base/average.c | 13 -
gdb/testsuite/gdb.base/call-ar-st.c | 278 -------------------
gdb/testsuite/gdb.base/call-rt-st.c | 151 -----------
gdb/testsuite/gdb.base/call-sc.c | 5 -
gdb/testsuite/gdb.base/call-strs.c | 22 --
gdb/testsuite/gdb.base/callfuncs.c | 129 ---------
gdb/testsuite/gdb.base/ending-run.c | 5 -
gdb/testsuite/gdb.base/execd-prog.c | 6 -
gdb/testsuite/gdb.base/exprs.c | 7 -
gdb/testsuite/gdb.base/foll-exec.c | 4 -
gdb/testsuite/gdb.base/foll-fork.c | 9 -
gdb/testsuite/gdb.base/foll-vfork.c | 4 -
gdb/testsuite/gdb.base/funcargs.c | 334 -----------------------
gdb/testsuite/gdb.base/gcore.c | 5 -
gdb/testsuite/gdb.base/jump.c | 5 -
gdb/testsuite/gdb.base/langs0.c | 6 -
gdb/testsuite/gdb.base/langs1.c | 8 -
gdb/testsuite/gdb.base/langs2.c | 17 --
gdb/testsuite/gdb.base/mips_pro.c | 25 --
gdb/testsuite/gdb.base/nodebug.c | 32 ---
gdb/testsuite/gdb.base/opaque0.c | 2 -
gdb/testsuite/gdb.base/opaque1.c | 5 -
gdb/testsuite/gdb.base/recurse.c | 6 -
gdb/testsuite/gdb.base/run.c | 11 -
gdb/testsuite/gdb.base/scope0.c | 29 --
gdb/testsuite/gdb.base/scope1.c | 4 -
gdb/testsuite/gdb.base/setshow.c | 7 -
gdb/testsuite/gdb.base/setvar.c | 7 -
gdb/testsuite/gdb.base/shmain.c | 10 -
gdb/testsuite/gdb.base/shr1.c | 20 --
gdb/testsuite/gdb.base/shr2.c | 8 -
gdb/testsuite/gdb.base/sigall.c | 426 ------------------------------
gdb/testsuite/gdb.base/signals.c | 6 -
gdb/testsuite/gdb.base/so-indr-cl.c | 8 -
gdb/testsuite/gdb.base/solib2.c | 5 -
gdb/testsuite/gdb.base/structs.c | 90 -------
gdb/testsuite/gdb.base/sum.c | 5 -
gdb/testsuite/gdb.base/vforked-prog.c | 4 -
gdb/testsuite/gdb.base/watchpoint.c | 4 -
gdb/testsuite/gdb.reverse/shr2.c | 8 -
gdb/testsuite/gdb.reverse/until-reverse.c | 29 --
gdb/testsuite/gdb.reverse/ur1.c | 7 -
gdb/testsuite/gdb.reverse/watch-reverse.c | 4 -
46 files changed, 1811 deletions(-)

diff --git a/gdb/testsuite/gdb.base/annota1.c b/gdb/testsuite/gdb.base/annota1.c
index 239ea16..424e1b8 100644
--- a/gdb/testsuite/gdb.base/annota1.c
+++ b/gdb/testsuite/gdb.base/annota1.c
@@ -2,28 +2,15 @@
#include <signal.h>

-#ifdef PROTOTYPES
void
handle_USR1 (int sig)
{
}
-#else
-void
-handle_USR1 (sig)
- int sig;
-{
-}
-#endif

int value;

-#ifdef PROTOTYPES
int
main (void)
-#else
-int
-main ()
-#endif
{
int my_array[3] = { 1, 2, 3 }; /* break main */

diff --git a/gdb/testsuite/gdb.base/annota3.c b/gdb/testsuite/gdb.base/annota3.c
index 239ea16..424e1b8 100644
--- a/gdb/testsuite/gdb.base/annota3.c
+++ b/gdb/testsuite/gdb.base/annota3.c
@@ -2,28 +2,15 @@
#include <signal.h>

-#ifdef PROTOTYPES
void
handle_USR1 (int sig)
{
}
-#else
-void
-handle_USR1 (sig)
- int sig;
-{
-}
-#endif

int value;

-#ifdef PROTOTYPES
int
main (void)
-#else
-int
-main ()
-#endif
{
int my_array[3] = { 1, 2, 3 }; /* break main */

diff --git a/gdb/testsuite/gdb.base/async.c b/gdb/testsuite/gdb.base/async.c
index 649e9e6..32779d9 100644
--- a/gdb/testsuite/gdb.base/async.c
+++ b/gdb/testsuite/gdb.base/async.c
@@ -1,12 +1,7 @@

-#ifdef PROTOTYPES
int
foo (void)
-#else
-int
-foo ()
-#endif
{
int y;
volatile int x;
@@ -17,13 +12,8 @@ foo ()
return x + y;
}

-#ifdef PROTOTYPES
int
main (void)
-#else
-int
-main ()
-#endif
{
int y, z;

@@ -37,13 +27,8 @@ main ()
}

-#ifdef PROTOTYPES
int
baz (void)
-#else
-int
-baz ()
-#endif
{
return 5;
}
diff --git a/gdb/testsuite/gdb.base/average.c b/gdb/testsuite/gdb.base/average.c
index 99c28cf..874bb1a 100644
--- a/gdb/testsuite/gdb.base/average.c
+++ b/gdb/testsuite/gdb.base/average.c
@@ -3,22 +3,13 @@
#include <stdio.h>
#include <stdlib.h>

-#ifdef PROTOTYPES
extern int sum(int *, int, int);
-#else
-extern int sum();
-#endif

#define num 10

static int my_list[num] = {3,4,2,0,2,1,8,3,6,7};

-#ifdef PROTOTYPES
void print_average(int *list, int low, int high)
-#else
-void print_average(list, low, high)
-int *list, low, high;
-#endif
{
int total = 0, num_elements = 0, average = 0;
total = sum(list, low, high);
@@ -28,11 +19,7 @@ int *list, low, high;
printf("%10.d\n", average);
}

-#ifdef PROTOTYPES
int main(void)
-#else
-main ()
-#endif
{
char c;
int first = 0, last = 0; /* stop-in-main */
diff --git a/gdb/testsuite/gdb.base/call-ar-st.c b/gdb/testsuite/gdb.base/call-ar-st.c
index f43e001..4b2ffb4 100644
--- a/gdb/testsuite/gdb.base/call-ar-st.c
+++ b/gdb/testsuite/gdb.base/call-ar-st.c
@@ -141,13 +141,7 @@ struct int_char_combo_t {
* IN id_int student -- enumerated type
* IN colors shirt -- enumerated type
*****************************************************************/
-#ifdef PROTOTYPES
void print_student_id_shirt_color (id_int student, colors shirt)
-#else
-void print_student_id_shirt_color ( student, shirt )
- id_int student;
- colors shirt;
-#endif
{

printf("student id : %d\t", student);
@@ -196,12 +190,7 @@ void print_student_id_shirt_color ( student, shirt )
* PRINT_CHAR_ARRAY :
* IN char array_c[] -- character array
*****************************************************************/
-#ifdef PROTOTYPES
void print_char_array (char array_c[])
-#else
-void print_char_array ( array_c )
- char array_c[];
-#endif
{

int index;
@@ -219,12 +208,7 @@ void print_char_array ( array_c )
* PRINT_DOUBLE_ARRAY :
* IN double array_d[] -- array of doubles
*****************************************************************/
-#ifdef PROTOTYPES
void print_double_array (double array_d[])
-#else
-void print_double_array (array_d)
- double array_d[];
-#endif
{

int index;
@@ -242,12 +226,7 @@ void print_double_array (array_d)
* PRINT_FLOAT_ARRAY:
* IN float array_f[] -- array of floats
*****************************************************************/
-#ifdef PROTOTYPES
void print_float_array (float array_f[])
-#else
-void print_float_array ( array_f )
- float array_f[];
-#endif
{

int index;
@@ -266,12 +245,7 @@ void print_float_array ( array_f )
* PRINT_INT_ARRAY:
* IN int array_i[] -- array of integers
*****************************************************************/
-#ifdef PROTOTYPES
void print_int_array (int array_i[])
-#else
-void print_int_array ( array_i )
- int array_i[];
-#endif
{

int index;
@@ -293,15 +267,7 @@ void print_int_array ( array_i )
* IN float array_f[] -- array of floats
* IN double array_d[] -- array of doubles
*****************************************************************/
-#ifdef PROTOTYPES
void print_all_arrays(int array_i[], char array_c[], float array_f[], double array_d[])
-#else
-void print_all_arrays( array_i, array_c, array_f, array_d )
- int array_i[];
- char array_c[];
- float array_f[];
- double array_d[];
-#endif
{
print_int_array(array_i); /* -step1- */
print_char_array(array_c); /* -next1- */
@@ -325,12 +291,7 @@ void loop_count () {
* A do nothing function. Used to provide a point at which calls can be made.
* IN int seed
*****************************************************************/
-#ifdef PROTOTYPES
void compute_with_small_structs (int seed)
-#else
-void compute_with_small_structs ( seed )
- int seed;
-#endif
{

struct small_rep_info_t array[4];
@@ -360,18 +321,7 @@ void compute_with_small_structs ( seed )
* IN unsigned e -- 0 or 1
* IN unsigned o -- 0 or 1
*****************************************************************/
-#ifdef PROTOTYPES
void init_bit_flags (struct bit_flags_t *bit_flags, unsigned a, unsigned b, unsigned g, unsigned d, unsigned e, unsigned o)
-#else
-void init_bit_flags ( bit_flags, a, b, g, d, e, o )
-struct bit_flags_t *bit_flags;
-unsigned a;
-unsigned b;
-unsigned g;
-unsigned d;
-unsigned e;
-unsigned o;
-#endif
{

bit_flags->alpha = a;
@@ -397,20 +347,7 @@ unsigned o;
* IN unsigned e -- 0 or 1
* IN unsigned o -- 0 or 1
*****************************************************************/
-#ifdef PROTOTYPES
void init_bit_flags_combo (struct bit_flags_combo_t *bit_flags_combo, unsigned a, unsigned b, char ch1, unsigned g, unsigned d, char ch2, unsigned e, unsigned o)
-#else
-void init_bit_flags_combo ( bit_flags_combo, a, b, ch1, g, d, ch2, e, o )
- struct bit_flags_combo_t *bit_flags_combo;
- unsigned a;
- unsigned b;
- char ch1;
- unsigned g;
- unsigned d;
- char ch2;
- unsigned e;
- unsigned o;
-#endif
{

bit_flags_combo->alpha = a; /* -step3- */
@@ -429,13 +366,7 @@ void init_bit_flags_combo ( bit_flags_combo, a, b, ch1, g, d, ch2, e, o )
* OUT struct one_double_t *one_double -- structure to fill
* IN double init_val
*****************************************************************/
-#ifdef PROTOTYPES
void init_one_double (struct one_double_t *one_double, double init_val)
-#else
-void init_one_double ( one_double, init_val )
- struct one_double_t *one_double;
- double init_val;
-#endif
{

one_double->double1 = init_val;
@@ -447,14 +378,7 @@ void init_one_double ( one_double, init_val )
* IN float init_val1
* IN float init_val2
*****************************************************************/
-#ifdef PROTOTYPES
void init_two_floats (struct two_floats_t *two_floats, float init_val1, float init_val2)
-#else
-void init_two_floats ( two_floats, init_val1, init_val2 )
- struct two_floats_t *two_floats;
- float init_val1;
- float init_val2;
-#endif
{
two_floats->float1 = init_val1;
two_floats->float2 = init_val2;
@@ -466,14 +390,7 @@ void init_two_floats ( two_floats, init_val1, init_val2 )
* IN char init_val1
* IN char init_val2
*****************************************************************/
-#ifdef PROTOTYPES
void init_two_chars (struct two_char_t *two_char, char init_val1, char init_val2)
-#else
-void init_two_chars ( two_char, init_val1, init_val2 )
- struct two_char_t *two_char;
- char init_val1;
- char init_val2;
-#endif
{

two_char->ch1 = init_val1;
@@ -487,15 +404,7 @@ void init_two_chars ( two_char, init_val1, init_val2 )
* IN char init_val2
* IN char init_val3
*****************************************************************/
-#ifdef PROTOTYPES
void init_three_chars (struct three_char_t *three_char, char init_val1, char init_val2, char init_val3)
-#else
-void init_three_chars ( three_char, init_val1, init_val2, init_val3 )
- struct three_char_t *three_char;
- char init_val1;
- char init_val2;
- char init_val3;
-#endif
{

three_char->ch1 = init_val1;
@@ -512,17 +421,7 @@ void init_three_chars ( three_char, init_val1, init_val2, init_val3 )
* IN char init_val4
* IN char init_val5
*****************************************************************/
-#ifdef PROTOTYPES
void init_five_chars (struct five_char_t *five_char, char init_val1, char init_val2, char init_val3, char init_val4, char init_val5)
-#else
-void init_five_chars ( five_char, init_val1, init_val2, init_val3,init_val4,init_val5 )
- struct five_char_t *five_char;
- char init_val1;
- char init_val2;
- char init_val3;
- char init_val4;
- char init_val5;
-#endif
{
five_char->ch1 = init_val1;
five_char->ch2 = init_val2;
@@ -537,14 +436,7 @@ void init_five_chars ( five_char, init_val1, init_val2, init_val3,init_val4,init
* IN int init_val1
* IN char init_val2
*****************************************************************/
-#ifdef PROTOTYPES
void init_int_char_combo (struct int_char_combo_t *combo, int init_val1, char init_val2)
-#else
-void init_int_char_combo ( combo, init_val1, init_val2 )
- struct int_char_combo_t *combo;
- int init_val1;
- char init_val2;
-#endif
{

combo->int1 = init_val1;
@@ -556,13 +448,7 @@ void init_int_char_combo ( combo, init_val1, init_val2 )
* OUT struct small_rep_into_t *small_struct -- structure to be filled
* IN int seed
*****************************************************************/
-#ifdef PROTOTYPES
void init_struct_rep(struct small_rep_info_t *small_struct, int seed)
-#else
-void init_struct_rep( small_struct, seed )
- struct small_rep_info_t *small_struct;
- int seed;
-#endif
{

small_struct->value = 2 + (seed*2);
@@ -574,7 +460,6 @@ void init_struct_rep( small_struct, seed )
* Takes all the small structures as input and calls the appropriate
* initialization routine for each structure
*****************************************************************/
-#ifdef PROTOTYPES
void init_small_structs (
struct small_rep_info_t *struct1,
struct small_rep_info_t *struct2,
@@ -591,25 +476,6 @@ void init_small_structs (
struct two_floats_t *f1,
struct two_floats_t *f2,
struct two_floats_t *f3)
-#else
-void init_small_structs (struct1, struct2, struct3,struct4,flags,flags_combo,
-three_char, five_char,int_char_combo, d1, d2,d3,f1,f2,f3)
- struct small_rep_info_t *struct1;
- struct small_rep_info_t *struct2;
- struct small_rep_info_t *struct3;
- struct small_rep_info_t *struct4;
- struct bit_flags_t *flags;
- struct bit_flags_combo_t *flags_combo;
- struct three_char_t *three_char;
- struct five_char_t *five_char;
- struct int_char_combo_t *int_char_combo;
- struct one_double_t *d1;
- struct one_double_t *d2;
- struct one_double_t *d3;
- struct two_floats_t *f1;
- struct two_floats_t *f2;
- struct two_floats_t *f3;
-#endif
{

init_bit_flags(flags, (unsigned)1, (unsigned)0, (unsigned)1,
@@ -636,7 +502,6 @@ three_char, five_char,int_char_combo, d1, d2,d3,f1,f2,f3)
* PRINT_TEN_DOUBLES :
* ?????????????????????????????
****************************************************************/
-#ifdef PROTOTYPES
void print_ten_doubles (
double d1,
double d2,
@@ -648,19 +513,6 @@ void print_ten_doubles (
double d8,
double d9,
double d10)
-#else
-void print_ten_doubles ( d1, d2, d3, d4, d5, d6, d7, d8, d9, d10 )
- double d1;
- double d2;
- double d3;
- double d4;
- double d5;
- double d6;
- double d7;
- double d8;
- double d9;
- double d10;
-#endif
{

printf("Two Doubles : %f\t%f\n", d1, d2);
@@ -674,12 +526,7 @@ void print_ten_doubles ( d1, d2, d3, d4, d5, d6, d7, d8, d9, d10 )
* PRINT_BIT_FLAGS :
* IN struct bit_flags_t bit_flags
****************************************************************/
-#ifdef PROTOTYPES
void print_bit_flags (struct bit_flags_t bit_flags)
-#else
-void print_bit_flags ( bit_flags )
-struct bit_flags_t bit_flags;
-#endif
{

if (bit_flags.alpha) printf("alpha\n");
@@ -694,12 +541,7 @@ struct bit_flags_t bit_flags;
* PRINT_BIT_FLAGS_COMBO :
* IN struct bit_flags_combo_t bit_flags_combo
****************************************************************/
-#ifdef PROTOTYPES
void print_bit_flags_combo (struct bit_flags_combo_t bit_flags_combo)
-#else
-void print_bit_flags_combo ( bit_flags_combo )
- struct bit_flags_combo_t bit_flags_combo;
-#endif
{

if (bit_flags_combo.alpha) printf("alpha\n");
@@ -715,12 +557,7 @@ void print_bit_flags_combo ( bit_flags_combo )
* PRINT_ONE_DOUBLE :
* IN struct one_double_t one_double
****************************************************************/
-#ifdef PROTOTYPES
void print_one_double (struct one_double_t one_double)
-#else
-void print_one_double ( one_double )
-struct one_double_t one_double;
-#endif
{

printf("Contents of one_double_t: \n\n");
@@ -731,12 +568,7 @@ struct one_double_t one_double;
* PRINT_TWO_FLOATS :
* IN struct two_floats_t two_floats
****************************************************************/
-#ifdef PROTOTYPES
void print_two_floats (struct two_floats_t two_floats)
-#else
-void print_two_floats ( two_floats )
-struct two_floats_t two_floats;
-#endif
{

printf("Contents of two_floats_t: \n\n");
@@ -747,12 +579,7 @@ struct two_floats_t two_floats;
* PRINT_TWO_CHARS :
* IN struct two_char_t two_char
****************************************************************/
-#ifdef PROTOTYPES
void print_two_chars (struct two_char_t two_char)
-#else
-void print_two_chars ( two_char )
-struct two_char_t two_char;
-#endif
{

printf("Contents of two_char_t: \n\n");
@@ -763,12 +590,7 @@ struct two_char_t two_char;
* PRINT_THREE_CHARS :
* IN struct three_char_t three_char
****************************************************************/
-#ifdef PROTOTYPES
void print_three_chars (struct three_char_t three_char)
-#else
-void print_three_chars ( three_char )
-struct three_char_t three_char;
-#endif
{

printf("Contents of three_char_t: \n\n");
@@ -779,12 +601,7 @@ struct three_char_t three_char;
* PRINT_FIVE_CHARS :
* IN struct five_char_t five_char
****************************************************************/
-#ifdef PROTOTYPES
void print_five_chars (struct five_char_t five_char)
-#else
-void print_five_chars ( five_char )
-struct five_char_t five_char;
-#endif
{

printf("Contents of five_char_t: \n\n");
@@ -797,12 +614,7 @@ struct five_char_t five_char;
* PRINT_INT_CHAR_COMBO :
* IN struct int_char_combo_t int_char_combo
****************************************************************/
-#ifdef PROTOTYPES
void print_int_char_combo (struct int_char_combo_t int_char_combo)
-#else
-void print_int_char_combo ( int_char_combo )
-struct int_char_combo_t int_char_combo;
-#endif
{

printf("Contents of int_char_combo_t: \n\n");
@@ -817,17 +629,10 @@ struct int_char_combo_t int_char_combo;
* IN struct small_rep_info_t struct2
* IN struct small_rep_info_t struct3
****************************************************************/
-#ifdef PROTOTYPES
void print_struct_rep(
struct small_rep_info_t struct1,
struct small_rep_info_t struct2,
struct small_rep_info_t struct3)
-#else
-void print_struct_rep( struct1, struct2, struct3)
- struct small_rep_info_t struct1;
- struct small_rep_info_t struct2;
- struct small_rep_info_t struct3;
-#endif
{

@@ -849,21 +654,12 @@ void print_struct_rep( struct1, struct2, struct3)
* IN struct small_rep_info_t struct3
* IN struct small_rep_info_t struct4
****************************************************************/
-#ifdef PROTOTYPES
void sum_struct_print (
int seed,
struct small_rep_info_t struct1,
struct small_rep_info_t struct2,
struct small_rep_info_t struct3,
struct small_rep_info_t struct4)
-#else
-void sum_struct_print ( seed, struct1, struct2, struct3, struct4)
- int seed;
- struct small_rep_info_t struct1;
- struct small_rep_info_t struct2;
- struct small_rep_info_t struct3;
- struct small_rep_info_t struct4;
-#endif
{
int sum;

@@ -878,7 +674,6 @@ void sum_struct_print ( seed, struct1, struct2, struct3, struct4)
* All of the small structures of odd sizes (40 bits, 8bits, etc.)
* are pushed onto the stack.
****************************************************************/
-#ifdef PROTOTYPES
void print_small_structs (
struct small_rep_info_t struct1,
struct small_rep_info_t struct2,
@@ -895,25 +690,6 @@ void print_small_structs (
struct two_floats_t f1,
struct two_floats_t f2,
struct two_floats_t f3)
-#else
-void print_small_structs ( struct1, struct2, struct3, struct4, flags,
-flags_combo, three_char, five_char, int_char_combo, d1, d2,d3,f1,f2,f3)
- struct small_rep_info_t struct1;
- struct small_rep_info_t struct2;
- struct small_rep_info_t struct3;
- struct small_rep_info_t struct4;
- struct bit_flags_t flags;
- struct bit_flags_combo_t flags_combo;
- struct three_char_t three_char;
- struct five_char_t five_char;
- struct int_char_combo_t int_char_combo;
- struct one_double_t d1;
- struct one_double_t d2;
- struct one_double_t d3;
- struct two_floats_t f1;
- struct two_floats_t f2;
- struct two_floats_t f3;
-#endif
{
print_bit_flags(flags);
print_bit_flags_combo(flags_combo);
@@ -939,7 +715,6 @@ flags_combo, three_char, five_char, int_char_combo, d1, d2,d3,f1,f2,f3)
* may force more space to be pushed onto the stack as part of the callers
* frame.
****************************************************************/
-#ifdef PROTOTYPES
void print_long_arg_list (
double a,
double b,
@@ -962,32 +737,6 @@ void print_long_arg_list (
struct two_floats_t f1,
struct two_floats_t f2,
struct two_floats_t f3)
-#else
-void print_long_arg_list ( a, b, c, d, e, f, struct1, struct2, struct3,
-struct4, flags, flags_combo, three_char, five_char, int_char_combo, d1,d2,d3,
-f1, f2, f3 )
- double a;
- double b;
- int c;
- int d;
- int e;
- int f;
- struct small_rep_info_t struct1;
- struct small_rep_info_t struct2;
- struct small_rep_info_t struct3;
- struct small_rep_info_t struct4;
- struct bit_flags_t flags;
- struct bit_flags_combo_t flags_combo;
- struct three_char_t three_char;
- struct five_char_t five_char;
- struct int_char_combo_t int_char_combo;
- struct one_double_t d1;
- struct one_double_t d2;
- struct one_double_t d3;
- struct two_floats_t f1;
- struct two_floats_t f2;
- struct two_floats_t f3;
-#endif
{
printf("double : %f\n", a); /* -step2- */
printf("double : %f\n", b);
@@ -1001,12 +750,7 @@ f1, f2, f3 )
}

-#ifdef PROTOTYPES
void print_one_large_struct (struct array_rep_info_t linked_list1)
-#else
-void print_one_large_struct( linked_list1 )
- struct array_rep_info_t linked_list1;
-#endif
{

/* printf("Contents of linked list1: \n\n");
@@ -1027,17 +771,10 @@ void print_one_large_struct( linked_list1 )
* IN struct array_rep_info_t linked_list2
* IN struct array_rep_info_t linked_list3
****************************************************************/
-#ifdef PROTOTYPES
void print_array_rep(
struct array_rep_info_t linked_list1,
struct array_rep_info_t linked_list2,
struct array_rep_info_t linked_list3)
-#else
-void print_array_rep( linked_list1, linked_list2, linked_list3 )
- struct array_rep_info_t linked_list1;
- struct array_rep_info_t linked_list2;
- struct array_rep_info_t linked_list3;
-#endif
{

int index;
@@ -1083,21 +820,12 @@ void print_array_rep( linked_list1, linked_list2, linked_list3 )
* IN struct array_rep_info_t linked_list3
* IN struct array_rep_info_t linked_list4
****************************************************************/
-#ifdef PROTOTYPES
void sum_array_print (
int seed,
struct array_rep_info_t linked_list1,
struct array_rep_info_t linked_list2,
struct array_rep_info_t linked_list3,
struct array_rep_info_t linked_list4)
-#else
-void sum_array_print ( seed, linked_list1, linked_list2, linked_list3,linked_list4)
- int seed;
- struct array_rep_info_t linked_list1;
- struct array_rep_info_t linked_list2;
- struct array_rep_info_t linked_list3;
- struct array_rep_info_t linked_list4;
-#endif
{
int index;
int sum;
@@ -1121,15 +849,9 @@ void sum_array_print ( seed, linked_list1, linked_list2, linked_list3,linked_lis
* IN struct array_rep_info_t *linked_list
* IN int seed
****************************************************************/
-#ifdef PROTOTYPES
void init_array_rep(
struct array_rep_info_t *linked_list,
int seed)
-#else
-void init_array_rep( linked_list, seed )
- struct array_rep_info_t *linked_list;
- int seed;
-#endif
{

int index;
diff --git a/gdb/testsuite/gdb.base/call-rt-st.c b/gdb/testsuite/gdb.base/call-rt-st.c
index a583bab..944f1af 100644
--- a/gdb/testsuite/gdb.base/call-rt-st.c
+++ b/gdb/testsuite/gdb.base/call-rt-st.c
@@ -141,7 +141,6 @@ void loop_count () {
* IN unsigned e -- 0 or 1
* IN unsigned o -- 0 or 1
*****************************************************************/
-#ifdef PROTOTYPES
void init_bit_flags_char (
struct bit_flags_char_t *bit_flags,
unsigned a,
@@ -150,16 +149,6 @@ unsigned g,
unsigned d,
unsigned e,
unsigned o)
-#else
-void init_bit_flags_char (bit_flags,a,b,g,d,e,o)
-struct bit_flags_char_t *bit_flags;
-unsigned a;
-unsigned b;
-unsigned g;
-unsigned d;
-unsigned e;
-unsigned o;
-#endif
{

bit_flags->alpha = a;
@@ -183,7 +172,6 @@ unsigned o;
* IN unsigned e -- 0 or 1
* IN unsigned o -- 0 or 1
*****************************************************************/
-#ifdef PROTOTYPES
void init_bit_flags_short (
struct bit_flags_short_t *bit_flags,
unsigned a,
@@ -192,16 +180,6 @@ unsigned g,
unsigned d,
unsigned e,
unsigned o)
-#else
-void init_bit_flags_short (bit_flags,a,b,g,d,e,o)
-struct bit_flags_short_t *bit_flags;
-unsigned a;
-unsigned b;
-unsigned g;
-unsigned d;
-unsigned e;
-unsigned o;
-#endif
{

bit_flags->alpha = a;
@@ -225,7 +203,6 @@ unsigned o;
* IN unsigned e -- 0 or 1
* IN unsigned o -- 0 or 1
*****************************************************************/
-#ifdef PROTOTYPES
void init_bit_flags (
struct bit_flags_t *bit_flags,
unsigned a,
@@ -234,16 +211,6 @@ unsigned g,
unsigned d,
unsigned e,
unsigned o)
-#else
-void init_bit_flags (bit_flags,a,b,g,d,e,o)
-struct bit_flags_t *bit_flags;
-unsigned a;
-unsigned b;
-unsigned g;
-unsigned d;
-unsigned e;
-unsigned o;
-#endif
{

bit_flags->alpha = a;
@@ -269,7 +236,6 @@ unsigned o;
* IN unsigned e -- 0 or 1
* IN unsigned o -- 0 or 1
*****************************************************************/
-#ifdef PROTOTYPES
void init_bit_flags_combo (
struct bit_flags_combo_t *bit_flags_combo,
unsigned a,
@@ -280,18 +246,6 @@ unsigned d,
char ch2,
unsigned e,
unsigned o)
-#else
-void init_bit_flags_combo (bit_flags_combo, a, b, ch1, g, d, ch2, e, o)
-struct bit_flags_combo_t *bit_flags_combo;
-unsigned a;
-unsigned b;
-char ch1;
-unsigned g;
-unsigned d;
-char ch2;
-unsigned e;
-unsigned o;
-#endif
{

bit_flags_combo->alpha = a;
@@ -310,13 +264,7 @@ unsigned o;
* OUT struct one_double_t *one_double -- structure to fill
* IN double init_val
*****************************************************************/
-#ifdef PROTOTYPES
void init_one_double ( struct one_double_t *one_double, double init_val)
-#else
-void init_one_double (one_double, init_val)
-struct one_double_t *one_double;
-double init_val;
-#endif
{

one_double->double1 = init_val;
@@ -328,17 +276,10 @@ double init_val;
* IN float init_val1
* IN float init_val2
*****************************************************************/
-#ifdef PROTOTYPES
void init_two_floats (
struct two_floats_t *two_floats,
float init_val1,
float init_val2)
-#else
-void init_two_floats (two_floats, init_val1, init_val2)
-struct two_floats_t *two_floats;
-float init_val1;
-float init_val2;
-#endif
{

two_floats->float1 = init_val1;
@@ -352,19 +293,11 @@ float init_val2;
* IN char init_val2
* IN char init_val3
*****************************************************************/
-#ifdef PROTOTYPES
void init_three_chars (
struct three_char_t *three_char,
char init_val1,
char init_val2,
char init_val3)
-#else
-void init_three_chars ( three_char, init_val1, init_val2, init_val3)
-struct three_char_t *three_char;
-char init_val1;
-char init_val2;
-char init_val3;
-#endif
{

three_char->ch1 = init_val1;
@@ -381,7 +314,6 @@ char init_val3;
* IN char init_val4
* IN char init_val5
*****************************************************************/
-#ifdef PROTOTYPES
void init_five_chars (
struct five_char_t *five_char,
char init_val1,
@@ -389,15 +321,6 @@ char init_val2,
char init_val3,
char init_val4,
char init_val5)
-#else
-void init_five_chars ( five_char, init_val1, init_val2, init_val3, init_val4, init_val5)
-struct five_char_t *five_char;
-char init_val1;
-char init_val2;
-char init_val3;
-char init_val4;
-char init_val5;
-#endif
{

five_char->ch1 = init_val1;
@@ -413,17 +336,10 @@ char init_val5;
* IN int init_val1
* IN char init_val2
*****************************************************************/
-#ifdef PROTOTYPES
void init_int_char_combo (
struct int_char_combo_t *combo,
int init_val1,
char init_val2)
-#else
-void init_int_char_combo ( combo, init_val1, init_val2)
-struct int_char_combo_t *combo;
-int init_val1;
-char init_val2;
-#endif
{

combo->int1 = init_val1;
@@ -435,15 +351,9 @@ char init_val2;
* OUT struct small_rep_into_t *small_struct -- structure to be filled
* IN int seed
*****************************************************************/
-#ifdef PROTOTYPES
void init_struct_rep(
struct small_rep_info_t *small_struct,
int seed)
-#else
-void init_struct_rep( small_struct, seed)
-struct small_rep_info_t *small_struct;
-int seed;
-#endif
{

small_struct->value = 2 + (seed*2);
@@ -454,12 +364,7 @@ int seed;
* PRINT_BIT_FLAGS_CHAR :
* IN struct bit_flags_char_t bit_flags
****************************************************************/
-#ifdef PROTOTYPES
struct bit_flags_char_t print_bit_flags_char (struct bit_flags_char_t bit_flags)
-#else
-struct bit_flags_char_t print_bit_flags_char ( bit_flags)
-struct bit_flags_char_t bit_flags;
-#endif
{

if (bit_flags.alpha) printf("alpha\n");
@@ -476,12 +381,7 @@ struct bit_flags_char_t bit_flags;
* PRINT_BIT_FLAGS_SHORT :
* IN struct bit_flags_short_t bit_flags
****************************************************************/
-#ifdef PROTOTYPES
struct bit_flags_short_t print_bit_flags_short (struct bit_flags_short_t bit_flags)
-#else
-struct bit_flags_short_t print_bit_flags_short ( bit_flags)
-struct bit_flags_short_t bit_flags;
-#endif
{

if (bit_flags.alpha) printf("alpha\n");
@@ -498,12 +398,7 @@ struct bit_flags_short_t bit_flags;
* PRINT_BIT_FLAGS :
* IN struct bit_flags_t bit_flags
****************************************************************/
-#ifdef PROTOTYPES
struct bit_flags_t print_bit_flags (struct bit_flags_t bit_flags)
-#else
-struct bit_flags_t print_bit_flags ( bit_flags)
-struct bit_flags_t bit_flags;
-#endif
{

if (bit_flags.alpha) printf("alpha\n");
@@ -520,12 +415,7 @@ struct bit_flags_t bit_flags;
* PRINT_BIT_FLAGS_COMBO :
* IN struct bit_flags_combo_t bit_flags_combo
****************************************************************/
-#ifdef PROTOTYPES
struct bit_flags_combo_t print_bit_flags_combo (struct bit_flags_combo_t bit_flags_combo)
-#else
-struct bit_flags_combo_t print_bit_flags_combo ( bit_flags_combo )
-struct bit_flags_combo_t bit_flags_combo;
-#endif
{

if (bit_flags_combo.alpha) printf("alpha\n");
@@ -543,12 +433,7 @@ struct bit_flags_combo_t bit_flags_combo;
* PRINT_ONE_DOUBLE :
* IN struct one_double_t one_double
****************************************************************/
-#ifdef PROTOTYPES
struct one_double_t print_one_double (struct one_double_t one_double)
-#else
-struct one_double_t print_one_double ( one_double )
-struct one_double_t one_double;
-#endif
{

printf("Contents of one_double_t: \n\n");
@@ -561,12 +446,7 @@ struct one_double_t one_double;
* PRINT_TWO_FLOATS :
* IN struct two_floats_t two_floats
****************************************************************/
-#ifdef PROTOTYPES
struct two_floats_t print_two_floats (struct two_floats_t two_floats)
-#else
-struct two_floats_t print_two_floats ( two_floats )
-struct two_floats_t two_floats;
-#endif
{

printf("Contents of two_floats_t: \n\n");
@@ -579,12 +459,7 @@ struct two_floats_t two_floats;
* PRINT_THREE_CHARS :
* IN struct three_char_t three_char
****************************************************************/
-#ifdef PROTOTYPES
struct three_char_t print_three_chars (struct three_char_t three_char)
-#else
-struct three_char_t print_three_chars ( three_char )
-struct three_char_t three_char;
-#endif
{

printf("Contents of three_char_t: \n\n");
@@ -597,12 +472,7 @@ struct three_char_t three_char;
* PRINT_FIVE_CHARS :
* IN struct five_char_t five_char
****************************************************************/
-#ifdef PROTOTYPES
struct five_char_t print_five_chars (struct five_char_t five_char)
-#else
-struct five_char_t print_five_chars ( five_char )
-struct five_char_t five_char;
-#endif
{

printf("Contents of five_char_t: \n\n");
@@ -617,12 +487,7 @@ struct five_char_t five_char;
* PRINT_INT_CHAR_COMBO :
* IN struct int_char_combo_t int_char_combo
****************************************************************/
-#ifdef PROTOTYPES
struct int_char_combo_t print_int_char_combo (struct int_char_combo_t int_char_combo)
-#else
-struct int_char_combo_t print_int_char_combo ( int_char_combo )
-struct int_char_combo_t int_char_combo;
-#endif
{

printf("Contents of int_char_combo_t: \n\n");
@@ -634,12 +499,7 @@ struct int_char_combo_t int_char_combo;
/*****************************************************************
* PRINT_STRUCT_REP :
****************************************************************/
-#ifdef PROTOTYPES
struct small_rep_info_t print_struct_rep(struct small_rep_info_t struct1)
-#else
-struct small_rep_info_t print_struct_rep( struct1 )
-struct small_rep_info_t struct1;
-#endif
{

printf("Contents of struct1: \n\n");
@@ -652,12 +512,7 @@ struct small_rep_info_t struct1;
}

-#ifdef PROTOTYPES
struct array_rep_info_t print_one_large_struct(struct array_rep_info_t linked_list1)
-#else
-struct array_rep_info_t print_one_large_struct( linked_list1 )
-struct array_rep_info_t linked_list1;
-#endif
{

@@ -673,13 +528,7 @@ struct array_rep_info_t linked_list1;
* IN struct array_rep_info_t *linked_list
* IN int seed
****************************************************************/
-#ifdef PROTOTYPES
void init_array_rep(struct array_rep_info_t *linked_list, int seed)
-#else
-void init_array_rep( linked_list, seed )
-struct array_rep_info_t *linked_list;
-int seed;
-#endif
{

int index;
diff --git a/gdb/testsuite/gdb.base/call-sc.c b/gdb/testsuite/gdb.base/call-sc.c
index cec4b34..56c18da 100644
--- a/gdb/testsuite/gdb.base/call-sc.c
+++ b/gdb/testsuite/gdb.base/call-sc.c
@@ -41,12 +41,7 @@ T fun()
return foo;
}

-#ifdef PROTOTYPES
void Fun(T foo)
-#else
-void Fun(foo)
- T foo;
-#endif
{
L = foo;
}
diff --git a/gdb/testsuite/gdb.base/call-strs.c b/gdb/testsuite/gdb.base/call-strs.c
index f3bc8da..c0b1823 100644
--- a/gdb/testsuite/gdb.base/call-strs.c
+++ b/gdb/testsuite/gdb.base/call-strs.c
@@ -6,19 +6,13 @@ char buf[100];
char bigbuf[1000];
char * s;

-#ifdef PROTOTYPES
char * str_func1(char *s1)
-#else
-char * str_func1(s1)
-char *s1;
-#endif
{
printf("first string arg is: %s\n", s1);
strcpy(bigbuf, s1);
return bigbuf;
}

-#ifdef PROTOTYPES
char * str_func(
char * s1,
char * s2,
@@ -27,22 +21,6 @@ char * s4,
char * s5,
char * s6,
char * s7)
-#else
-char * str_func(s1,
- s2,
- s3,
- s4,
- s5,
- s6,
- s7)
-char * s1;
-char * s2;
-char * s3;
-char * s4;
-char * s5;
-char * s6;
-char * s7;
-#endif
{
printf("first string arg is: %s\n", s1);
printf("second string arg is: %s\n", s2);
diff --git a/gdb/testsuite/gdb.base/callfuncs.c b/gdb/testsuite/gdb.base/callfuncs.c
index 8548757..379b713 100644
--- a/gdb/testsuite/gdb.base/callfuncs.c
+++ b/gdb/testsuite/gdb.base/callfuncs.c
@@ -123,20 +123,12 @@ struct struct1 {
#endif /* TEST_COMPLEX */
/* 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);
}
@@ -151,29 +143,17 @@ 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);
}
@@ -181,11 +161,7 @@ int t_enum_value3 (enum_arg) enum enumtype enum_arg;
/* 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;
@@ -200,7 +176,6 @@ int sum_args (argc, argv) int argc; int argv[];
/* 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); }
@@ -218,48 +193,17 @@ float _Complex t_structs_fc (struct struct1 tstruct) { return tstruct.fc;}
double _Complex t_structs_dc (struct struct1 tstruct) { return tstruct.dc;}
long double _Complex t_structs_ldc (struct struct1 tstruct) { return tstruct.ldc;}
#endif
-#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;
-}
-#ifdef TEST_COMPLEX
-float _Complex t_structs_fc (tstruct) struct struct1 tstruct; { return tstruct.fc;}
-double _Complex t_structs_dc (tstruct) struct struct1 tstruct; { return tstruct.dc;}
-long double _Complex t_structs_ldc (tstruct) struct struct1 tstruct; { return tstruct.ldc;}
-#endif
-#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) &&
@@ -270,63 +214,29 @@ cmp10 (i0, i1, i2, i3, i4, i5, i6, i7, i8, i9)
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));
}
@@ -394,12 +304,7 @@ t_float_many_args (float f1, float f2, float f3, float f4, float f5, float f6,
&& (sum_args - sum_values) > -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
@@ -544,47 +449,25 @@ DEF_FUNC_VALUES_3(fc, long double, creall, cimagl)
#endif /* TEST_COMPLEX */

-#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));
}

-#ifdef PROTOTYPES
int t_double_int (double double_arg1, int int_arg2)
-#else
-int t_double_int (double_arg1, int_arg2)
-double double_arg1;
-int int_arg2;
-#endif
{
return ((double_arg1 - int_arg2) < DELTA
&& (double_arg1 - int_arg2) > -DELTA);
}

-#ifdef PROTOTYPES
int t_int_double (int int_arg1, double double_arg2)
-#else
-int t_int_double (int_arg1, double_arg2)
-int int_arg1;
-double double_arg2;
-#endif
{
return ((int_arg1 - double_arg2) < DELTA
&& (int_arg1 - double_arg2) > -DELTA);
@@ -608,25 +491,13 @@ double double_arg2;
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));
}
diff --git a/gdb/testsuite/gdb.base/ending-run.c b/gdb/testsuite/gdb.base/ending-run.c
index d857cf8..42f12c0 100644
--- a/gdb/testsuite/gdb.base/ending-run.c
+++ b/gdb/testsuite/gdb.base/ending-run.c
@@ -4,12 +4,7 @@
#include <stdio.h>
#include <stdlib.h>

-#ifdef PROTOTYPES
int callee (int x)
-#else
-int callee( x )
-int x;
-#endif
{
int y = x * x; /* -break1- */
return (y - 2);
diff --git a/gdb/testsuite/gdb.base/execd-prog.c b/gdb/testsuite/gdb.base/execd-prog.c
index 5435f7d..ac9928f 100644
--- a/gdb/testsuite/gdb.base/execd-prog.c
+++ b/gdb/testsuite/gdb.base/execd-prog.c
@@ -8,13 +8,7 @@
*/
int global_i = 0;

-#ifdef PROTOTYPES
int main (int argc, char **argv)
-#else
-main (argc, argv)
- int argc;
- char * argv[];
-#endif
{
/* There is a local_j in foll-exec, which exec's us. We
should not be able to see that other definition of local_j
diff --git a/gdb/testsuite/gdb.base/exprs.c b/gdb/testsuite/gdb.base/exprs.c
index e1ad182..cd605f3 100644
--- a/gdb/testsuite/gdb.base/exprs.c
+++ b/gdb/testsuite/gdb.base/exprs.c
@@ -1,11 +1,4 @@
-#ifdef PROTOTYPES
int main (int argc, char **argv, char **envp)
-#else
-main (argc, argv, envp)
- int argc;
- char **argv;
- char **envp;
-#endif
{
extern void dummy();
dummy();
diff --git a/gdb/testsuite/gdb.base/foll-exec.c b/gdb/testsuite/gdb.base/foll-exec.c
index 5b0d9c5..6e302bb 100644
--- a/gdb/testsuite/gdb.base/foll-exec.c
+++ b/gdb/testsuite/gdb.base/foll-exec.c
@@ -6,11 +6,7 @@

int global_i = 100;

-#ifdef PROTOTYPES
int main (void)
-#else
-main ()
-#endif
{
int local_j = global_i+1;
int local_k = local_j+1;
diff --git a/gdb/testsuite/gdb.base/foll-fork.c b/gdb/testsuite/gdb.base/foll-fork.c
index a640928..4d8c138 100644
--- a/gdb/testsuite/gdb.base/foll-fork.c
+++ b/gdb/testsuite/gdb.base/foll-fork.c
@@ -2,22 +2,13 @@
#include <unistd.h>
#include <stdlib.h>

-#ifdef PROTOTYPES
void callee (int i)
-#else
-void callee (i)
- int i;
-#endif
{
/* Any output corrupts GDB CLI expect strings.
printf("callee: %d\n", i); */
}

-#ifdef PROTOTYPES
int main (void)
-#else
-main ()
-#endif
{
int pid;
int v = 5;
diff --git a/gdb/testsuite/gdb.base/foll-vfork.c b/gdb/testsuite/gdb.base/foll-vfork.c
index 27c0dfc..933ce38 100644
--- a/gdb/testsuite/gdb.base/foll-vfork.c
+++ b/gdb/testsuite/gdb.base/foll-vfork.c
@@ -18,11 +18,7 @@
#include <stdio.h>
#include <unistd.h>

-#ifdef PROTOTYPES
int main (void)
-#else
-main ()
-#endif
{
int pid;

diff --git a/gdb/testsuite/gdb.base/funcargs.c b/gdb/testsuite/gdb.base/funcargs.c
index b34f3fb..600792f 100644
--- a/gdb/testsuite/gdb.base/funcargs.c
+++ b/gdb/testsuite/gdb.base/funcargs.c
@@ -77,12 +77,7 @@ char carray[] = {'a', 'n', ' ', 'a', 'r', 'r', 'a', 'y', '\0'};
/* Test various permutations and interleaving of integral arguments */

-#ifdef PROTOTYPES
void call0a (char c, short s, int i, long l)
-#else
-call0a (c, s, i, l)
-char c; short s; int i; long l;
-#endif
{
c = 'a';
s = 5;
@@ -90,42 +85,22 @@ char c; short s; int i; long l;
l = 7;
}

-#ifdef PROTOTYPES
void call0b (short s, int i, long l, char c)
-#else
-call0b (s, i, l, c)
-short s; int i; long l; char c;
-#endif
{
s = 6; i = 7; l = 8; c = 'j';
}

-#ifdef PROTOTYPES
void call0c (int i, long l, char c, short s)
-#else
-call0c (i, l, c, s)
-int i; long l; char c; short s;
-#endif
{
i = 3; l = 4; c = 'k'; s = 5;
}

-#ifdef PROTOTYPES
void call0d (long l, char c, short s, int i)
-#else
-call0d (l, c, s, i)
-long l; char c; short s; int i;
-#endif
{
l = 7; c = 'z'; s = 8; i = 9;
}

-#ifdef PROTOTYPES
void call0e (char c1, long l, char c2, int i, char c3, short s, char c4, char c5)
-#else
-call0e (c1, l, c2, i, c3, s, c4, c5)
-char c1; long l; char c2; int i; char c3; short s; char c4; char c5;
-#endif
{
c1 = 'a'; l = 5; c2 = 'b'; i = 7; c3 = 'c'; s = 7; c4 = 'f'; c5 = 'g';
}
@@ -134,53 +109,27 @@ char c1; long l; char c2; int i; char c3; short s; char c4; char c5;
/* Test various permutations and interleaving of unsigned integral arguments */

-#ifdef PROTOTYPES
void call1a (unsigned char uc, unsigned short us, unsigned int ui, unsigned long ul)
-#else
-call1a (uc, us, ui, ul)
-unsigned char uc; unsigned short us; unsigned int ui; unsigned long ul;
-#endif
{
uc = 5; us = 6; ui = 7; ul = 8;
}

-#ifdef PROTOTYPES
void call1b (unsigned short us, unsigned int ui, unsigned long ul, unsigned char uc)
-#else
-call1b (us, ui, ul, uc)
-unsigned short us; unsigned int ui; unsigned long ul; unsigned char uc;
-#endif
{
uc = 5; us = 6; ui = 7; ul = 8;
}

-#ifdef PROTOTYPES
void call1c (unsigned int ui, unsigned long ul, unsigned char uc, unsigned short us)
-#else
-call1c (ui, ul, uc, us)
-unsigned int ui; unsigned long ul; unsigned char uc; unsigned short us;
-#endif
{
uc = 5; us = 6; ui = 7; ul = 8;
}

-#ifdef PROTOTYPES
void call1d (unsigned long ul, unsigned char uc, unsigned short us, unsigned int ui)
-#else
-call1d (ul, uc, us, ui)
-unsigned long ul; unsigned char uc; unsigned short us; unsigned int ui;
-#endif
{
uc = 5; us = 6; ui = 7; ul = 8;
}

-#ifdef PROTOTYPES
void call1e (unsigned char uc1, unsigned long ul, unsigned char uc2, unsigned int ui, unsigned char uc3, unsigned short us, unsigned char uc4, unsigned char uc5)
-#else
-call1e (uc1, ul, uc2, ui, uc3, us, uc4, uc5)
-unsigned char uc1; unsigned long ul; unsigned char uc2; unsigned int ui;
-unsigned char uc3; unsigned short us; unsigned char uc4; unsigned char uc5;
-#endif
{
uc1 = 5; ul = 7; uc2 = 8; ui = 9; uc3 = 10; us = 11; uc4 = 12; uc5 = 55;
}
@@ -189,93 +138,47 @@ unsigned char uc3; unsigned short us; unsigned char uc4; unsigned char uc5;
floating point arguments. */

-#ifdef PROTOTYPES
void call2a (char c, float f1, short s, double d1, int i, float f2, long l, double d2)
-#else
-call2a (c, f1, s, d1, i, f2, l, d2)
-char c; float f1; short s; double d1; int i; float f2; long l; double d2;
-#endif
{
c = 'a'; f1 = 0.0; s = 5; d1 = 0.0; i = 6; f2 = 0.1; l = 7; d2 = 0.2;
}

-#ifdef PROTOTYPES
void call2b (float f1, short s, double d1, int i, float f2, long l, double d2, char c)
-#else
-call2b (f1, s, d1, i, f2, l, d2, c)
-float f1; short s; double d1; int i; float f2; long l; double d2; char c;
-#endif
{
c = 'a'; f1 = 0.0; s = 5; d1 = 0.0; i = 6; f2 = 0.1; l = 7; d2 = 0.2;
}

-#ifdef PROTOTYPES
void call2c (short s, double d1, int i, float f2, long l, double d2, char c, float f1)
-#else
-call2c (s, d1, i, f2, l, d2, c, f1)
-short s; double d1; int i; float f2; long l; double d2; char c; float f1;
-#endif
{
c = 'a'; f1 = 0.0; s = 5; d1 = 0.0; i = 6; f2 = 0.1; l = 7; d2 = 0.2;
}

-#ifdef PROTOTYPES
void call2d (double d1, int i, float f2, long l, double d2, char c, float f1, short s)
-#else
-call2d (d1, i, f2, l, d2, c, f1, s)
-double d1; int i; float f2; long l; double d2; char c; float f1; short s;
-#endif
{
c = 'a'; f1 = 0.0; s = 5; d1 = 0.0; i = 6; f2 = 0.1; l = 7; d2 = 0.2;
}

-#ifdef PROTOTYPES
void call2e (int i, float f2, long l, double d2, char c, float f1, short s, double d1)
-#else
-call2e (i, f2, l, d2, c, f1, s, d1)
-int i; float f2; long l; double d2; char c; float f1; short s; double d1;
-#endif
{
c = 'a'; f1 = 0.0; s = 5; d1 = 0.0; i = 6; f2 = 0.1; l = 7; d2 = 0.2;
}

-#ifdef PROTOTYPES
void call2f (float f2, long l, double d2, char c, float f1, short s, double d1, int i)
-#else
-call2f (f2, l, d2, c, f1, s, d1, i)
-float f2; long l; double d2; char c; float f1; short s; double d1; int i;
-#endif
{
c = 'a'; f1 = 0.0; s = 5; d1 = 0.0; i = 6; f2 = 0.1; l = 7; d2 = 0.2;
}

-#ifdef PROTOTYPES
void call2g (long l, double d2, char c, float f1, short s, double d1, int i, float f2)
-#else
-call2g (l, d2, c, f1, s, d1, i, f2)
-long l; double d2; char c; float f1; short s; double d1; int i; float f2;
-#endif
{
c = 'a'; f1 = 0.0; s = 5; d1 = 0.0; i = 6; f2 = 0.1; l = 7; d2 = 0.2;
}

-#ifdef PROTOTYPES
void call2h (double d2, char c, float f1, short s, double d1, int i, float f2, long l)
-#else
-call2h (d2, c, f1, s, d1, i, f2, l)
-double d2; char c; float f1; short s; double d1; int i; float f2; long l;
-#endif
{
c = 'a'; f1 = 0.0; s = 5; d1 = 0.0; i = 6; f2 = 0.1; l = 7; d2 = 0.2;
}

-#ifdef PROTOTYPES
void call2i (char c1, float f1, char c2, char c3, double d1, char c4, char c5, char c6, float f2, short s, char c7, double d2)
-#else
-call2i (c1, f1, c2, c3, d1, c4, c5, c6, f2, s, c7, d2)
-char c1; float f1; char c2; char c3; double d1; char c4; char c5; char c6;
-float f2; short s; char c7; double d2;
-#endif
{
c1 = 'a'; f1 = 0.0; c2 = 5; d1 = 0.0; c3 = 6; f2 = 0.1; c4 = 7; d2 = 0.2;
c5 = 's'; c6 = 'f'; c7 = 'z'; s = 77;
@@ -285,33 +188,17 @@ float f2; short s; char c7; double d2;
/* Test pointers to various integral and floating types. */

-#ifdef PROTOTYPES
void call3a (char *cp, short *sp, int *ip, long *lp)
-#else
-call3a (cp, sp, ip, lp)
-char *cp; short *sp; int *ip; long *lp;
-#endif
{
cp = 0; sp = 0; ip = 0; lp = 0;
}

-#ifdef PROTOTYPES
void call3b (unsigned char *ucp, unsigned short *usp, unsigned int *uip, unsigned long *ulp)
-#else
-call3b (ucp, usp, uip, ulp)
-unsigned char *ucp; unsigned short *usp; unsigned int *uip;
-unsigned long *ulp;
-#endif
{
ucp = 0; usp = 0; uip = 0; ulp = 0;
}

-#ifdef PROTOTYPES
void call3c (float *fp, double *dp)
-#else
-call3c (fp, dp)
-float *fp; double *dp;
-#endif
{
fp = 0; dp = 0;
}
@@ -322,107 +209,53 @@ float *fp; double *dp;

/* Test various _Complex type args. */

-#ifdef PROTOTYPES
void callca (float _Complex f1, float _Complex f2, float _Complex f3)
-#else
-callca (f1, f2, f3)
-float _Complex f1; float _Complex f2; float _Complex f3;
-#endif
{

}

-#ifdef PROTOTYPES
void callcb (double _Complex d1, double _Complex d2, double _Complex d3)
-#else
-callcb (d1, d2, d3)
-double _Complex d1; double _Complex d2; double _Complex d3;
-#endif
{

}

-#ifdef PROTOTYPES
void callcc (long double _Complex ld1, long double _Complex ld2, long double _Complex ld3)
-#else
-callcc (ld1, ld2, ld3)
-long double _Complex ld1; long double _Complex ld2; long double _Complex ld3;
-#endif
{

}

-#ifdef PROTOTYPES
void callcd (float _Complex fc1, double _Complex dc1, long double _Complex ldc1)
-#else
-callcd (fc1, dc1, ldc1)
-float _Complex fc1; double _Complex dc1; long double _Complex ldc1;
-#endif
{
}

-#ifdef PROTOTYPES
void callce (double _Complex dc1, long double _Complex ldc1, float _Complex fc1)
-#else
-callce (dc1, ldc1, fc1)
-double _Complex dc1; long double _Complex ldc1; float _Complex fc1;
-#endif
{
}

-#ifdef PROTOTYPES
void callcf (long double _Complex ldc1, float _Complex fc1, double _Complex dc1)
-#else
-callcf (ldc1, fc1, dc1)
-long double _Complex ldc1; float _Complex fc1; double _Complex dc1;
-#endif
{
}

/* Test passing _Complex type and integral. */
-#ifdef PROTOTYPES
void callc1a (char c, short s, int i, unsigned int ui, long l,
float _Complex fc1, double _Complex dc1,
long double _Complex ldc1)
-#else
-callc1a (c, s, i, ui, l, fc1, dc1, ldc1)
-char c; short s; int i; unsigned int ui; long l; float _Complex fc1; double _Complex dc1; long double _Complex ldc1;
-#endif
{}

-#ifdef PROTOTYPES
void callc1b (long double _Complex ldc1, char c, short s, int i,
float _Complex fc1, unsigned int ui, long l, double _Complex dc1)
-#else
-callc1b (ldc1, c, s, i, fc1, ui, l, dc1)
-char c; short s; int i; unsigned int ui; long l; float _Complex fc1; double _Complex dc1; long double _Complex ldc1;
-#endif
{}

-#ifdef PROTOTYPES
void callc2a (char c, short s, int i, unsigned int ui, long l, float f,
double d, float _Complex fc1, double _Complex dc1,
long double _Complex ldc1)
-#else
-callc2a (c, s, i, ui, l, f, d, fc1, dc1, ldc1)
- char c; short s; int i; unsigned int ui; long l; float f; double d;
- float _Complex fc1; double _Complex dc1;
- long double _Complex ldc1;
-#endif
{}

-#ifdef PROTOTYPES
void callc2b (float _Complex fc1, char c, short s, int i, unsigned int ui,
long double _Complex ldc1, long l, float f, double d,
double _Complex dc1)
-#else
-callc2b (fc1, c, s, i, ui, ldc1, l, f, d, dc1)
- char c; short s; int i; unsigned int ui; long l; float f; double d;
- float _Complex fc1; double _Complex dc1;
- long double _Complex ldc1;
-#endif
{}

@@ -431,20 +264,10 @@ callc2b (fc1, c, s, i, ui, ldc1, l, f, d, dc1)
/* Test passing structures and unions by reference. */

-#ifdef PROTOTYPES
void call4a (struct stag *stp)
-#else
-call4a (stp)
-struct stag *stp;
-#endif
{stp = 0;}

-#ifdef PROTOTYPES
void call4b (union utag *unp)
-#else
-call4b (unp)
-union utag *unp;
-#endif
{
unp = 0;
}
@@ -453,20 +276,10 @@ union utag *unp;
/* Test passing structures and unions by value. */

-#ifdef PROTOTYPES
void call5a (struct stag st)
-#else
-call5a (st)
-struct stag st;
-#endif
{st.s1 = 5;}

-#ifdef PROTOTYPES
void call5b (union utag un)
-#else
-call5b (un)
-union utag un;
-#endif
{un.u1 = 7;}

@@ -477,117 +290,61 @@ void call6k ()
{
}

-#ifdef PROTOTYPES
void call6j (unsigned long ul)
-#else
-call6j (ul)
-unsigned long ul;
-#endif
{
ul = ul;
call6k ();
}

-#ifdef PROTOTYPES
void call6i (unsigned int ui, unsigned long ul)
-#else
-call6i (ui, ul)
-unsigned int ui; unsigned long ul;
-#endif
{
ui = ui;
call6j (ul);
}

-#ifdef PROTOTYPES
void call6h (unsigned short us, unsigned int ui, unsigned long ul)
-#else
-call6h (us, ui, ul)
-unsigned short us; unsigned int ui; unsigned long ul;
-#endif
{
us = us;
call6i (ui, ul);
}

-#ifdef PROTOTYPES
void call6g (unsigned char uc, unsigned short us, unsigned int ui, unsigned long ul)
-#else
-call6g (uc, us, ui, ul)
-unsigned char uc; unsigned short us; unsigned int ui; unsigned long ul;
-#endif
{
uc = uc;
call6h (us, ui, ul);
}

-#ifdef PROTOTYPES
void call6f (double d, unsigned char uc, unsigned short us, unsigned int ui, unsigned long ul)
-#else
-call6f (d, uc, us, ui, ul)
-double d;
-unsigned char uc; unsigned short us; unsigned int ui; unsigned long ul;
-#endif
{
d = d;
call6g (uc, us, ui, ul);
}

-#ifdef PROTOTYPES
void call6e (float f, double d, unsigned char uc, unsigned short us, unsigned int ui, unsigned long ul)
-#else
-call6e (f, d, uc, us, ui, ul)
-float f; double d;
-unsigned char uc; unsigned short us; unsigned int ui; unsigned long ul;
-#endif
{
f = f;
call6f (d, uc, us, ui, ul);
}

-#ifdef PROTOTYPES
void call6d (long l, float f, double d, unsigned char uc, unsigned short us, unsigned int ui, unsigned long ul)
-#else
-call6d (l, f, d, uc, us, ui, ul)
-long l; float f; double d;
-unsigned char uc; unsigned short us; unsigned int ui; unsigned long ul;
-#endif
{
l = l;
call6e (f, d, uc, us, ui, ul);
}

-#ifdef PROTOTYPES
void call6c (int i, long l, float f, double d, unsigned char uc, unsigned short us, unsigned int ui, unsigned long ul)
-#else
-call6c (i, l, f, d, uc, us, ui, ul)
-int i; long l; float f; double d;
-unsigned char uc; unsigned short us; unsigned int ui; unsigned long ul;
-#endif
{
i = i;
call6d (l, f, d, uc, us, ui, ul);
}

-#ifdef PROTOTYPES
void call6b (short s, int i, long l, float f, double d, unsigned char uc, unsigned short us, unsigned int ui, unsigned long ul)
-#else
-call6b (s, i, l, f, d, uc, us, ui, ul)
-short s; int i; long l; float f; double d;
-unsigned char uc; unsigned short us; unsigned int ui; unsigned long ul;
-#endif
{
s = s;
call6c (i, l, f, d, uc, us, ui, ul);
}

-#ifdef PROTOTYPES
void call6a (char c, short s, int i, long l, float f, double d, unsigned char uc, unsigned short us, unsigned int ui, unsigned long ul)
-#else
-call6a (c, s, i, l, f, d, uc, us, ui, ul)
-char c; short s; int i; long l; float f; double d;
-unsigned char uc; unsigned short us; unsigned int ui; unsigned long ul;
-#endif
{
c = c;
call6b (s, i, l, f, d, uc, us, ui, ul);
@@ -596,113 +353,58 @@ unsigned char uc; unsigned short us; unsigned int ui; unsigned long ul;
/* Test shuffling of args, round robin */

-#ifdef PROTOTYPES
void call7k (char c, int i, short s, long l, float f, unsigned char uc, double d, unsigned short us, unsigned long ul, unsigned int ui)
-#else
-call7k (c, i, s, l, f, uc, d, us, ul, ui)
-char c; int i; short s; long l; float f; unsigned char uc; double d; unsigned short us; unsigned long ul; unsigned int ui;
-#endif
{
c = 'a'; i = 7; s = 8; l = 7; f = 0.3; uc = 44; d = 0.44; us = 77;
ul = 43; ui = 33;
}

-#ifdef PROTOTYPES
void call7j (unsigned int ui, char c, int i, short s, long l, float f, unsigned char uc, double d, unsigned short us, unsigned long ul)
-#else
-call7j (ui, c, i, s, l, f, uc, d, us, ul)
-unsigned int ui; char c; int i; short s; long l; float f; unsigned char uc; double d; unsigned short us; unsigned long ul;
-#endif
{
call7k (c, i, s, l, f, uc, d, us, ul, ui);
}

-#ifdef PROTOTYPES
void call7i (unsigned long ul, unsigned int ui, char c, int i, short s, long l, float f, unsigned char uc, double d, unsigned short us)
-#else
-call7i (ul, ui, c, i, s, l, f, uc, d, us)
-unsigned long ul; unsigned int ui; char c; int i; short s; long l; float f; unsigned char uc; double d; unsigned short us;
-#endif
{
call7j (ui, c, i, s, l, f, uc, d, us, ul);
}

-#ifdef PROTOTYPES
void call7h (unsigned short us, unsigned long ul, unsigned int ui, char c, int i, short s, long l, float f, unsigned char uc, double d)
-#else
-call7h (us, ul, ui, c, i, s, l, f, uc, d)
-unsigned short us; unsigned long ul; unsigned int ui; char c; int i; short s; long l; float f; unsigned char uc; double d;
-#endif
{
call7i (ul, ui, c, i, s, l, f, uc, d, us);
}

-#ifdef PROTOTYPES
void call7g (double d, unsigned short us, unsigned long ul, unsigned int ui, char c, int i, short s, long l, float f, unsigned char uc)
-#else
-call7g (d, us, ul, ui, c, i, s, l, f, uc)
-double d; unsigned short us; unsigned long ul; unsigned int ui; char c; int i; short s; long l; float f; unsigned char uc;
-#endif
{
call7h (us, ul, ui, c, i, s, l, f, uc, d);
}

-#ifdef PROTOTYPES
void call7f (unsigned char uc, double d, unsigned short us, unsigned long ul, unsigned int ui, char c, int i, short s, long l, float f)
-#else
-call7f (uc, d, us, ul, ui, c, i, s, l, f)
-unsigned char uc; double d; unsigned short us; unsigned long ul; unsigned int ui; char c; int i; short s; long l; float f;
-#endif
{
call7g (d, us, ul, ui, c, i, s, l, f, uc);
}

-#ifdef PROTOTYPES
void call7e (float f, unsigned char uc, double d, unsigned short us, unsigned long ul, unsigned int ui, char c, int i, short s, long l)
-#else
-call7e (f, uc, d, us, ul, ui, c, i, s, l)
-float f; unsigned char uc; double d; unsigned short us; unsigned long ul; unsigned int ui; char c; int i; short s; long l;
-#endif
{
call7f (uc, d, us, ul, ui, c, i, s, l, f);
}

-#ifdef PROTOTYPES
void call7d (long l, float f, unsigned char uc, double d, unsigned short us, unsigned long ul, unsigned int ui, char c, int i, short s)
-#else
-call7d (l, f, uc, d, us, ul, ui, c, i, s)
-long l; float f; unsigned char uc; double d; unsigned short us; unsigned long ul; unsigned int ui; char c; int i; short s;
-#endif
{
call7e (f, uc, d, us, ul, ui, c, i, s, l);
}

-#ifdef PROTOTYPES
void call7c (short s, long l, float f, unsigned char uc, double d, unsigned short us, unsigned long ul, unsigned int ui, char c, int i)
-#else
-call7c (s, l, f, uc, d, us, ul, ui, c, i)
-short s; long l; float f; unsigned char uc; double d; unsigned short us; unsigned long ul; unsigned int ui; char c; int i;
-#endif
{
call7d (l, f, uc, d, us, ul, ui, c, i, s);
}

-#ifdef PROTOTYPES
void call7b (int i, short s, long l, float f, unsigned char uc, double d, unsigned short us, unsigned long ul, unsigned int ui, char c)
-#else
-call7b (i, s, l, f, uc, d, us, ul, ui, c)
-int i; short s; long l; float f; unsigned char uc; double d; unsigned short us; unsigned long ul; unsigned int ui; char c;
-#endif
{
call7c (s, l, f, uc, d, us, ul, ui, c, i);
}

-#ifdef PROTOTYPES
void call7a (char c, int i, short s, long l, float f, unsigned char uc, double d, unsigned short us, unsigned long ul, unsigned int ui)
-#else
-call7a (c, i, s, l, f, uc, d, us, ul, ui)
-char c; int i; short s; long l; float f; unsigned char uc; double d; unsigned short us; unsigned long ul; unsigned int ui;
-#endif
{
call7b (i, s, l, f, uc, d, us, ul, ui, c);
}
@@ -722,13 +424,7 @@ void hitbottom ()
{
}

-#ifdef PROTOTYPES
void recurse (SVAL a, int depth)
-#else
-void recurse (a, depth)
-SVAL a;
-int depth;
-#endif
{
a.s = a.i = a.l = --depth;
if (depth == 0)
@@ -748,16 +444,7 @@ void test_struct_args ()
calls alloca may do things differently with respect to frames. So give
it a try. */

-#ifdef PROTOTYPES
void localvars_after_alloca (char c, short s, int i, long l)
-#else
-void
-localvars_after_alloca (c, s, i, l)
- char c;
- short s;
- int i;
- long l;
-#endif
{
#ifdef HAVE_STACK_ALLOCA
/* No need to use the alloca.c alloca-on-top-of-malloc; it doesn't
@@ -772,29 +459,14 @@ localvars_after_alloca (c, s, i, l)
l = 7;
}

-#ifdef PROTOTYPES
void call_after_alloca_subr (char c, short s, int i, long l, unsigned char uc, unsigned short us, unsigned int ui, unsigned long ul)
-#else
-void
-call_after_alloca_subr (c, s, i, l, uc, us, ui, ul)
-char c; int i; short s; long l; unsigned char uc; unsigned short us; unsigned long ul; unsigned int ui;
-#endif
{
c = 'a';
i = 7; s = 8; l = 7; uc = 44; us = 77;
ul = 43; ui = 33;
}

-#ifdef PROTOTYPES
void call_after_alloca (char c, short s, int i, long l)
-#else
-void
-call_after_alloca (c, s, i, l)
- char c;
- short s;
- int i;
- long l;
-#endif
{
#ifdef HAVE_STACK_ALLOCA
/* No need to use the alloca.c alloca-on-top-of-malloc; it doesn't
@@ -813,13 +485,7 @@ call_after_alloca (c, s, i, l)
will require a trampoline between dyncall and this function on the
call path, then another trampoline on between this function and main
on the return path. */
-#ifdef PROTOTYPES
double call_with_trampolines (double d1)
-#else
-double
-call_with_trampolines (d1)
-double d1;
-#endif
{
return d1;
} /* End of call_with_trampolines, this comment is needed by funcargs.exp */
diff --git a/gdb/testsuite/gdb.base/gcore.c b/gdb/testsuite/gdb.base/gcore.c
index 88418b3..ee826a5 100644
--- a/gdb/testsuite/gdb.base/gcore.c
+++ b/gdb/testsuite/gdb.base/gcore.c
@@ -49,12 +49,7 @@ array_func ()
terminal_func ();
}

-#ifdef PROTOTYPES
int factorial_func (int value)
-#else
-int factorial_func (value)
- int value;
-#endif
{
if (value > 1) {
value *= factorial_func (value - 1);
diff --git a/gdb/testsuite/gdb.base/jump.c b/gdb/testsuite/gdb.base/jump.c
index 3c05244..376ea17 100644
--- a/gdb/testsuite/gdb.base/jump.c
+++ b/gdb/testsuite/gdb.base/jump.c
@@ -2,12 +2,7 @@
particularly deep about the functionality nor names in here.
*/

-#ifdef PROTOTYPES
static int square (int x)
-#else
-static int square (x)
- int x;
-#endif
{
return x*x; /* out-of-func */
}
diff --git a/gdb/testsuite/gdb.base/langs0.c b/gdb/testsuite/gdb.base/langs0.c
index cc6efdd..41e5d38 100644
--- a/gdb/testsuite/gdb.base/langs0.c
+++ b/gdb/testsuite/gdb.base/langs0.c
@@ -1,14 +1,8 @@
/* This file is actually in C, it is not supposed to simulate something
translated from another language or anything like that. */
-#ifdef PROTOTYPES
extern int fsub_();

int csub (int x)
-#else
-int
-csub (x)
- int x;
-#endif
{
return x + 1;
}
diff --git a/gdb/testsuite/gdb.base/langs1.c b/gdb/testsuite/gdb.base/langs1.c
index 8ffd13f..7b6b229 100644
--- a/gdb/testsuite/gdb.base/langs1.c
+++ b/gdb/testsuite/gdb.base/langs1.c
@@ -16,22 +16,14 @@ static integer c__10000 = 10000;

/* I am not sure whether there is a way to have a fortran program without */
/* a MAIN, but it does not really harm us to have one. */
-#ifdef PROTOTYPES
/* Main program */ void MAIN__()
-#else
-/* Main program */ MAIN__()
-#endif
{
} /* MAIN__ */

#line 4 "langs1.f"
/* Subroutine */ int fsub_()
{
-#ifdef PROTOTYPES
extern integer cppsub_(int*);
-#else
- extern integer cppsub_();
-#endif

#line 5 "langs1.f"
#line 6 "langs1.f"
diff --git a/gdb/testsuite/gdb.base/langs2.c b/gdb/testsuite/gdb.base/langs2.c
index 502b800..a06fb30 100644
--- a/gdb/testsuite/gdb.base/langs2.c
+++ b/gdb/testsuite/gdb.base/langs2.c
@@ -1,5 +1,4 @@
/* This is intended to be a vague simulation of cfront output. */
-#ifdef PROTOTYPES
#line 1 "langs2.cxx"
extern int csub (int);
int
@@ -14,19 +13,3 @@ cppsub_ (int * y)
{
return foo__Fi (*y);
}
-#else
-#line 1 "langs2.cxx"
-extern int csub ();
-int
-foo__Fi (x) int x;
-{
- return csub (x / 2);
-}
-
-extern int cppsub_ ();
-int
-cppsub_ (y) int *y;
-{
- return foo__Fi (*y);
-}
-#endif
diff --git a/gdb/testsuite/gdb.base/mips_pro.c b/gdb/testsuite/gdb.base/mips_pro.c
index c28f99e..2c258a8 100644
--- a/gdb/testsuite/gdb.base/mips_pro.c
+++ b/gdb/testsuite/gdb.base/mips_pro.c
@@ -1,25 +1,13 @@
/* Tests regarding examination of prologues. */

-#ifdef PROTOTYPES
int
inner (int z)
-#else
-int
-inner (z)
- int z;
-#endif
{
return 2 * z;
}

-#ifdef PROTOTYPES
int
middle (int x)
-#else
-int
-middle (x)
- int x;
-#endif
{
if (x == 0)
return inner (5);
@@ -27,27 +15,14 @@ middle (x)
return inner (6);
}

-#ifdef PROTOTYPES
int
top (int y)
-#else
-int
-top (y)
- int y;
-#endif
{
return middle (y + 1);
}

-#ifdef PROTOTYPES
int
main (int argc, char **argv)
-#else
-int
-main (argc, argv)
- int argc;
- char **argv;
-#endif
{
return top (-1) + top (1);
}
diff --git a/gdb/testsuite/gdb.base/nodebug.c b/gdb/testsuite/gdb.base/nodebug.c
index 4857882..eb5d661 100644
--- a/gdb/testsuite/gdb.base/nodebug.c
+++ b/gdb/testsuite/gdb.base/nodebug.c
@@ -6,65 +6,33 @@ static int datalocal = 4; /* Should go in local data */
int bssglobal; /* Should go in global bss */
static int bsslocal; /* Should go in local bss */

-#ifdef PROTOTYPES
int
inner (int x)
-#else
-int
-inner (x)
- int x;
-#endif
{
return x + dataglobal + datalocal + bssglobal + bsslocal;
}

-#ifdef PROTOTYPES
static short
middle (int x)
-#else
-static short
-middle (x)
- int x;
-#endif
{
return 2 * inner (x);
}

-#ifdef PROTOTYPES
short
top (int x)
-#else
-short
-top (x)
- int x;
-#endif
{
return 2 * middle (x);
}

-#ifdef PROTOTYPES
int
main (int argc, char **argv)
-#else
-int
-main (argc, argv)
- int argc;
- char **argv;
-#endif
{
return top (argc);
}

int *x;

-#ifdef PROTOTYPES
int array_index (char *arr, int i)
-#else
-int
-array_index (arr, i)
- char *arr;
- int i;
-#endif
{
/* The basic concept is just "return arr[i];". But call malloc so that gdb
will be able to call functions. */
diff --git a/gdb/testsuite/gdb.base/opaque0.c b/gdb/testsuite/gdb.base/opaque0.c
index bf90eca..330560e 100644
--- a/gdb/testsuite/gdb.base/opaque0.c
+++ b/gdb/testsuite/gdb.base/opaque0.c
@@ -7,9 +7,7 @@

struct foo *foop;
extern struct foo *getfoo ();
-#ifdef PROTOTYPES
extern void putfoo (struct foo *foop);
-#endif

int main ()
{
diff --git a/gdb/testsuite/gdb.base/opaque1.c b/gdb/testsuite/gdb.base/opaque1.c
index c34f7aa..ccb5fce 100644
--- a/gdb/testsuite/gdb.base/opaque1.c
+++ b/gdb/testsuite/gdb.base/opaque1.c
@@ -8,11 +8,6 @@ struct foo *getfoo ()
return (&afoo);
}

-#ifdef PROTOTYPES
void putfoo (struct foo *foop)
-#else
-void putfoo (foop)
- struct foo *foop;
-#endif
{
}
diff --git a/gdb/testsuite/gdb.base/recurse.c b/gdb/testsuite/gdb.base/recurse.c
index cb7b022..821c2de 100644
--- a/gdb/testsuite/gdb.base/recurse.c
+++ b/gdb/testsuite/gdb.base/recurse.c
@@ -1,14 +1,8 @@
/* Trivial code used to test watchpoints in recursive code and
auto-deletion of watchpoints as they go out of scope. */

-#ifdef PROTOTYPES
static int
recurse (int a)
-#else
-static int
-recurse (a)
- int a;
-#endif
{
int b = 0;

diff --git a/gdb/testsuite/gdb.base/run.c b/gdb/testsuite/gdb.base/run.c
index df54056..0c62002 100644
--- a/gdb/testsuite/gdb.base/run.c
+++ b/gdb/testsuite/gdb.base/run.c
@@ -6,17 +6,10 @@
#include <stdio.h>
#include <stdlib.h>

-#ifdef PROTOTYPES
int factorial (int);

int
main (int argc, char **argv, char **envp)
-#else
-int
-main (argc, argv, envp)
-int argc;
-char *argv[], **envp;
-#endif
{
#ifdef FAKEARGV
printf ("%d\n", factorial (1)); /* commands.exp: hw local_var out of scope */
@@ -31,11 +24,7 @@ char *argv[], **envp;
return 0;
}

-#ifdef PROTOTYPES
int factorial (int value)
-#else
-int factorial (value) int value;
-#endif
{
int local_var;

diff --git a/gdb/testsuite/gdb.base/scope0.c b/gdb/testsuite/gdb.base/scope0.c
index 775f8dc..e7f4724 100644
--- a/gdb/testsuite/gdb.base/scope0.c
+++ b/gdb/testsuite/gdb.base/scope0.c
@@ -44,14 +44,8 @@ void init0 ()

/* This is to derail optimizer in localscopes.
Return 1 + 2 + . . . + N. */
-#ifdef PROTOTYPES
int
sum_upto (int n)
-#else
-int
-sum_upto (n)
- int n;
-#endif
{
int i;
int retval = 0;
@@ -61,13 +55,8 @@ sum_upto (n)
return retval;
}

-#ifdef PROTOTYPES
int
useit (int val)
-#else
-int
-useit (val) int val;
-#endif
{
static int usedval;

@@ -75,13 +64,8 @@ useit (val) int val;
return val + sum_upto (0);
}

-#ifdef PROTOTYPES
int
useitp (const int *val)
-#else
-int
-useitp (val) const int *val;
-#endif
{
static int usedval;

@@ -89,15 +73,8 @@ useitp (val) const int *val;
return *val + sum_upto (0);
}

-#ifdef PROTOTYPES
int
autovars (int bcd, int abc)
-#else
-int
-autovars (bcd, abc)
- int bcd;
- int abc;
-#endif
{
int i0 = useit (0), i1 = useit (1), i2 = useit (2);
int i3 = useit (3), i4 = useit (4), i5 = useit (5);
@@ -172,14 +149,8 @@ autovars (bcd, abc)
+ i91 + i92 + i93 + i94 + i95 + i96 + i97 + i98 + i99 + abc + bcd;
}

-#ifdef PROTOTYPES
int
localscopes (int x)
-#else
-int
-localscopes (x)
- int x;
-#endif
{
int localval;
int retval;
diff --git a/gdb/testsuite/gdb.base/scope1.c b/gdb/testsuite/gdb.base/scope1.c
index 2631ead..e4a7ed2 100644
--- a/gdb/testsuite/gdb.base/scope1.c
+++ b/gdb/testsuite/gdb.base/scope1.c
@@ -43,11 +43,7 @@ void usestatics1 ()
useit1 (&filelocal_ro);
}

-#ifdef PROTOTYPES
void useit1 (const int *val)
-#else
-void useit1 (val) const int *val;
-#endif
{
static int usedval;

diff --git a/gdb/testsuite/gdb.base/setshow.c b/gdb/testsuite/gdb.base/setshow.c
index a30ef82..c8e843c 100644
--- a/gdb/testsuite/gdb.base/setshow.c
+++ b/gdb/testsuite/gdb.base/setshow.c
@@ -3,15 +3,8 @@

#include <stdio.h>

-#ifdef PROTOTYPES
int
main(int argc, char **argv)
-#else
-int
-main(argc, argv)
- int argc;
- char **argv;
-#endif
{
int i = 1;

diff --git a/gdb/testsuite/gdb.base/setvar.c b/gdb/testsuite/gdb.base/setvar.c
index 5d08602..1b8d808 100644
--- a/gdb/testsuite/gdb.base/setvar.c
+++ b/gdb/testsuite/gdb.base/setvar.c
@@ -1,13 +1,6 @@
#include <stdlib.h>

-#ifdef PROTOTYPES
int main (int argc, char **argv, char **envp)
-#else
-main (argc, argv, envp)
- int argc;
- char **argv;
- char **envp;
-#endif
{
extern void dummy();
dummy();
diff --git a/gdb/testsuite/gdb.base/shmain.c b/gdb/testsuite/gdb.base/shmain.c
index d2dc2f3..e36f84f 100644
--- a/gdb/testsuite/gdb.base/shmain.c
+++ b/gdb/testsuite/gdb.base/shmain.c
@@ -18,22 +18,12 @@ struct {

int g;

-#ifdef PROTOTYPES
int local_structarg(struct s x)
-#else
-int local_structarg(x)
-struct s x;
-#endif
{
return x.b;
}

-#ifdef PROTOTYPES
int mainshr1(int g)
-#else
-int mainshr1(g)
-int g;
-#endif
{
return 2*g;
}
diff --git a/gdb/testsuite/gdb.base/shr1.c b/gdb/testsuite/gdb.base/shr1.c
index 117119a..da7bffa 100644
--- a/gdb/testsuite/gdb.base/shr1.c
+++ b/gdb/testsuite/gdb.base/shr1.c
@@ -7,12 +7,7 @@ float sg = 5.5;
int sgi = 2;
static int sgs = 7;

-#ifdef PROTOTYPES
int shr1(int x)
-#else
-int shr1(x)
-int x;
-#endif
{
f mumble;
int l;
@@ -29,32 +24,17 @@ int x;
return 2*x;
}

-#ifdef PROTOTYPES
static int shr1_local(int x)
-#else
-static int shr1_local(x)
-int x;
-#endif
{
return 2*x;
}

-#ifdef PROTOTYPES
int structarg(struct s x)
-#else
-int structarg(x)
-struct s x;
-#endif
{
return x.a;
}

-#ifdef PROTOTYPES
int pstructarg(struct s *x)
-#else
-int pstructarg(x)
-struct s *x;
-#endif
{
return x->a;
}
diff --git a/gdb/testsuite/gdb.base/shr2.c b/gdb/testsuite/gdb.base/shr2.c
index 36a71b3..1007b61 100644
--- a/gdb/testsuite/gdb.base/shr2.c
+++ b/gdb/testsuite/gdb.base/shr2.c
@@ -1,17 +1,9 @@
-#ifdef PROTOTYPES
int shr2(int x)
-#else
-int shr2(x) int x;
-#endif
{
return 2*x; /* shr2-return */
}

-#ifdef PROTOTYPES
int shr2_local(int x)
-#else
-int shr2_local(x) int x;
-#endif
{
return 2*x;
}
diff --git a/gdb/testsuite/gdb.base/sigall.c b/gdb/testsuite/gdb.base/sigall.c
index 283cef3..81f3b08 100644
--- a/gdb/testsuite/gdb.base/sigall.c
+++ b/gdb/testsuite/gdb.base/sigall.c
@@ -5,784 +5,358 @@
/* Signal handlers, we set breakpoints in them to make sure that the
signals really get delivered. */

-#ifdef PROTOTYPES
void
handle_ABRT (int sig)
-#else
-void
-handle_ABRT (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_HUP (int sig)
-#else
-void
-handle_HUP (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_QUIT (int sig)
-#else
-void
-handle_QUIT (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_ILL (int sig)
-#else
-void
-handle_ILL (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_EMT (int sig)
-#else
-void
-handle_EMT (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_FPE (int sig)
-#else
-void
-handle_FPE (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_BUS (int sig)
-#else
-void
-handle_BUS (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_SEGV (int sig)
-#else
-void
-handle_SEGV (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_SYS (int sig)
-#else
-void
-handle_SYS (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_PIPE (int sig)
-#else
-void
-handle_PIPE (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_ALRM (int sig)
-#else
-void
-handle_ALRM (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_URG (int sig)
-#else
-void
-handle_URG (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_TSTP (int sig)
-#else
-void
-handle_TSTP (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_CONT (int sig)
-#else
-void
-handle_CONT (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_CHLD (int sig)
-#else
-void
-handle_CHLD (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_TTIN (int sig)
-#else
-void
-handle_TTIN (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_TTOU (int sig)
-#else
-void
-handle_TTOU (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_IO (int sig)
-#else
-void
-handle_IO (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_XCPU (int sig)
-#else
-void
-handle_XCPU (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_XFSZ (int sig)
-#else
-void
-handle_XFSZ (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_VTALRM (int sig)
-#else
-void
-handle_VTALRM (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_PROF (int sig)
-#else
-void
-handle_PROF (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_WINCH (int sig)
-#else
-void
-handle_WINCH (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_LOST (int sig)
-#else
-void
-handle_LOST (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_USR1 (int sig)
-#else
-void
-handle_USR1 (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_USR2 (int sig)
-#else
-void
-handle_USR2 (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_PWR (int sig)
-#else
-void
-handle_PWR (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_POLL (int sig)
-#else
-void
-handle_POLL (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_WIND (int sig)
-#else
-void
-handle_WIND (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_PHONE (int sig)
-#else
-void
-handle_PHONE (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_WAITING (int sig)
-#else
-void
-handle_WAITING (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_LWP (int sig)
-#else
-void
-handle_LWP (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_DANGER (int sig)
-#else
-void
-handle_DANGER (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_GRANT (int sig)
-#else
-void
-handle_GRANT (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_RETRACT (int sig)
-#else
-void
-handle_RETRACT (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_MSG (int sig)
-#else
-void
-handle_MSG (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_SOUND (int sig)
-#else
-void
-handle_SOUND (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_SAK (int sig)
-#else
-void
-handle_SAK (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_PRIO (int sig)
-#else
-void
-handle_PRIO (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_33 (int sig)
-#else
-void
-handle_33 (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_34 (int sig)
-#else
-void
-handle_34 (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_35 (int sig)
-#else
-void
-handle_35 (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_36 (int sig)
-#else
-void
-handle_36 (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_37 (int sig)
-#else
-void
-handle_37 (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_38 (int sig)
-#else
-void
-handle_38 (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_39 (int sig)
-#else
-void
-handle_39 (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_40 (int sig)
-#else
-void
-handle_40 (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_41 (int sig)
-#else
-void
-handle_41 (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_42 (int sig)
-#else
-void
-handle_42 (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_43 (int sig)
-#else
-void
-handle_43 (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_44 (int sig)
-#else
-void
-handle_44 (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_45 (int sig)
-#else
-void
-handle_45 (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_46 (int sig)
-#else
-void
-handle_46 (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_47 (int sig)
-#else
-void
-handle_47 (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_48 (int sig)
-#else
-void
-handle_48 (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_49 (int sig)
-#else
-void
-handle_49 (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_50 (int sig)
-#else
-void
-handle_50 (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_51 (int sig)
-#else
-void
-handle_51 (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_52 (int sig)
-#else
-void
-handle_52 (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_53 (int sig)
-#else
-void
-handle_53 (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_54 (int sig)
-#else
-void
-handle_54 (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_55 (int sig)
-#else
-void
-handle_55 (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_56 (int sig)
-#else
-void
-handle_56 (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_57 (int sig)
-#else
-void
-handle_57 (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_58 (int sig)
-#else
-void
-handle_58 (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_59 (int sig)
-#else
-void
-handle_59 (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_60 (int sig)
-#else
-void
-handle_60 (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_61 (int sig)
-#else
-void
-handle_61 (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_62 (int sig)
-#else
-void
-handle_62 (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_63 (int sig)
-#else
-void
-handle_63 (sig)
- int sig;
-#endif
{
}

-#ifdef PROTOTYPES
void
handle_TERM (int sig)
-#else
-void
-handle_TERM (sig)
- int sig;
-#endif
{
}
\f
diff --git a/gdb/testsuite/gdb.base/signals.c b/gdb/testsuite/gdb.base/signals.c
index 51e97c4..7566068 100644
--- a/gdb/testsuite/gdb.base/signals.c
+++ b/gdb/testsuite/gdb.base/signals.c
@@ -6,14 +6,8 @@

static int count = 0;

-#ifdef PROTOTYPES
static void
handler (int sig)
-#else
-static void
-handler (sig)
- int sig;
-#endif
{
signal (sig, handler);
++count;
diff --git a/gdb/testsuite/gdb.base/so-indr-cl.c b/gdb/testsuite/gdb.base/so-indr-cl.c
index f31800d..9b5e5a9 100644
--- a/gdb/testsuite/gdb.base/so-indr-cl.c
+++ b/gdb/testsuite/gdb.base/so-indr-cl.c
@@ -3,18 +3,10 @@
*/

#include <stdio.h>
-#ifdef PROTOTYPES
extern "C" int solib_main (int);

static int
solib_wrapper (int (*function)(int))
-#else
-extern int solib_main (int);
-
-static int
-solib_wrapper (function)
- int (*function)(int);
-#endif
{
return (*function)(100);
}
diff --git a/gdb/testsuite/gdb.base/solib2.c b/gdb/testsuite/gdb.base/solib2.c
index 8c69d8b..131c337 100644
--- a/gdb/testsuite/gdb.base/solib2.c
+++ b/gdb/testsuite/gdb.base/solib2.c
@@ -5,12 +5,7 @@
#ifdef __cplusplus
extern "C" {
#endif
-#ifdef PROTOTYPES
int solib_main (int arg)
-#else
-int solib_main (arg)
- int arg;
-#endif
{
return arg*arg*arg;
}
diff --git a/gdb/testsuite/gdb.base/structs.c b/gdb/testsuite/gdb.base/structs.c
index d0b69a8..1fb4250 100644
--- a/gdb/testsuite/gdb.base/structs.c
+++ b/gdb/testsuite/gdb.base/structs.c
@@ -193,165 +193,75 @@ struct struct18 fun18()
return foo18;
}

-#ifdef PROTOTYPES
void Fun1(struct struct1 foo1)
-#else
-void Fun1(foo1)
- struct struct1 foo1;
-#endif
{
L1 = foo1;
}
-#ifdef PROTOTYPES
void Fun2(struct struct2 foo2)
-#else
-void Fun2(foo2)
- struct struct2 foo2;
-#endif
{
L2 = foo2;
}
-#ifdef PROTOTYPES
void Fun3(struct struct3 foo3)
-#else
-void Fun3(foo3)
- struct struct3 foo3;
-#endif
{
L3 = foo3;
}
-#ifdef PROTOTYPES
void Fun4(struct struct4 foo4)
-#else
-void Fun4(foo4)
- struct struct4 foo4;
-#endif
{
L4 = foo4;
}
-#ifdef PROTOTYPES
void Fun5(struct struct5 foo5)
-#else
-void Fun5(foo5)
- struct struct5 foo5;
-#endif
{
L5 = foo5;
}
-#ifdef PROTOTYPES
void Fun6(struct struct6 foo6)
-#else
-void Fun6(foo6)
- struct struct6 foo6;
-#endif
{
L6 = foo6;
}
-#ifdef PROTOTYPES
void Fun7(struct struct7 foo7)
-#else
-void Fun7(foo7)
- struct struct7 foo7;
-#endif
{
L7 = foo7;
}
-#ifdef PROTOTYPES
void Fun8(struct struct8 foo8)
-#else
-void Fun8(foo8)
- struct struct8 foo8;
-#endif
{
L8 = foo8;
}
-#ifdef PROTOTYPES
void Fun9(struct struct9 foo9)
-#else
-void Fun9(foo9)
- struct struct9 foo9;
-#endif
{
L9 = foo9;
}
-#ifdef PROTOTYPES
void Fun10(struct struct10 foo10)
-#else
-void Fun10(foo10)
- struct struct10 foo10;
-#endif
{
L10 = foo10;
}
-#ifdef PROTOTYPES
void Fun11(struct struct11 foo11)
-#else
-void Fun11(foo11)
- struct struct11 foo11;
-#endif
{
L11 = foo11;
}
-#ifdef PROTOTYPES
void Fun12(struct struct12 foo12)
-#else
-void Fun12(foo12)
- struct struct12 foo12;
-#endif
{
L12 = foo12;
}
-#ifdef PROTOTYPES
void Fun13(struct struct13 foo13)
-#else
-void Fun13(foo13)
- struct struct13 foo13;
-#endif
{
L13 = foo13;
}
-#ifdef PROTOTYPES
void Fun14(struct struct14 foo14)
-#else
-void Fun14(foo14)
- struct struct14 foo14;
-#endif
{
L14 = foo14;
}
-#ifdef PROTOTYPES
void Fun15(struct struct15 foo15)
-#else
-void Fun15(foo15)
- struct struct15 foo15;
-#endif
{
L15 = foo15;
}
-#ifdef PROTOTYPES
void Fun16(struct struct16 foo16)
-#else
-void Fun16(foo16)
- struct struct16 foo16;
-#endif
{
L16 = foo16;
}
-#ifdef PROTOTYPES
void Fun17(struct struct17 foo17)
-#else
-void Fun17(foo17)
- struct struct17 foo17;
-#endif
{
L17 = foo17;
}
-#ifdef PROTOTYPES
void Fun18(struct struct18 foo18)
-#else
-void Fun18(foo18)
- struct struct18 foo18;
-#endif
{
L18 = foo18;
}
diff --git a/gdb/testsuite/gdb.base/sum.c b/gdb/testsuite/gdb.base/sum.c
index 6dd7a75..3e27fa1 100644
--- a/gdb/testsuite/gdb.base/sum.c
+++ b/gdb/testsuite/gdb.base/sum.c
@@ -1,12 +1,7 @@
/* This is a sample program for the HP/DDE debugger. */
#include <stdio.h>

-#ifdef PROTOTYPES
int sum(int *list, int low, int high)
-#else
-int sum(list, low, high)
-int *list, low, high;
-#endif
{
int i = 0, s = 0; /* stop-in-sum */
for (i = low; i <= high; i++)
diff --git a/gdb/testsuite/gdb.base/vforked-prog.c b/gdb/testsuite/gdb.base/vforked-prog.c
index 763e5d9..818ad98 100644
--- a/gdb/testsuite/gdb.base/vforked-prog.c
+++ b/gdb/testsuite/gdb.base/vforked-prog.c
@@ -17,11 +17,7 @@

#include <stdio.h>

-#ifdef PROTOTYPES
int main (void)
-#else
-main()
-#endif
{
printf("Hello from vforked-prog...\n");
return 0;
diff --git a/gdb/testsuite/gdb.base/watchpoint.c b/gdb/testsuite/gdb.base/watchpoint.c
index 92fb3b1..60f60d6 100644
--- a/gdb/testsuite/gdb.base/watchpoint.c
+++ b/gdb/testsuite/gdb.base/watchpoint.c
@@ -81,11 +81,7 @@ void marker6 ()
{
}

-#ifdef PROTOTYPES
void recurser (int x)
-#else
-void recurser (x) int x;
-#endif
{
int local_x = 0;

diff --git a/gdb/testsuite/gdb.reverse/shr2.c b/gdb/testsuite/gdb.reverse/shr2.c
index 52ed6b2..1329df1 100644
--- a/gdb/testsuite/gdb.reverse/shr2.c
+++ b/gdb/testsuite/gdb.reverse/shr2.c
@@ -17,20 +17,12 @@

#include "shr.h"

-#ifdef PROTOTYPES
int shr2(int x)
-#else
-int shr2(x) int x;
-#endif
{
return 2*x;
}

-#ifdef PROTOTYPES
int shr2_local(int x)
-#else
-int shr2_local(x) int x;
-#endif
{
return 2*x;
}
diff --git a/gdb/testsuite/gdb.reverse/until-reverse.c b/gdb/testsuite/gdb.reverse/until-reverse.c
index 28c71b2..80581b4 100644
--- a/gdb/testsuite/gdb.reverse/until-reverse.c
+++ b/gdb/testsuite/gdb.reverse/until-reverse.c
@@ -18,34 +18,20 @@
#include <stdio.h>
#include <stdlib.h>

-#ifdef PROTOTYPES
extern int marker1 (void);
extern int marker2 (int a);
extern void marker3 (char *a, char *b);
extern void marker4 (long d);
-#else
-extern int marker1 ();
-extern int marker2 ();
-extern void marker3 ();
-extern void marker4 ();
-#endif

/*
* This simple classical example of recursion is useful for
* testing stack backtraces and such.
*/

-#ifdef PROTOTYPES
int factorial(int);

int
main (int argc, char **argv, char **envp)
-#else
-int
-main (argc, argv, envp)
-int argc;
-char *argv[], **envp;
-#endif
{
if (argc == 12345) { /* an unlikely value < 2^16, in case uninited */ /* set breakpoint 6 here */
fprintf (stderr, "usage: factorial <number>\n");
@@ -65,12 +51,7 @@ char *argv[], **envp;
return argc; /* set breakpoint 10 here */
} /* set breakpoint 10a here */

-#ifdef PROTOTYPES
int factorial (int value)
-#else
-int factorial (value)
-int value;
-#endif
{
if (value > 1) { /* set breakpoint 7 here */
value *= factorial (value - 1);
@@ -78,12 +59,7 @@ int value;
return (value); /* set breakpoint 19 here */
}

-#ifdef PROTOTYPES
int multi_line_if_conditional (int a, int b, int c)
-#else
-int multi_line_if_conditional (a, b, c)
- int a, b, c;
-#endif
{
if (a /* set breakpoint 3 here */
&& b
@@ -93,12 +69,7 @@ int multi_line_if_conditional (a, b, c)
return 1;
}

-#ifdef PROTOTYPES
int multi_line_while_conditional (int a, int b, int c)
-#else
-int multi_line_while_conditional (a, b, c)
- int a, b, c;
-#endif
{
while (a /* set breakpoint 4 here */
&& b
diff --git a/gdb/testsuite/gdb.reverse/ur1.c b/gdb/testsuite/gdb.reverse/ur1.c
index b07e211..3147646 100644
--- a/gdb/testsuite/gdb.reverse/ur1.c
+++ b/gdb/testsuite/gdb.reverse/ur1.c
@@ -26,17 +26,10 @@
These functions are in a separate source file to prevent an
optimizing compiler from inlining them and optimizing them away. */

-#ifdef PROTOTYPES
int marker1 (void) { return (0); } /* set breakpoint 15 here */
int marker2 (int a) { return (1); } /* set breakpoint 8 here */
void marker3 (char *a, char *b) {} /* set breakpoint 17 here */
void marker4 (long d) {} /* set breakpoint 14 here */
-#else
-int marker1 () { return (0); } /* set breakpoint 16 here */
-int marker2 (a) int a; { return (1); } /* set breakpoint 9 here */
-void marker3 (a, b) char *a, *b; {} /* set breakpoint 18 here */
-void marker4 (d) long d; {} /* set breakpoint 13 here */
-#endif

/* A structure we use for field name completion tests. */
struct some_struct
diff --git a/gdb/testsuite/gdb.reverse/watch-reverse.c b/gdb/testsuite/gdb.reverse/watch-reverse.c
index 7244793..2f7b180 100644
--- a/gdb/testsuite/gdb.reverse/watch-reverse.c
+++ b/gdb/testsuite/gdb.reverse/watch-reverse.c
@@ -78,11 +78,7 @@ void marker6 ()
{
}

-#ifdef PROTOTYPES
void recurser (int x)
-#else
-void recurser (x) int x;
-#endif
{
int local_x;

--
1.8.4.2