* ggc.h: Convert to ISO C90 prototypes.

	* ggc-none.c: Likewise.
	* ggc-common.c: Likewise.
	* ggc-page.c: Likewise.
	* ggc-simple.c: Likewise.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@67596 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 53 insertions, 61 deletions

diff --git a/gcc/ggc.h b/gcc/ggc.h
index e1364a3a84e..2f7d09c3d6f 100644
--- a/gcc/ggc.h
+++ b/gcc/ggc.h
@@ -1,5 +1,6 @@
 /* Garbage collection for the GNU compiler.
-   Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
+   Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003
+   Free Software Foundation, Inc.
 
 This file is part of GCC.
 
@@ -30,35 +31,33 @@ extern const char digit_vector[];	/* "0" .. "9" */
    machinery.  */
 
 /* The first parameter is a pointer to a pointer, the second a cookie.  */
-typedef void (*gt_pointer_operator) PARAMS ((void *, void *));
+typedef void (*gt_pointer_operator) (void *, void *);
 
 #include "gtype-desc.h"
 
 /* One of these applies its third parameter (with cookie in the fourth
    parameter) to each pointer in the object pointed to by the first
    parameter, using the second parameter.  */
-typedef void (*gt_note_pointers) 
-     PARAMS ((void *, void *, gt_pointer_operator, void *));
+typedef void (*gt_note_pointers) (void *, void *, gt_pointer_operator,
+				  void *);
 
 /* One of these is called before objects are re-ordered in memory.
    The first parameter is the original object, the second is the
    subobject that has had its pointers reordered, the third parameter
    can compute the new values of a pointer when given the cookie in
    the fourth parameter.  */
-typedef void (*gt_handle_reorder)
-     PARAMS ((void *, void *, gt_pointer_operator, void *));
+typedef void (*gt_handle_reorder) (void *, void *, gt_pointer_operator,
+				   void *);
 
 /* Used by the gt_pch_n_* routines.  Register an object in the hash table.  */
-extern int gt_pch_note_object 
-     PARAMS ((void *, void *, gt_note_pointers));
+extern int gt_pch_note_object (void *, void *, gt_note_pointers);
 
-/* Used by the gt_pch_n_* routines.  Register that an object has a reorder 
+/* Used by the gt_pch_n_* routines.  Register that an object has a reorder
    function.  */
-extern void gt_pch_note_reorder
-     PARAMS ((void *, void *, gt_handle_reorder));
+extern void gt_pch_note_reorder (void *, void *, gt_handle_reorder);
 
 /* Mark the object in the first parameter and anything it points to.  */
-typedef void (*gt_pointer_walker) PARAMS ((void *));
+typedef void (*gt_pointer_walker) (void *);
 
 /* Structures for the easy way to mark roots.
    In an array, terminated by having base == NULL.*/
@@ -84,7 +83,7 @@ struct ggc_cache_tab {
   size_t stride;
   gt_pointer_walker cb;
   gt_pointer_walker pchw;
-  int (*marked_p) PARAMS ((const void *));
+  int (*marked_p) (const void *);
 };
 #define LAST_GGC_CACHE_TAB { NULL, 0, 0, NULL, NULL, NULL }
 /* Pointers to arrays of ggc_cache_tab, terminated by NULL.  */
@@ -107,102 +106,95 @@ extern const struct ggc_cache_tab * const gt_ggc_cache_rtab[];
    returns zero if the object was not previously marked; non-zero if
    the object was already marked, or if, for any other reason,
    pointers in this data structure should not be traversed.  */
-extern int ggc_set_mark			PARAMS ((const void *));
+extern int ggc_set_mark	(const void *);
 
 /* Return 1 if P has been marked, zero otherwise.
    P must have been allocated by the GC allocator; it mustn't point to
    static objects, stack variables, or memory allocated with malloc.  */
-extern int ggc_marked_p			PARAMS ((const void *));
+extern int ggc_marked_p	(const void *);
 
 /* Mark the entries in the string pool.  */
-extern void ggc_mark_stringpool		PARAMS ((void));
+extern void ggc_mark_stringpool	(void);
 
 /* Call ggc_set_mark on all the roots.  */
 
-extern void ggc_mark_roots		PARAMS ((void));
+extern void ggc_mark_roots (void);
 
 /* Save and restore the string pool entries for PCH.  */
 
-extern void gt_pch_save_stringpool	PARAMS ((void));
-extern void gt_pch_fixup_stringpool     PARAMS ((void));
-extern void gt_pch_restore_stringpool	PARAMS ((void));
+extern void gt_pch_save_stringpool (void);
+extern void gt_pch_fixup_stringpool (void);
+extern void gt_pch_restore_stringpool (void);
 
 /* PCH and GGC handling for strings, mostly trivial.  */
 
-extern void gt_pch_p_S			PARAMS ((void *, void *,
-						 gt_pointer_operator, void *));
-extern void gt_pch_n_S			PARAMS ((const void *));
-extern void gt_ggc_m_S			PARAMS ((void *));
+extern void gt_pch_p_S (void *, void *, gt_pointer_operator, void *);
+extern void gt_pch_n_S (const void *);
+extern void gt_ggc_m_S (void *);
 
 /* Initialise the string pool.  */
-extern void init_stringpool	PARAMS ((void));
+extern void init_stringpool (void);
 
 /* A GC implementation must provide these functions.  They are internal
    to the GC system.  */
 
 /* Initialize the garbage collector.  */
-extern void init_ggc		PARAMS ((void));
+extern void init_ggc (void);
 
 /* Start a new GGC context.  Memory allocated in previous contexts
    will not be collected while the new context is active.  */
-extern void ggc_push_context	PARAMS ((void));
+extern void ggc_push_context (void);
 
 /* Finish a GC context.  Any uncollected memory in the new context
    will be merged with the old context.  */
-extern void ggc_pop_context 	PARAMS ((void));
+extern void ggc_pop_context (void);
 
 struct ggc_pch_data;
 
 /* Return a new ggc_pch_data structure.  */
-extern struct ggc_pch_data *init_ggc_pch PARAMS ((void));
+extern struct ggc_pch_data *init_ggc_pch (void);
 
 /* The second parameter and third parameters give the address and size
    of an object.  Update the ggc_pch_data structure with as much of
    that information as is necessary.  */
-extern void ggc_pch_count_object	PARAMS ((struct ggc_pch_data *,
-						 void *, size_t));
+extern void ggc_pch_count_object (struct ggc_pch_data *, void *, size_t);
 
-/* Return the total size of the data to be written to hold all 
+/* Return the total size of the data to be written to hold all
    the objects previously passed to ggc_pch_count_object.  */
-extern size_t ggc_pch_total_size	PARAMS ((struct ggc_pch_data *));
+extern size_t ggc_pch_total_size (struct ggc_pch_data *);
 
 /* The objects, when read, will most likely be at the address
    in the second parameter.  */
-extern void ggc_pch_this_base		PARAMS ((struct ggc_pch_data *,
-						 void *));
+extern void ggc_pch_this_base (struct ggc_pch_data *, void *);
 
 /* Assuming that the objects really do end up at the address
    passed to ggc_pch_this_base, return the address of this object.  */
-extern char *ggc_pch_alloc_object	PARAMS ((struct ggc_pch_data *,
-						 void *, size_t));
+extern char *ggc_pch_alloc_object (struct ggc_pch_data *, void *, size_t);
 
 /* Write out any initial information required.  */
-extern void ggc_pch_prepare_write	PARAMS ((struct ggc_pch_data *,
-						 FILE *));
+extern void ggc_pch_prepare_write (struct ggc_pch_data *, FILE *);
 /* Write out this object, including any padding.  */
-extern void ggc_pch_write_object	PARAMS ((struct ggc_pch_data *,
-						 FILE *, void *, void *,
-						 size_t));
+extern void ggc_pch_write_object (struct ggc_pch_data *, FILE *, void *,
+				  void *, size_t);
 /* All objects have been written, write out any final information
    required.  */
-extern void ggc_pch_finish		PARAMS ((struct ggc_pch_data *,
-						 FILE *));
+extern void ggc_pch_finish (struct ggc_pch_data *, FILE *);
 
 /* A PCH file has just been read in at the address specified second
    parameter.  Set up the GC implementation for the new objects.  */
-extern void ggc_pch_read PARAMS ((FILE *, void *));
+extern void ggc_pch_read (FILE *, void *);
 
 
 /* Allocation.  */
 
 /* The internal primitive.  */
-extern void *ggc_alloc		PARAMS ((size_t));
+extern void *ggc_alloc (size_t);
 /* Like ggc_alloc, but allocates cleared memory.  */
-extern void *ggc_alloc_cleared	PARAMS ((size_t));
+extern void *ggc_alloc_cleared (size_t);
 /* Resize a block.  */
-extern void *ggc_realloc	PARAMS ((void *, size_t));
+extern void *ggc_realloc (void *, size_t);
 /* Like ggc_alloc_cleared, but performs a multiplication.  */
-extern void *ggc_calloc		PARAMS ((size_t, size_t));
+extern void *ggc_calloc (size_t, size_t);
 
 #define ggc_alloc_rtx(NSLOTS)						  \
   ((struct rtx_def *) ggc_alloc (sizeof (struct rtx_def)		  \
@@ -221,8 +213,8 @@ extern void *ggc_calloc		PARAMS ((size_t, size_t));
   splay_tree_new_with_allocator (COMPARE, NULL, NULL,			 \
                                  &ggc_splay_alloc, &ggc_splay_dont_free, \
 				 NULL)
-extern PTR ggc_splay_alloc PARAMS ((int, void *));
-extern void ggc_splay_dont_free PARAMS ((void *, void *));
+extern void *ggc_splay_alloc (int, void *);
+extern void ggc_splay_dont_free (void *, void *);
 
 /* Allocate a gc-able string, and fill it with LENGTH bytes from CONTENTS.
    If LENGTH is -1, then CONTENTS is assumed to be a
@@ -235,16 +227,16 @@ extern const char *ggc_alloc_string	PARAMS ((const char *contents,
 
 /* Invoke the collector.  Garbage collection occurs only when this
    function is called, not during allocations.  */
-extern void ggc_collect			PARAMS ((void));
+extern void ggc_collect	(void);
 
 /* Return the number of bytes allocated at the indicated address.  */
-extern size_t ggc_get_size		PARAMS ((const void *));
+extern size_t ggc_get_size (const void *);
 
 /* Write out all GCed objects to F.  */
-extern void gt_pch_save			PARAMS ((FILE *f));
+extern void gt_pch_save (FILE *f);
 
 /* Read objects previously saved with gt_pch_save from F.  */
-extern void gt_pch_restore		PARAMS ((FILE *f));
+extern void gt_pch_restore (FILE *f);
 
 /* Statistics.  */
 
@@ -258,13 +250,13 @@ typedef struct ggc_statistics
 
 /* Used by the various collectors to gather and print statistics that
    do not depend on the collector in use.  */
-extern void ggc_print_common_statistics PARAMS ((FILE *, ggc_statistics *));
+extern void ggc_print_common_statistics (FILE *, ggc_statistics *);
 
 /* Print allocation statistics.  */
-extern void ggc_print_statistics	PARAMS ((void));
-extern void stringpool_statistics	PARAMS ((void));
+extern void ggc_print_statistics (void);
+extern void stringpool_statistics (void);
 
 /* Heuristics.  */
-extern int ggc_min_expand_heuristic PARAMS ((void));
-extern int ggc_min_heapsize_heuristic PARAMS ((void));
-extern void init_ggc_heuristics PARAMS ((void));
+extern int ggc_min_expand_heuristic (void);
+extern int ggc_min_heapsize_heuristic (void);
+extern void init_ggc_heuristics (void);