Convert libiberty to use ISO C prototype style 4/n
Mostafa Hagog
MUSTAFA@il.ibm.com
Sun Mar 27 17:15:00 GMT 2005
I didn't see that this patch was approved to be committed , am I missing
something?
(http://gcc.gnu.org/ml/gcc-cvs/2005-03/msg01320.html)
Anyway, this causes the following error when trying to build gcc on
powerpc-apple-darwin:
gcc -c -DHAVE_CONFIG_H -g -O2 -I. -I../../../gcc/libiberty/../include -W
-Wall -Wtraditional -pedantic ../../../gcc/libiberty/getopt1.c -o getopt1.o
../../../gcc/libiberty/getopt1.c: In function `getopt_long':
../../../gcc/libiberty/getopt1.c:71: warning: traditional C rejects ISO C
style function definitions
../../../gcc/libiberty/getopt1.c: At top level:
../../../gcc/libiberty/getopt1.c:83: error: conflicting types for
'getopt_long_only'
../../../gcc/libiberty/../include/getopt.h:125: error: previous declaration
of 'getopt_long_only' was here
../../../gcc/libiberty/getopt1.c: In function `getopt_long_only':
../../../gcc/libiberty/getopt1.c:83: warning: traditional C rejects ISO C
style function definitions
../../../gcc/libiberty/getopt1.c:84: warning: passing arg 3 of
`_getopt_internal' from incompatible pointer type
make[1]: *** [getopt1.o] Error 1
make: *** [all-build-libiberty] Error 2
Mostafa.
gcc-patches-owner@gcc.gnu.org wrote on 27/03/2005 17:27:30:
>
> Yet, another set.
>
> -- Gaby
> include/
> 2005-03-27 Gabriel Dos Reis <gdr@integrable-solutions.net>
>
> * md5.h: Remove definition and uses of __P.
> * dyn-string.h: Remove uses of PARAMS.
> * fibheap.h: Likewise.
> * floatformat.h: Likewise.
> * hashtab.h: Likewise.
>
> libiberty/
> 2005-03-27 Gabriel Dos Reis <gdr@integrable-solutions.net>
>
> Convert libiberty to use ISO C prototype style 4/n.
> * hashtab.c (higher_prime_index, hash_pointer, eq_pointer,
> htab_size, htab_elements, htab_mod_1, htab_mod, htab_mod_m2,
> htab_create_alloc, htab_set_functions_ex, htab_create,
> htab_try_create, htab_delete, htab_empty,
> find_empty_slot_for_expand, htab_expand, htab_find_with_hash,
> htab_find, htab_find_slot_with_hash, htab_find_slot,
> htab_remove_elt, htab_remove_elt_with_hash, htab_clear_slot,
> htab_traverse_noresize, htab_traverse, htab_collisions,
> htab_hash_string, iterative_hash): Use ISO C prototype.
> * hex.c (hex_init): Likewise.
> * index.c (index): Likewise.
> * insque.c (insque, remque): Likewise.
> * lbasename.c (lbasename): Likewise.
> * lrealpath.c (lrealpath): Likewise.
> * make-relative-prefix.c (save_string, split_directories,
> free_split_directories, make_relative_prefix): Likewise.
> * make-temp-file.c (try, choose_tmpdir, make_temp_file): Likewise.
> * md5.c (md5_init_ctx, md5_read_ctx, md5_finish_ctx, md5_stream,
> md5_buffer, md5_process_bytes, md5_process_block): Likewise.
> * memchr.c (memchr): Likewise.
> * memcpy.c (memcpy): Likewise.
> * memmove.c (memmove): Likewise.
> * gettimeofday.c (gettimeofday): Likewise.
> * getruntime.c (get_run_time): Likewise.
> * getpwd.c (getpwd, getpwd): Likewise.
> * getpagesize.c (getpagesize): Likewise.
> * getopt1.c (getopt_long, getopt_long_only, main): Likewise.
> * getopt.c (my_index, exchange, _getopt_initialize,
> _getopt_internal, getopt, main): Likewise.
> * getcwd.c (getcwd): Likewise.
> * fnmatch.c (fnmatch): Likewise.
> * floatformat.c (floatformat_always_valid,
> floatformat_i387_ext_is_valid, get_field, floatformat_to_double,
> put_field, floatformat_from_double, floatformat_is_valid,
> ieee_test, main): Likewise.
> * fibheap.c (fibheap_new, fibnode_new, fibheap_compare,
> fibheap_comp_data, fibheap_insert, fibheap_min, fibheap_min_key,
> fibheap_union, fibheap_extract_min, fibheap_replace_key_data,
> fibheap_replace_key, fibheap_replace_data, fibheap_delete_node,
> fibheap_delete, fibheap_empty, fibheap_extr_min_node,
> fibheap_ins_root, fibheap_rem_root, fibheap_consolidate,
> fibheap_link, fibheap_cut, fibheap_cascading_cut,
> fibnode_insert_after, fibnode_remove): Likewise.
> * ffs.c (ffs): Likewise.
> * fdmatch.c (fdmatch): Likewise.
> * dyn-string.c (dyn_string_init, dyn_string_new,
> dyn_string_delete, dyn_string_release, dyn_string_resize,
> dyn_string_clear, dyn_string_copy, dyn_string_copy_cstr,
> dyn_string_prepend, dyn_string_prepend_cstr, dyn_string_insert,
> dyn_string_insert_cstr, dyn_string_insert_char,
> dyn_string_append, dyn_string_append_cstr,
> dyn_string_append_char, dyn_string_substring, dyn_string_eq):
> Likewise.
>
> Index: include/dyn-string.h
> ===================================================================
> RCS file: /cvs/gcc/gcc/include/dyn-string.h,v
> retrieving revision 1.8
> diff -p -r1.8 dyn-string.h
> *** include/dyn-string.h 25 Feb 2004 01:42:20 -0000 1.8
> --- include/dyn-string.h 27 Mar 2005 14:36:14 -0000
> *************** typedef struct dyn_string
> *** 40,63 ****
> (strcmp ((DS1)->s, (DS2)->s))
>
>
> ! extern int dyn_string_init PARAMS ((struct dyn_string*,
int));
> ! extern dyn_string_t dyn_string_new PARAMS ((int));
> ! extern void dyn_string_delete PARAMS ((dyn_string_t));
> ! extern char *dyn_string_release PARAMS ((dyn_string_t));
> ! extern dyn_string_t dyn_string_resize PARAMS ((dyn_string_t, int));
> ! extern void dyn_string_clear PARAMS ((dyn_string_t));
> ! extern int dyn_string_copy PARAMS ((dyn_string_t,
> dyn_string_t));
> ! extern int dyn_string_copy_cstr PARAMS ((dyn_string_t,
> const char *));
> ! extern int dyn_string_prepend PARAMS ((dyn_string_t,
> dyn_string_t));
> ! extern int dyn_string_prepend_cstr PARAMS ((dyn_string_t,
> const char *));
> ! extern int dyn_string_insert PARAMS ((dyn_string_t, int,
> ! dyn_string_t));
> ! extern int dyn_string_insert_cstr PARAMS ((dyn_string_t, int,
> ! const char *));
> ! extern int dyn_string_insert_char PARAMS ((dyn_string_t, int,
int));
> ! extern int dyn_string_append PARAMS ((dyn_string_t,
> dyn_string_t));
> ! extern int dyn_string_append_cstr PARAMS ((dyn_string_t,
> const char *));
> ! extern int dyn_string_append_char PARAMS ((dyn_string_t, int));
> ! extern int dyn_string_substring PARAMS ((dyn_string_t,
> ! dyn_string_t, int, int));
> ! extern int dyn_string_eq PARAMS ((dyn_string_t,
> dyn_string_t));
> --- 40,60 ----
> (strcmp ((DS1)->s, (DS2)->s))
>
>
> ! extern int dyn_string_init (struct dyn_string *, int);
> ! extern dyn_string_t dyn_string_new (int);
> ! extern void dyn_string_delete (dyn_string_t);
> ! extern char *dyn_string_release (dyn_string_t);
> ! extern dyn_string_t dyn_string_resize (dyn_string_t, int);
> ! extern void dyn_string_clear (dyn_string_t);
> ! extern int dyn_string_copy (dyn_string_t, dyn_string_t);
> ! extern int dyn_string_copy_cstr (dyn_string_t, const char *);
> ! extern int dyn_string_prepend (dyn_string_t, dyn_string_t);
> ! extern int dyn_string_prepend_cstr (dyn_string_t, const char *);
> ! extern int dyn_string_insert (dyn_string_t, int, dyn_string_t);
> ! extern int dyn_string_insert_cstr (dyn_string_t, int, const char *);
> ! extern int dyn_string_insert_char (dyn_string_t, int, int);
> ! extern int dyn_string_append (dyn_string_t, dyn_string_t);
> ! extern int dyn_string_append_cstr (dyn_string_t, const char *);
> ! extern int dyn_string_append_char (dyn_string_t, int);
> ! extern int dyn_string_substring (dyn_string_t, dyn_string_t, int,
int);
> ! extern int dyn_string_eq (dyn_string_t, dyn_string_t);
> Index: include/fibheap.h
> ===================================================================
> RCS file: /cvs/gcc/gcc/include/fibheap.h,v
> retrieving revision 1.8
> diff -p -r1.8 fibheap.h
> *** include/fibheap.h 10 Dec 2004 21:24:58 -0000 1.8
> --- include/fibheap.h 27 Mar 2005 14:36:14 -0000
> *************** typedef struct fibnode
> *** 68,86 ****
> #endif
> } *fibnode_t;
>
> ! extern fibheap_t fibheap_new PARAMS ((void));
> ! extern fibnode_t fibheap_insert PARAMS ((fibheap_t, fibheapkey_t, void
*));
> ! extern int fibheap_empty PARAMS ((fibheap_t));
> ! extern fibheapkey_t fibheap_min_key PARAMS ((fibheap_t));
> ! extern fibheapkey_t fibheap_replace_key PARAMS ((fibheap_t, fibnode_t,
> ! fibheapkey_t));
> ! extern void *fibheap_replace_key_data PARAMS ((fibheap_t, fibnode_t,
> ! fibheapkey_t, void *));
> ! extern void *fibheap_extract_min PARAMS ((fibheap_t));
> ! extern void *fibheap_min PARAMS ((fibheap_t));
> ! extern void *fibheap_replace_data PARAMS ((fibheap_t, fibnode_t, void
*));
> ! extern void *fibheap_delete_node PARAMS ((fibheap_t, fibnode_t));
> ! extern void fibheap_delete PARAMS ((fibheap_t));
> ! extern fibheap_t fibheap_union PARAMS ((fibheap_t, fibheap_t));
>
> #endif /* _FIBHEAP_H_ */
> --- 68,86 ----
> #endif
> } *fibnode_t;
>
> ! extern fibheap_t fibheap_new (void);
> ! extern fibnode_t fibheap_insert (fibheap_t, fibheapkey_t, void *);
> ! extern int fibheap_empty (fibheap_t);
> ! extern fibheapkey_t fibheap_min_key (fibheap_t);
> ! extern fibheapkey_t fibheap_replace_key (fibheap_t, fibnode_t,
> ! fibheapkey_t);
> ! extern void *fibheap_replace_key_data (fibheap_t, fibnode_t,
> ! fibheapkey_t, void *);
> ! extern void *fibheap_extract_min (fibheap_t);
> ! extern void *fibheap_min (fibheap_t);
> ! extern void *fibheap_replace_data (fibheap_t, fibnode_t, void *);
> ! extern void *fibheap_delete_node (fibheap_t, fibnode_t);
> ! extern void fibheap_delete (fibheap_t);
> ! extern fibheap_t fibheap_union (fibheap_t, fibheap_t);
>
> #endif /* _FIBHEAP_H_ */
> Index: include/floatformat.h
> ===================================================================
> RCS file: /cvs/gcc/gcc/include/floatformat.h,v
> retrieving revision 1.10
> diff -p -r1.10 floatformat.h
> *** include/floatformat.h 22 Sep 2003 17:42:03 -0000 1.10
> --- include/floatformat.h 27 Mar 2005 14:36:15 -0000
> *************** struct floatformat
> *** 82,88 ****
> const char *name;
>
> /* Validator method. */
> ! int (*is_valid) PARAMS ((const struct floatformat *fmt, const
> char *from));
> };
>
> /* floatformats for IEEE single and double, big and little endian. */
> --- 82,88 ----
> const char *name;
>
> /* Validator method. */
> ! int (*is_valid) (const struct floatformat *fmt, const char *from);
> };
>
> /* floatformats for IEEE single and double, big and little endian. */
> *************** extern const struct floatformat floatfor
> *** 116,133 ****
> Store the double in *TO. */
>
> extern void
> ! floatformat_to_double PARAMS ((const struct floatformat *, const
> char *, double *));
>
> /* The converse: convert the double *FROM to FMT
> and store where TO points. */
>
> extern void
> ! floatformat_from_double PARAMS ((const struct floatformat *,
> ! const double *, char *));
>
> /* Return non-zero iff the data at FROM is a valid number in format
FMT. */
>
> extern int
> ! floatformat_is_valid PARAMS ((const struct floatformat *fmt, const
> char *from));
>
> #endif /* defined (FLOATFORMAT_H) */
> --- 116,132 ----
> Store the double in *TO. */
>
> extern void
> ! floatformat_to_double (const struct floatformat *, const char *, double
*);
>
> /* The converse: convert the double *FROM to FMT
> and store where TO points. */
>
> extern void
> ! floatformat_from_double (const struct floatformat *, const double
> *, char *);
>
> /* Return non-zero iff the data at FROM is a valid number in format
FMT. */
>
> extern int
> ! floatformat_is_valid (const struct floatformat *fmt, const char *from);
>
> #endif /* defined (FLOATFORMAT_H) */
> Index: include/hashtab.h
> ===================================================================
> RCS file: /cvs/gcc/gcc/include/hashtab.h,v
> retrieving revision 1.22
> diff -p -r1.22 hashtab.h
> *** include/hashtab.h 22 Apr 2004 17:36:03 -0000 1.22
> --- include/hashtab.h 27 Mar 2005 14:36:15 -0000
> *************** typedef unsigned int hashval_t;
> *** 48,85 ****
> /* Callback function pointer types. */
>
> /* Calculate hash of a table entry. */
> ! typedef hashval_t (*htab_hash) PARAMS ((const void *));
>
> /* Compare a table entry with a possible entry. The entry already in
> the table always comes first, so the second element can be of a
> different type (but in this case htab_find and htab_find_slot
> cannot be used; instead the variants that accept a hash value
> must be used). */
> ! typedef int (*htab_eq) PARAMS ((const void *, const void *));
>
> /* Cleanup function called whenever a live element is removed from
> the hash table. */
> ! typedef void (*htab_del) PARAMS ((void *));
>
> /* Function called by htab_traverse for each live element. The first
> arg is the slot of the element (which can be passed to
htab_clear_slot
> if desired), the second arg is the auxiliary pointer handed to
> htab_traverse. Return 1 to continue scan, 0 to stop. */
> ! typedef int (*htab_trav) PARAMS ((void **, void *));
>
> /* Memory-allocation function, with the same functionality as calloc().
> Iff it returns NULL, the hash table implementation will pass an
error
> code back to the user, so if your code doesn't handle errors,
> best if you use xcalloc instead. */
> ! typedef PTR (*htab_alloc) PARAMS ((size_t, size_t));
>
> /* We also need a free() routine. */
> ! typedef void (*htab_free) PARAMS ((PTR));
>
> /* Memory allocation and deallocation; variants which take an extra
> argument. */
> ! typedef PTR (*htab_alloc_with_arg) PARAMS ((void *, size_t, size_t));
> ! typedef void (*htab_free_with_arg) PARAMS ((void *, void *));
>
> /* Hash tables are of the following type. The structure
> (implementation) of this type is not needed for using the hash
> --- 48,85 ----
> /* Callback function pointer types. */
>
> /* Calculate hash of a table entry. */
> ! typedef hashval_t (*htab_hash) (const void *);
>
> /* Compare a table entry with a possible entry. The entry already in
> the table always comes first, so the second element can be of a
> different type (but in this case htab_find and htab_find_slot
> cannot be used; instead the variants that accept a hash value
> must be used). */
> ! typedef int (*htab_eq) (const void *, const void *);
>
> /* Cleanup function called whenever a live element is removed from
> the hash table. */
> ! typedef void (*htab_del) (void *);
>
> /* Function called by htab_traverse for each live element. The first
> arg is the slot of the element (which can be passed to
htab_clear_slot
> if desired), the second arg is the auxiliary pointer handed to
> htab_traverse. Return 1 to continue scan, 0 to stop. */
> ! typedef int (*htab_trav) (void **, void *);
>
> /* Memory-allocation function, with the same functionality as calloc().
> Iff it returns NULL, the hash table implementation will pass an
error
> code back to the user, so if your code doesn't handle errors,
> best if you use xcalloc instead. */
> ! typedef PTR (*htab_alloc) (size_t, size_t);
>
> /* We also need a free() routine. */
> ! typedef void (*htab_free) (PTR);
>
> /* Memory allocation and deallocation; variants which take an extra
> argument. */
> ! typedef PTR (*htab_alloc_with_arg) (void *, size_t, size_t);
> ! typedef void (*htab_free_with_arg) (void *, void *);
>
> /* Hash tables are of the following type. The structure
> (implementation) of this type is not needed for using the hash
> *************** enum insert_option {NO_INSERT, INSERT};
> *** 139,183 ****
>
> /* The prototypes of the package functions. */
>
> ! extern htab_t htab_create_alloc PARAMS ((size_t, htab_hash,
> ! htab_eq, htab_del,
> ! htab_alloc, htab_free));
> !
> ! extern htab_t htab_create_alloc_ex PARAMS ((size_t, htab_hash,
> ! htab_eq, htab_del,
> ! PTR, htab_alloc_with_arg,
> ! htab_free_with_arg));
>
> /* Backward-compatibility functions. */
> ! extern htab_t htab_create PARAMS ((size_t, htab_hash, htab_eq,
htab_del));
> ! extern htab_t htab_try_create PARAMS ((size_t, htab_hash, htab_eq,
> htab_del));
>
> ! extern void htab_set_functions_ex PARAMS ((htab_t, htab_hash,
> ! htab_eq, htab_del,
> ! PTR, htab_alloc_with_arg,
> ! htab_free_with_arg));
> !
> ! extern void htab_delete PARAMS ((htab_t));
> ! extern void htab_empty PARAMS ((htab_t));
> !
> ! extern PTR htab_find PARAMS ((htab_t, const void *));
> ! extern PTR *htab_find_slot PARAMS ((htab_t, const void *,
> ! enum insert_option));
> ! extern PTR htab_find_with_hash PARAMS ((htab_t, const void *,
> ! hashval_t));
> ! extern PTR *htab_find_slot_with_hash PARAMS ((htab_t, const void
*,
> ! hashval_t,
> ! enum insert_option));
> ! extern void htab_clear_slot PARAMS ((htab_t, void **));
> ! extern void htab_remove_elt PARAMS ((htab_t, void *));
> ! extern void htab_remove_elt_with_hash PARAMS ((htab_t, void *,
> hashval_t));
> !
> ! extern void htab_traverse PARAMS ((htab_t, htab_trav, void *));
> ! extern void htab_traverse_noresize PARAMS ((htab_t, htab_trav,void
*));
> !
> ! extern size_t htab_size PARAMS ((htab_t));
> ! extern size_t htab_elements PARAMS ((htab_t));
> ! extern double htab_collisions PARAMS ((htab_t));
>
> /* A hash function for pointers. */
> extern htab_hash htab_hash_pointer;
> --- 139,181 ----
>
> /* The prototypes of the package functions. */
>
> ! extern htab_t htab_create_alloc (size_t, htab_hash,
> ! htab_eq, htab_del,
> ! htab_alloc, htab_free);
> !
> ! extern htab_t htab_create_alloc_ex (size_t, htab_hash,
> ! htab_eq, htab_del,
> ! PTR, htab_alloc_with_arg,
> ! htab_free_with_arg);
>
> /* Backward-compatibility functions. */
> ! extern htab_t htab_create (size_t, htab_hash, htab_eq, htab_del);
> ! extern htab_t htab_try_create (size_t, htab_hash, htab_eq, htab_del);
>
> ! extern void htab_set_functions_ex (htab_t, htab_hash,
> ! htab_eq, htab_del,
> ! PTR, htab_alloc_with_arg,
> ! htab_free_with_arg);
> !
> ! extern void htab_delete (htab_t);
> ! extern void htab_empty (htab_t);
> !
> ! extern PTR htab_find (htab_t, const void *);
> ! extern PTR *htab_find_slot (htab_t, const void *, enum
insert_option);
> ! extern PTR htab_find_with_hash (htab_t, const void *, hashval_t);
> ! extern PTR *htab_find_slot_with_hash (htab_t, const void *,
> ! hashval_t,
> ! enum insert_option);
> ! extern void htab_clear_slot (htab_t, void **);
> ! extern void htab_remove_elt (htab_t, void *);
> ! extern void htab_remove_elt_with_hash (htab_t, void *, hashval_t);
> !
> ! extern void htab_traverse (htab_t, htab_trav, void *);
> ! extern void htab_traverse_noresize (htab_t, htab_trav, void *);
> !
> ! extern size_t htab_size (htab_t);
> ! extern size_t htab_elements (htab_t);
> ! extern double htab_collisions (htab_t);
>
> /* A hash function for pointers. */
> extern htab_hash htab_hash_pointer;
> *************** extern htab_hash htab_hash_pointer;
> *** 186,195 ****
> extern htab_eq htab_eq_pointer;
>
> /* A hash function for null-terminated strings. */
> ! extern hashval_t htab_hash_string PARAMS ((const PTR));
>
> /* An iterative hash function for arbitrary data. */
> ! extern hashval_t iterative_hash PARAMS ((const PTR, size_t,
hashval_t));
> /* Shorthand for hashing something with an intrinsic size. */
> #define iterative_hash_object(OB,INIT) iterative_hash (&OB, sizeof
> (OB), INIT)
>
> --- 184,193 ----
> extern htab_eq htab_eq_pointer;
>
> /* A hash function for null-terminated strings. */
> ! extern hashval_t htab_hash_string (const PTR);
>
> /* An iterative hash function for arbitrary data. */
> ! extern hashval_t iterative_hash (const PTR, size_t, hashval_t);
> /* Shorthand for hashing something with an intrinsic size. */
> #define iterative_hash_object(OB,INIT) iterative_hash (&OB, sizeof
> (OB), INIT)
>
> Index: include/md5.h
> ===================================================================
> RCS file: /cvs/gcc/gcc/include/md5.h,v
> retrieving revision 1.3
> diff -p -r1.3 md5.h
> *** include/md5.h 14 Mar 2001 19:44:38 -0000 1.3
> --- include/md5.h 27 Mar 2005 14:36:15 -0000
> *************** typedef u_int32_t md5_uint32;
> *** 66,78 ****
> # endif
> #endif
>
> - #undef __P
> - #if defined (__STDC__) && __STDC__
> - #define __P(x) x
> - #else
> - #define __P(x) ()
> - #endif
> -
> /* Structure to save state of computation between the single steps. */
> struct md5_ctx
> {
> --- 66,71 ----
> *************** struct md5_ctx
> *** 93,113 ****
>
> /* Initialize structure containing state of computation.
> (RFC 1321, 3.3: Step 3) */
> ! extern void md5_init_ctx __P ((struct md5_ctx *ctx));
>
> /* Starting with the result of former calls of this function (or the
> initialization function update the context for the next LEN bytes
> starting at BUFFER.
> It is necessary that LEN is a multiple of 64!!! */
> ! extern void md5_process_block __P ((const void *buffer, size_t len,
> ! struct md5_ctx *ctx));
>
> /* Starting with the result of former calls of this function (or the
> initialization function update the context for the next LEN bytes
> starting at BUFFER.
> It is NOT required that LEN is a multiple of 64. */
> ! extern void md5_process_bytes __P ((const void *buffer, size_t len,
> ! struct md5_ctx *ctx));
>
> /* Process the remaining bytes in the buffer and put result from CTX
> in first 16 bytes following RESBUF. The result is always in little
> --- 86,106 ----
>
> /* Initialize structure containing state of computation.
> (RFC 1321, 3.3: Step 3) */
> ! extern void md5_init_ctx (struct md5_ctx *ctx);
>
> /* Starting with the result of former calls of this function (or the
> initialization function update the context for the next LEN bytes
> starting at BUFFER.
> It is necessary that LEN is a multiple of 64!!! */
> ! extern void md5_process_block (const void *buffer, size_t len,
> ! struct md5_ctx *ctx);
>
> /* Starting with the result of former calls of this function (or the
> initialization function update the context for the next LEN bytes
> starting at BUFFER.
> It is NOT required that LEN is a multiple of 64. */
> ! extern void md5_process_bytes (const void *buffer, size_t len,
> ! struct md5_ctx *ctx);
>
> /* Process the remaining bytes in the buffer and put result from CTX
> in first 16 bytes following RESBUF. The result is always in little
> *************** extern void md5_process_bytes __P ((cons
> *** 116,122 ****
>
> IMPORTANT: On some systems it is required that RESBUF is correctly
> aligned for a 32 bits value. */
> ! extern void *md5_finish_ctx __P ((struct md5_ctx *ctx, void *resbuf));
>
>
> /* Put result from CTX in first 16 bytes following RESBUF. The result
is
> --- 109,115 ----
>
> IMPORTANT: On some systems it is required that RESBUF is correctly
> aligned for a 32 bits value. */
> ! extern void *md5_finish_ctx (struct md5_ctx *ctx, void *resbuf);
>
>
> /* Put result from CTX in first 16 bytes following RESBUF. The result
is
> *************** extern void *md5_finish_ctx __P ((struct
> *** 125,142 ****
>
> IMPORTANT: On some systems it is required that RESBUF is correctly
> aligned for a 32 bits value. */
> ! extern void *md5_read_ctx __P ((const struct md5_ctx *ctx, void
*resbuf));
>
>
> /* Compute MD5 message digest for bytes read from STREAM. The
> resulting message digest number will be written into the 16 bytes
> beginning at RESBLOCK. */
> ! extern int md5_stream __P ((FILE *stream, void *resblock));
>
> /* Compute MD5 message digest for LEN bytes beginning at BUFFER. The
> result is always in little endian byte order, so that a byte-wise
> output yields to the wanted ASCII representation of the message
> digest. */
> ! extern void *md5_buffer __P ((const char *buffer, size_t len, void
> *resblock));
>
> #endif
> --- 118,135 ----
>
> IMPORTANT: On some systems it is required that RESBUF is correctly
> aligned for a 32 bits value. */
> ! extern void *md5_read_ctx (const struct md5_ctx *ctx, void *resbuf);
>
>
> /* Compute MD5 message digest for bytes read from STREAM. The
> resulting message digest number will be written into the 16 bytes
> beginning at RESBLOCK. */
> ! extern int md5_stream (FILE *stream, void *resblock);
>
> /* Compute MD5 message digest for LEN bytes beginning at BUFFER. The
> result is always in little endian byte order, so that a byte-wise
> output yields to the wanted ASCII representation of the message
> digest. */
> ! extern void *md5_buffer (const char *buffer, size_t len, void
*resblock);
>
> #endif
> Index: libiberty/dyn-string.c
> ===================================================================
> RCS file: /cvs/gcc/gcc/libiberty/dyn-string.c,v
> retrieving revision 1.8
> diff -p -r1.8 dyn-string.c
> *** libiberty/dyn-string.c 24 Feb 2004 02:32:50 -0000 1.8
> --- libiberty/dyn-string.c 27 Mar 2005 14:36:19 -0000
> *************** Boston, MA 02111-1307, USA. */
> *** 56,64 ****
> fails, returns 0. Otherwise returns 1. */
>
> int
> ! dyn_string_init (ds_struct_ptr, space)
> ! struct dyn_string *ds_struct_ptr;
> ! int space;
> {
> /* We need at least one byte in which to store the terminating NUL.
*/
> if (space == 0)
> --- 56,62 ----
> fails, returns 0. Otherwise returns 1. */
>
> int
> ! dyn_string_init (struct dyn_string *ds_struct_ptr, int space)
> {
> /* We need at least one byte in which to store the terminating NUL.
*/
> if (space == 0)
> *************** dyn_string_init (ds_struct_ptr, space)
> *** 85,92 ****
> returns the newly allocated string. */
>
> dyn_string_t
> ! dyn_string_new (space)
> ! int space;
> {
> dyn_string_t result;
> #ifdef RETURN_ON_ALLOCATION_FAILURE
> --- 83,89 ----
> returns the newly allocated string. */
>
> dyn_string_t
> ! dyn_string_new (int space)
> {
> dyn_string_t result;
> #ifdef RETURN_ON_ALLOCATION_FAILURE
> *************** dyn_string_new (space)
> *** 108,115 ****
> /* Free the memory used by DS. */
>
> void
> ! dyn_string_delete (ds)
> ! dyn_string_t ds;
> {
> free (ds->s);
> free (ds);
> --- 105,111 ----
> /* Free the memory used by DS. */
>
> void
> ! dyn_string_delete (dyn_string_t ds)
> {
> free (ds->s);
> free (ds);
> *************** dyn_string_delete (ds)
> *** 120,127 ****
> DS is then set to the empty string. Deletes DS itself. */
>
> char*
> ! dyn_string_release (ds)
> ! dyn_string_t ds;
> {
> /* Store the old buffer. */
> char* result = ds->s;
> --- 116,122 ----
> DS is then set to the empty string. Deletes DS itself. */
>
> char*
> ! dyn_string_release (dyn_string_t ds)
> {
> /* Store the old buffer. */
> char* result = ds->s;
> *************** dyn_string_release (ds)
> *** 141,149 ****
> operation fails, deletes DS and returns NULL. */
>
> dyn_string_t
> ! dyn_string_resize (ds, space)
> ! dyn_string_t ds;
> ! int space;
> {
> int new_allocated = ds->allocated;
>
> --- 136,142 ----
> operation fails, deletes DS and returns NULL. */
>
> dyn_string_t
> ! dyn_string_resize (dyn_string_t ds, int space)
> {
> int new_allocated = ds->allocated;
>
> *************** dyn_string_resize (ds, space)
> *** 176,183 ****
> /* Sets the contents of DS to the empty string. */
>
> void
> ! dyn_string_clear (ds)
> ! dyn_string_t ds;
> {
> /* A dyn_string always has room for at least the NUL terminator. */
> ds->s[0] = '\0';
> --- 169,175 ----
> /* Sets the contents of DS to the empty string. */
>
> void
> ! dyn_string_clear (dyn_string_t ds)
> {
> /* A dyn_string always has room for at least the NUL terminator. */
> ds->s[0] = '\0';
> *************** dyn_string_clear (ds)
> *** 189,197 ****
> RETURN_ON_ALLOCATION_FAILURE, deletes DEST and returns 0. */
>
> int
> ! dyn_string_copy (dest, src)
> ! dyn_string_t dest;
> ! dyn_string_t src;
> {
> if (dest == src)
> abort ();
> --- 181,187 ----
> RETURN_ON_ALLOCATION_FAILURE, deletes DEST and returns 0. */
>
> int
> ! dyn_string_copy (dyn_string_t dest, dyn_string_t src)
> {
> if (dest == src)
> abort ();
> *************** dyn_string_copy (dest, src)
> *** 211,219 ****
> and returns 0. */
>
> int
> ! dyn_string_copy_cstr (dest, src)
> ! dyn_string_t dest;
> ! const char *src;
> {
> int length = strlen (src);
> /* Make room in DEST. */
> --- 201,207 ----
> and returns 0. */
>
> int
> ! dyn_string_copy_cstr (dyn_string_t dest, const char *src)
> {
> int length = strlen (src);
> /* Make room in DEST. */
> *************** dyn_string_copy_cstr (dest, src)
> *** 232,240 ****
> returns 0. */
>
> int
> ! dyn_string_prepend (dest, src)
> ! dyn_string_t dest;
> ! dyn_string_t src;
> {
> return dyn_string_insert (dest, 0, src);
> }
> --- 220,226 ----
> returns 0. */
>
> int
> ! dyn_string_prepend (dyn_string_t dest, dyn_string_t src)
> {
> return dyn_string_insert (dest, 0, src);
> }
> *************** dyn_string_prepend (dest, src)
> *** 244,252 ****
> if RETURN_ON_ALLOCATION_FAILURE, deletes DEST and returns 0. */
>
> int
> ! dyn_string_prepend_cstr (dest, src)
> ! dyn_string_t dest;
> ! const char *src;
> {
> return dyn_string_insert_cstr (dest, 0, src);
> }
> --- 230,236 ----
> if RETURN_ON_ALLOCATION_FAILURE, deletes DEST and returns 0. */
>
> int
> ! dyn_string_prepend_cstr (dyn_string_t dest, const char *src)
> {
> return dyn_string_insert_cstr (dest, 0, src);
> }
> *************** dyn_string_prepend_cstr (dest, src)
> *** 257,266 ****
> and returns 0. */
>
> int
> ! dyn_string_insert (dest, pos, src)
> ! dyn_string_t dest;
> ! int pos;
> ! dyn_string_t src;
> {
> int i;
>
> --- 241,247 ----
> and returns 0. */
>
> int
> ! dyn_string_insert (dyn_string_t dest, int pos, dyn_string_t src)
> {
> int i;
>
> *************** dyn_string_insert (dest, pos, src)
> *** 285,294 ****
> and returns 0. */
>
> int
> ! dyn_string_insert_cstr (dest, pos, src)
> ! dyn_string_t dest;
> ! int pos;
> ! const char *src;
> {
> int i;
> int length = strlen (src);
> --- 266,272 ----
> and returns 0. */
>
> int
> ! dyn_string_insert_cstr (dyn_string_t dest, int pos, const char *src)
> {
> int i;
> int length = strlen (src);
> *************** dyn_string_insert_cstr (dest, pos, src)
> *** 310,319 ****
> RETURN_ON_ALLOCATION_FAILURE, deletes DEST and returns 0. */
>
> int
> ! dyn_string_insert_char (dest, pos, c)
> ! dyn_string_t dest;
> ! int pos;
> ! int c;
> {
> int i;
>
> --- 288,294 ----
> RETURN_ON_ALLOCATION_FAILURE, deletes DEST and returns 0. */
>
> int
> ! dyn_string_insert_char (dyn_string_t dest, int pos, int c)
> {
> int i;
>
> *************** dyn_string_insert_char (dest, pos, c)
> *** 334,342 ****
> returns 0. */
>
> int
> ! dyn_string_append (dest, s)
> ! dyn_string_t dest;
> ! dyn_string_t s;
> {
> if (dyn_string_resize (dest, dest->length + s->length) == 0)
> return 0;
> --- 309,315 ----
> returns 0. */
>
> int
> ! dyn_string_append (dyn_string_t dest, dyn_string_t s)
> {
> if (dyn_string_resize (dest, dest->length + s->length) == 0)
> return 0;
> *************** dyn_string_append (dest, s)
> *** 350,358 ****
> deletes DEST and returns 0. */
>
> int
> ! dyn_string_append_cstr (dest, s)
> ! dyn_string_t dest;
> ! const char *s;
> {
> int len = strlen (s);
>
> --- 323,329 ----
> deletes DEST and returns 0. */
>
> int
> ! dyn_string_append_cstr (dyn_string_t dest, const char *s)
> {
> int len = strlen (s);
>
> *************** dyn_string_append_cstr (dest, s)
> *** 369,377 ****
> if RETURN_ON_ALLOCATION_FAILURE, deletes DEST and returns 0. */
>
> int
> ! dyn_string_append_char (dest, c)
> ! dyn_string_t dest;
> ! int c;
> {
> /* Make room for the extra character. */
> if (dyn_string_resize (dest, dest->length + 1) == NULL)
> --- 340,346 ----
> if RETURN_ON_ALLOCATION_FAILURE, deletes DEST and returns 0. */
>
> int
> ! dyn_string_append_char (dyn_string_t dest, int c)
> {
> /* Make room for the extra character. */
> if (dyn_string_resize (dest, dest->length + 1) == NULL)
> *************** dyn_string_append_char (dest, c)
> *** 392,402 ****
> deletes DEST and returns 0. */
>
> int
> ! dyn_string_substring (dest, src, start, end)
> ! dyn_string_t dest;
> ! dyn_string_t src;
> ! int start;
> ! int end;
> {
> int i;
> int length = end - start;
> --- 361,368 ----
> deletes DEST and returns 0. */
>
> int
> ! dyn_string_substring (dyn_string_t dest, dyn_string_t src,
> ! int start, int end)
> {
> int i;
> int length = end - start;
> *************** dyn_string_substring (dest, src, start,
> *** 421,429 ****
> /* Returns non-zero if DS1 and DS2 have the same contents. */
>
> int
> ! dyn_string_eq (ds1, ds2)
> ! dyn_string_t ds1;
> ! dyn_string_t ds2;
> {
> /* If DS1 and DS2 have different lengths, they must not be the same.
*/
> if (ds1->length != ds2->length)
> --- 387,393 ----
> /* Returns non-zero if DS1 and DS2 have the same contents. */
>
> int
> ! dyn_string_eq (dyn_string_t ds1, dyn_string_t ds2)
> {
> /* If DS1 and DS2 have different lengths, they must not be the same.
*/
> if (ds1->length != ds2->length)
> Index: libiberty/fdmatch.c
> ===================================================================
> RCS file: /cvs/gcc/gcc/libiberty/fdmatch.c,v
> retrieving revision 1.3
> diff -p -r1.3 fdmatch.c
> *** libiberty/fdmatch.c 16 Oct 2001 02:50:13 -0000 1.3
> --- libiberty/fdmatch.c 27 Mar 2005 14:36:19 -0000
> *************** BUGS
> *** 46,54 ****
> #include <sys/types.h>
> #include <sys/stat.h>
>
> ! int fdmatch (fd1, fd2)
> ! int fd1;
> ! int fd2;
> {
> struct stat sbuf1;
> struct stat sbuf2;
> --- 46,52 ----
> #include <sys/types.h>
> #include <sys/stat.h>
>
> ! int fdmatch (int fd1, int fd2)
> {
> struct stat sbuf1;
> struct stat sbuf2;
> Index: libiberty/ffs.c
> ===================================================================
> RCS file: /cvs/gcc/gcc/libiberty/ffs.c,v
> retrieving revision 1.3
> diff -p -r1.3 ffs.c
> *** libiberty/ffs.c 17 Oct 2001 21:15:40 -0000 1.3
> --- libiberty/ffs.c 27 Mar 2005 14:36:19 -0000
> *************** value 1). If @var{valu} is zero, zero i
> *** 11,18 ****
> */
>
> int
> ! ffs (valu)
> ! register int valu;
> {
> register int bit;
>
> --- 11,17 ----
> */
>
> int
> ! ffs (register int valu)
> {
> register int bit;
>
> Index: libiberty/fibheap.c
> ===================================================================
> RCS file: /cvs/gcc/gcc/libiberty/fibheap.c,v
> retrieving revision 1.6
> diff -p -r1.6 fibheap.c
> *** libiberty/fibheap.c 6 Sep 2003 05:28:03 -0000 1.6
> --- libiberty/fibheap.c 27 Mar 2005 14:36:19 -0000
> *************** Boston, MA 02111-1307, USA. */
> *** 37,68 ****
>
> #define FIBHEAPKEY_MIN LONG_MIN
>
> ! static void fibheap_ins_root PARAMS ((fibheap_t, fibnode_t));
> ! static void fibheap_rem_root PARAMS ((fibheap_t, fibnode_t));
> ! static void fibheap_consolidate PARAMS ((fibheap_t));
> ! static void fibheap_link PARAMS ((fibheap_t, fibnode_t, fibnode_t));
> ! static void fibheap_cut PARAMS ((fibheap_t, fibnode_t, fibnode_t));
> ! static void fibheap_cascading_cut PARAMS ((fibheap_t, fibnode_t));
> ! static fibnode_t fibheap_extr_min_node PARAMS ((fibheap_t));
> ! static int fibheap_compare PARAMS ((fibheap_t, fibnode_t, fibnode_t));
> ! static int fibheap_comp_data PARAMS ((fibheap_t, fibheapkey_t, void *,
> ! fibnode_t));
> ! static fibnode_t fibnode_new PARAMS ((void));
> ! static void fibnode_insert_after PARAMS ((fibnode_t, fibnode_t));
> #define fibnode_insert_before(a, b) fibnode_insert_after (a->left, b)
> ! static fibnode_t fibnode_remove PARAMS ((fibnode_t));
>
>
> /* Create a new fibonacci heap. */
> fibheap_t
> ! fibheap_new ()
> {
> return (fibheap_t) xcalloc (1, sizeof (struct fibheap));
> }
>
> /* Create a new fibonacci heap node. */
> static fibnode_t
> ! fibnode_new ()
> {
> fibnode_t node;
>
> --- 37,67 ----
>
> #define FIBHEAPKEY_MIN LONG_MIN
>
> ! static void fibheap_ins_root (fibheap_t, fibnode_t);
> ! static void fibheap_rem_root (fibheap_t, fibnode_t);
> ! static void fibheap_consolidate (fibheap_t);
> ! static void fibheap_link (fibheap_t, fibnode_t, fibnode_t);
> ! static void fibheap_cut (fibheap_t, fibnode_t, fibnode_t);
> ! static void fibheap_cascading_cut (fibheap_t, fibnode_t);
> ! static fibnode_t fibheap_extr_min_node (fibheap_t);
> ! static int fibheap_compare (fibheap_t, fibnode_t, fibnode_t);
> ! static int fibheap_comp_data (fibheap_t, fibheapkey_t, void *,
fibnode_t);
> ! static fibnode_t fibnode_new (void);
> ! static void fibnode_insert_after (fibnode_t, fibnode_t);
> #define fibnode_insert_before(a, b) fibnode_insert_after (a->left, b)
> ! static fibnode_t fibnode_remove (fibnode_t);
>
>
> /* Create a new fibonacci heap. */
> fibheap_t
> ! fibheap_new (void)
> {
> return (fibheap_t) xcalloc (1, sizeof (struct fibheap));
> }
>
> /* Create a new fibonacci heap node. */
> static fibnode_t
> ! fibnode_new (void)
> {
> fibnode_t node;
>
> *************** fibnode_new ()
> *** 74,83 ****
> }
>
> static inline int
> ! fibheap_compare (heap, a, b)
> ! fibheap_t heap ATTRIBUTE_UNUSED;
> ! fibnode_t a;
> ! fibnode_t b;
> {
> if (a->key < b->key)
> return -1;
> --- 73,79 ----
> }
>
> static inline int
> ! fibheap_compare (fibheap_t heap ATTRIBUTE_UNUSED, fibnode_t a,
fibnode_t b)
> {
> if (a->key < b->key)
> return -1;
> *************** fibheap_compare (heap, a, b)
> *** 87,97 ****
> }
>
> static inline int
> ! fibheap_comp_data (heap, key, data, b)
> ! fibheap_t heap;
> ! fibheapkey_t key;
> ! void *data;
> ! fibnode_t b;
> {
> struct fibnode a;
>
> --- 83,89 ----
> }
>
> static inline int
> ! fibheap_comp_data (fibheap_t heap, fibheapkey_t key, void *data,
> fibnode_t b)
> {
> struct fibnode a;
>
> *************** fibheap_comp_data (heap, key, data, b)
> *** 103,112 ****
>
> /* Insert DATA, with priority KEY, into HEAP. */
> fibnode_t
> ! fibheap_insert (heap, key, data)
> ! fibheap_t heap;
> ! fibheapkey_t key;
> ! void *data;
> {
> fibnode_t node;
>
> --- 95,101 ----
>
> /* Insert DATA, with priority KEY, into HEAP. */
> fibnode_t
> ! fibheap_insert (fibheap_t heap, fibheapkey_t key, void *data)
> {
> fibnode_t node;
>
> *************** fibheap_insert (heap, key, data)
> *** 132,139 ****
>
> /* Return the data of the minimum node (if we know it). */
> void *
> ! fibheap_min (heap)
> ! fibheap_t heap;
> {
> /* If there is no min, we can't easily return it. */
> if (heap->min == NULL)
> --- 121,127 ----
>
> /* Return the data of the minimum node (if we know it). */
> void *
> ! fibheap_min (fibheap_t heap)
> {
> /* If there is no min, we can't easily return it. */
> if (heap->min == NULL)
> *************** fibheap_min (heap)
> *** 143,150 ****
>
> /* Return the key of the minimum node (if we know it). */
> fibheapkey_t
> ! fibheap_min_key (heap)
> ! fibheap_t heap;
> {
> /* If there is no min, we can't easily return it. */
> if (heap->min == NULL)
> --- 131,137 ----
>
> /* Return the key of the minimum node (if we know it). */
> fibheapkey_t
> ! fibheap_min_key (fibheap_t heap)
> {
> /* If there is no min, we can't easily return it. */
> if (heap->min == NULL)
> *************** fibheap_min_key (heap)
> *** 154,162 ****
>
> /* Union HEAPA and HEAPB into a new heap. */
> fibheap_t
> ! fibheap_union (heapa, heapb)
> ! fibheap_t heapa;
> ! fibheap_t heapb;
> {
> fibnode_t a_root, b_root, temp;
>
> --- 141,147 ----
>
> /* Union HEAPA and HEAPB into a new heap. */
> fibheap_t
> ! fibheap_union (fibheap_t heapa, fibheap_t heapb)
> {
> fibnode_t a_root, b_root, temp;
>
> *************** fibheap_union (heapa, heapb)
> *** 190,197 ****
>
> /* Extract the data of the minimum node from HEAP. */
> void *
> ! fibheap_extract_min (heap)
> ! fibheap_t heap;
> {
> fibnode_t z;
> void *ret = NULL;
> --- 175,181 ----
>
> /* Extract the data of the minimum node from HEAP. */
> void *
> ! fibheap_extract_min (fibheap_t heap)
> {
> fibnode_t z;
> void *ret = NULL;
> *************** fibheap_extract_min (heap)
> *** 211,221 ****
>
> /* Replace both the KEY and the DATA associated with NODE. */
> void *
> ! fibheap_replace_key_data (heap, node, key, data)
> ! fibheap_t heap;
> ! fibnode_t node;
> ! fibheapkey_t key;
> ! void *data;
> {
> void *odata;
> fibheapkey_t okey;
> --- 195,202 ----
>
> /* Replace both the KEY and the DATA associated with NODE. */
> void *
> ! fibheap_replace_key_data (fibheap_t heap, fibnode_t node,
> ! fibheapkey_t key, void *data)
> {
> void *odata;
> fibheapkey_t okey;
> *************** fibheap_replace_key_data (heap, node, ke
> *** 253,272 ****
>
> /* Replace the DATA associated with NODE. */
> void *
> ! fibheap_replace_data (heap, node, data)
> ! fibheap_t heap;
> ! fibnode_t node;
> ! void *data;
> {
> return fibheap_replace_key_data (heap, node, node->key, data);
> }
>
> /* Replace the KEY associated with NODE. */
> fibheapkey_t
> ! fibheap_replace_key (heap, node, key)
> ! fibheap_t heap;
> ! fibnode_t node;
> ! fibheapkey_t key;
> {
> int okey = node->key;
> fibheap_replace_key_data (heap, node, key, node->data);
> --- 234,247 ----
>
> /* Replace the DATA associated with NODE. */
> void *
> ! fibheap_replace_data (fibheap_t heap, fibnode_t node, void *data)
> {
> return fibheap_replace_key_data (heap, node, node->key, data);
> }
>
> /* Replace the KEY associated with NODE. */
> fibheapkey_t
> ! fibheap_replace_key (fibheap_t heap, fibnode_t node, fibheapkey_t key)
> {
> int okey = node->key;
> fibheap_replace_key_data (heap, node, key, node->data);
> *************** fibheap_replace_key (heap, node, key)
> *** 275,283 ****
>
> /* Delete NODE from HEAP. */
> void *
> ! fibheap_delete_node (heap, node)
> ! fibheap_t heap;
> ! fibnode_t node;
> {
> void *ret = node->data;
>
> --- 250,256 ----
>
> /* Delete NODE from HEAP. */
> void *
> ! fibheap_delete_node (fibheap_t heap, fibnode_t node)
> {
> void *ret = node->data;
>
> *************** fibheap_delete_node (heap, node)
> *** 290,297 ****
>
> /* Delete HEAP. */
> void
> ! fibheap_delete (heap)
> ! fibheap_t heap;
> {
> while (heap->min != NULL)
> free (fibheap_extr_min_node (heap));
> --- 263,269 ----
>
> /* Delete HEAP. */
> void
> ! fibheap_delete (fibheap_t heap)
> {
> while (heap->min != NULL)
> free (fibheap_extr_min_node (heap));
> *************** fibheap_delete (heap)
> *** 301,316 ****
>
> /* Determine if HEAP is empty. */
> int
> ! fibheap_empty (heap)
> ! fibheap_t heap;
> {
> return heap->nodes == 0;
> }
>
> /* Extract the minimum node of the heap. */
> static fibnode_t
> ! fibheap_extr_min_node (heap)
> ! fibheap_t heap;
> {
> fibnode_t ret = heap->min;
> fibnode_t x, y, orig;
> --- 273,286 ----
>
> /* Determine if HEAP is empty. */
> int
> ! fibheap_empty (fibheap_t heap)
> {
> return heap->nodes == 0;
> }
>
> /* Extract the minimum node of the heap. */
> static fibnode_t
> ! fibheap_extr_min_node (fibheap_t heap)
> {
> fibnode_t ret = heap->min;
> fibnode_t x, y, orig;
> *************** fibheap_extr_min_node (heap)
> *** 346,354 ****
>
> /* Insert NODE into the root list of HEAP. */
> static void
> ! fibheap_ins_root (heap, node)
> ! fibheap_t heap;
> ! fibnode_t node;
> {
> /* If the heap is currently empty, the new node becomes the singleton
> circular root list. */
> --- 316,322 ----
>
> /* Insert NODE into the root list of HEAP. */
> static void
> ! fibheap_ins_root (fibheap_t heap, fibnode_t node)
> {
> /* If the heap is currently empty, the new node becomes the singleton
> circular root list. */
> *************** fibheap_ins_root (heap, node)
> *** 367,375 ****
>
> /* Remove NODE from the rootlist of HEAP. */
> static void
> ! fibheap_rem_root (heap, node)
> ! fibheap_t heap;
> ! fibnode_t node;
> {
> if (node->left == node)
> heap->root = NULL;
> --- 335,341 ----
>
> /* Remove NODE from the rootlist of HEAP. */
> static void
> ! fibheap_rem_root (fibheap_t heap, fibnode_t node)
> {
> if (node->left == node)
> heap->root = NULL;
> *************** fibheap_rem_root (heap, node)
> *** 379,386 ****
>
> /* Consolidate the heap. */
> static void
> ! fibheap_consolidate (heap)
> ! fibheap_t heap;
> {
> fibnode_t a[1 + 8 * sizeof (long)];
> fibnode_t w;
> --- 345,351 ----
>
> /* Consolidate the heap. */
> static void
> ! fibheap_consolidate (fibheap_t heap)
> {
> fibnode_t a[1 + 8 * sizeof (long)];
> fibnode_t w;
> *************** fibheap_consolidate (heap)
> *** 427,436 ****
>
> /* Make NODE a child of PARENT. */
> static void
> ! fibheap_link (heap, node, parent)
> ! fibheap_t heap ATTRIBUTE_UNUSED;
> ! fibnode_t node;
> ! fibnode_t parent;
> {
> if (parent->child == NULL)
> parent->child = node;
> --- 392,399 ----
>
> /* Make NODE a child of PARENT. */
> static void
> ! fibheap_link (fibheap_t heap ATTRIBUTE_UNUSED,
> ! fibnode_t node, fibnode_t parent)
> {
> if (parent->child == NULL)
> parent->child = node;
> *************** fibheap_link (heap, node, parent)
> *** 443,452 ****
>
> /* Remove NODE from PARENT's child list. */
> static void
> ! fibheap_cut (heap, node, parent)
> ! fibheap_t heap;
> ! fibnode_t node;
> ! fibnode_t parent;
> {
> fibnode_remove (node);
> parent->degree--;
> --- 406,412 ----
>
> /* Remove NODE from PARENT's child list. */
> static void
> ! fibheap_cut (fibheap_t heap, fibnode_t node, fibnode_t parent)
> {
> fibnode_remove (node);
> parent->degree--;
> *************** fibheap_cut (heap, node, parent)
> *** 456,464 ****
> }
>
> static void
> ! fibheap_cascading_cut (heap, y)
> ! fibheap_t heap;
> ! fibnode_t y;
> {
> fibnode_t z;
>
> --- 416,422 ----
> }
>
> static void
> ! fibheap_cascading_cut (fibheap_t heap, fibnode_t y)
> {
> fibnode_t z;
>
> *************** fibheap_cascading_cut (heap, y)
> *** 478,486 ****
> }
>
> static void
> ! fibnode_insert_after (a, b)
> ! fibnode_t a;
> ! fibnode_t b;
> {
> if (a == a->right)
> {
> --- 436,442 ----
> }
>
> static void
> ! fibnode_insert_after (fibnode_t a, fibnode_t b)
> {
> if (a == a->right)
> {
> *************** fibnode_insert_after (a, b)
> *** 499,506 ****
> }
>
> static fibnode_t
> ! fibnode_remove (node)
> ! fibnode_t node;
> {
> fibnode_t ret;
>
> --- 455,461 ----
> }
>
> static fibnode_t
> ! fibnode_remove (fibnode_t node)
> {
> fibnode_t ret;
>
> Index: libiberty/floatformat.c
> ===================================================================
> RCS file: /cvs/gcc/gcc/libiberty/floatformat.c,v
> retrieving revision 1.15
> diff -p -r1.15 floatformat.c
> *** libiberty/floatformat.c 3 Dec 2003 18:36:50 -0000 1.15
> --- libiberty/floatformat.c 27 Mar 2005 14:36:19 -0000
> *************** Foundation, Inc., 59 Temple Place - Suit
> *** 46,63 ****
> #define NAN (0.0 / 0.0)
> #endif
>
> ! static unsigned long get_field PARAMS ((const unsigned char *,
> ! enum floatformat_byteorders,
> ! unsigned int,
> ! unsigned int,
> ! unsigned int));
> ! static int floatformat_always_valid PARAMS ((const struct floatformat
*fmt,
> ! const char *from));
>
> static int
> ! floatformat_always_valid (fmt, from)
> ! const struct floatformat *fmt ATTRIBUTE_UNUSED;
> ! const char *from ATTRIBUTE_UNUSED;
> {
> return 1;
> }
> --- 46,62 ----
> #define NAN (0.0 / 0.0)
> #endif
>
> ! static unsigned long get_field (const unsigned char *,
> ! enum floatformat_byteorders,
> ! unsigned int,
> ! unsigned int,
> ! unsigned int);
> ! static int floatformat_always_valid (const struct floatformat *fmt,
> ! const char *from);
>
> static int
> ! floatformat_always_valid (const struct floatformat *fmt
ATTRIBUTE_UNUSED,
> ! const char *from ATTRIBUTE_UNUSED)
> {
> return 1;
> }
> *************** const struct floatformat floatformat_iee
> *** 108,119 ****
> floatformat_always_valid
> };
>
> ! static int floatformat_i387_ext_is_valid PARAMS ((const struct
> floatformat *fmt, const char *from));
>
> static int
> ! floatformat_i387_ext_is_valid (fmt, from)
> ! const struct floatformat *fmt;
> ! const char *from;
> {
> /* In the i387 double-extended format, if the exponent is all ones,
> then the integer bit must be set. If the exponent is neither 0
> --- 107,116 ----
> floatformat_always_valid
> };
>
> ! static int floatformat_i387_ext_is_valid (const struct floatformat
> *fmt, const char *from);
>
> static int
> ! floatformat_i387_ext_is_valid (const struct floatformat *fmt,
> const char *from)
> {
> /* In the i387 double-extended format, if the exponent is all ones,
> then the integer bit must be set. If the exponent is neither 0
> *************** const struct floatformat floatformat_ia6
> *** 220,231 ****
> /* Extract a field which starts at START and is LEN bits long. DATA
and
> TOTAL_LEN are the thing we are extracting it from, in
byteorderORDER. */
> static unsigned long
> ! get_field (data, order, total_len, start, len)
> ! const unsigned char *data;
> ! enum floatformat_byteorders order;
> ! unsigned int total_len;
> ! unsigned int start;
> ! unsigned int len;
> {
> unsigned long result;
> unsigned int cur_byte;
> --- 217,224 ----
> /* Extract a field which starts at START and is LEN bits long. DATA
and
> TOTAL_LEN are the thing we are extracting it from, in
byteorderORDER. */
> static unsigned long
> ! get_field (const unsigned char *data, enum floatformat_byteorders
order,
> ! unsigned int total_len, unsigned int start, unsigned int
len)
> {
> unsigned long result;
> unsigned int cur_byte;
> *************** get_field (data, order, total_len, start
> *** 273,282 ****
> Store the double in *TO. */
>
> void
> ! floatformat_to_double (fmt, from, to)
> ! const struct floatformat *fmt;
> ! const char *from;
> ! double *to;
> {
> const unsigned char *ufrom = (const unsigned char *)from;
> double dto;
> --- 266,273 ----
> Store the double in *TO. */
>
> void
> ! floatformat_to_double (const struct floatformat *fmt,
> ! const char *from, double *to)
> {
> const unsigned char *ufrom = (const unsigned char *)from;
> double dto;
> *************** floatformat_to_double (fmt, from, to)
> *** 381,402 ****
> *to = dto;
> }
>
> ! static void put_field PARAMS ((unsigned char *, enum
floatformat_byteorders,
> ! unsigned int,
> ! unsigned int,
> ! unsigned int,
> ! unsigned long));
>
> /* Set a field which starts at START and is LEN bits long. DATA and
> TOTAL_LEN are the thing we are extracting it from, in
byteorderORDER. */
> static void
> ! put_field (data, order, total_len, start, len, stuff_to_put)
> ! unsigned char *data;
> ! enum floatformat_byteorders order;
> ! unsigned int total_len;
> ! unsigned int start;
> ! unsigned int len;
> ! unsigned long stuff_to_put;
> {
> unsigned int cur_byte;
> int cur_bitshift;
> --- 372,389 ----
> *to = dto;
> }
>
> ! static void put_field (unsigned char *, enum floatformat_byteorders,
> ! unsigned int,
> ! unsigned int,
> ! unsigned int,
> ! unsigned long);
>
> /* Set a field which starts at START and is LEN bits long. DATA and
> TOTAL_LEN are the thing we are extracting it from, in
byteorderORDER. */
> static void
> ! put_field (unsigned char *data, enum floatformat_byteorders order,
> ! unsigned int total_len, unsigned int start, unsigned int
len,
> ! unsigned long stuff_to_put)
> {
> unsigned int cur_byte;
> int cur_bitshift;
> *************** put_field (data, order, total_len, start
> *** 443,452 ****
> restrictions. */
>
> void
> ! floatformat_from_double (fmt, from, to)
> ! const struct floatformat *fmt;
> ! const double *from;
> ! char *to;
> {
> double dfrom;
> int exponent;
> --- 430,437 ----
> restrictions. */
>
> void
> ! floatformat_from_double (const struct floatformat *fmt,
> ! const double *from, char *to)
> {
> double dfrom;
> int exponent;
> *************** floatformat_from_double (fmt, from, to)
> *** 541,549 ****
> /* Return non-zero iff the data at FROM is a valid number in format
FMT. */
>
> int
> ! floatformat_is_valid (fmt, from)
> ! const struct floatformat *fmt;
> ! const char *from;
> {
> return fmt->is_valid (fmt, from);
> }
> --- 526,532 ----
> /* Return non-zero iff the data at FROM is a valid number in format
FMT. */
>
> int
> ! floatformat_is_valid (const struct floatformat *fmt, const char *from)
> {
> return fmt->is_valid (fmt, from);
> }
> *************** floatformat_is_valid (fmt, from)
> *** 556,563 ****
> /* This is to be run on a host which uses IEEE floating point. */
>
> void
> ! ieee_test (n)
> ! double n;
> {
> double result;
>
> --- 539,545 ----
> /* This is to be run on a host which uses IEEE floating point. */
>
> void
> ! ieee_test (double n)
> {
> double result;
>
> *************** ieee_test (n)
> *** 597,603 ****
> }
>
> int
> ! main ()
> {
> ieee_test (0.0);
> ieee_test (0.5);
> --- 579,585 ----
> }
>
> int
> ! main (void)
> {
> ieee_test (0.0);
> ieee_test (0.5);
> Index: libiberty/fnmatch.c
> ===================================================================
> RCS file: /cvs/gcc/gcc/libiberty/fnmatch.c,v
> retrieving revision 1.6
> diff -p -r1.6 fnmatch.c
> *** libiberty/fnmatch.c 29 Dec 2000 19:37:03 -0000 1.6
> --- libiberty/fnmatch.c 27 Mar 2005 14:36:19 -0000
> *************** extern int errno;
> *** 65,74 ****
> /* Match STRING against the filename pattern PATTERN, returning zero if
> it matches, nonzero if not. */
> int
> ! fnmatch (pattern, string, flags)
> ! const char *pattern;
> ! const char *string;
> ! int flags;
> {
> register const char *p = pattern, *n = string;
> register unsigned char c;
> --- 65,71 ----
> /* Match STRING against the filename pattern PATTERN, returning zero if
> it matches, nonzero if not. */
> int
> ! fnmatch (const char *pattern, const char *string, int flags)
> {
> register const char *p = pattern, *n = string;
> register unsigned char c;
> Index: libiberty/getcwd.c
> ===================================================================
> RCS file: /cvs/gcc/gcc/libiberty/getcwd.c,v
> retrieving revision 1.8
> diff -p -r1.8 getcwd.c
> *** libiberty/getcwd.c 15 Apr 2003 20:36:33 -0000 1.8
> --- libiberty/getcwd.c 27 Mar 2005 14:36:19 -0000
> *************** extern int errno;
> *** 38,46 ****
> #endif
>
> char *
> ! getcwd (buf, len)
> ! char *buf;
> ! size_t len;
> {
> char ourbuf[MAXPATHLEN];
> char *result;
> --- 38,44 ----
> #endif
>
> char *
> ! getcwd (char *buf, size_t len)
> {
> char ourbuf[MAXPATHLEN];
> char *result;
> Index: libiberty/getopt.c
> ===================================================================
> RCS file: /cvs/gcc/gcc/libiberty/getopt.c,v
> retrieving revision 1.8
> diff -p -r1.8 getopt.c
> *** libiberty/getopt.c 15 Apr 2003 14:24:26 -0000 1.8
> --- libiberty/getopt.c 27 Mar 2005 14:36:20 -0000
> *************** extern char *getenv ();
> *** 217,225 ****
> #endif
>
> static char *
> ! my_index (str, chr)
> ! const char *str;
> ! int chr;
> {
> while (*str)
> {
> --- 217,223 ----
> #endif
>
> static char *
> ! my_index (const char *str, int chr)
> {
> while (*str)
> {
> *************** static void exchange (char **);
> *** 307,314 ****
> #endif
>
> static void
> ! exchange (argv)
> ! char **argv;
> {
> int bottom = first_nonopt;
> int middle = last_nonopt;
> --- 305,311 ----
> #endif
>
> static void
> ! exchange (char **argv)
> {
> int bottom = first_nonopt;
> int middle = last_nonopt;
> *************** exchange (argv)
> *** 392,401 ****
> static const char *_getopt_initialize (int, char *const *, const char
*);
> #endif
> static const char *
> ! _getopt_initialize (argc, argv, optstring)
> ! int argc;
> ! char *const *argv;
> ! const char *optstring;
> {
> /* Start processing options with ARGV-element 1 (since ARGV-element 0
> is the program name); the sequence of previously skipped
> --- 389,395 ----
> static const char *_getopt_initialize (int, char *const *, const char
*);
> #endif
> static const char *
> ! _getopt_initialize (int argc, char *const *argv, const char *optstring)
> {
> /* Start processing options with ARGV-element 1 (since ARGV-element 0
> is the program name); the sequence of previously skipped
> *************** _getopt_initialize (argc, argv, optstrin
> *** 514,526 ****
> long-named options. */
>
> int
> ! _getopt_internal (argc, argv, optstring, longopts, longind, long_only)
> ! int argc;
> ! char *const *argv;
> ! const char *optstring;
> ! const struct option *longopts;
> ! int *longind;
> ! int long_only;
> {
> optarg = NULL;
>
> --- 508,516 ----
> long-named options. */
>
> int
> ! _getopt_internal (int argc, char *const *argv, const char *optstring,
> ! const struct option *longopts,
> ! int *longind, int long_only)
> {
> optarg = NULL;
>
> *************** _getopt_internal (argc, argv, optstring,
> *** 970,979 ****
> }
>
> int
> ! getopt (argc, argv, optstring)
> ! int argc;
> ! char *const *argv;
> ! const char *optstring;
> {
> return _getopt_internal (argc, argv, optstring,
> (const struct option *) 0,
> --- 960,966 ----
> }
>
> int
> ! getopt (int argc, char *const *argv, const char *optstring)
> {
> return _getopt_internal (argc, argv, optstring,
> (const struct option *) 0,
> *************** getopt (argc, argv, optstring)
> *** 989,997 ****
> the above definition of `getopt'. */
>
> int
> ! main (argc, argv)
> ! int argc;
> ! char **argv;
> {
> int c;
> int digit_optind = 0;
> --- 976,982 ----
> the above definition of `getopt'. */
>
> int
> ! main (int argc, char **argv)
> {
> int c;
> int digit_optind = 0;
> Index: libiberty/getopt1.c
> ===================================================================
> RCS file: /cvs/gcc/gcc/libiberty/getopt1.c,v
> retrieving revision 1.5
> diff -p -r1.5 getopt1.c
> *** libiberty/getopt1.c 29 Dec 2000 19:37:03 -0000 1.5
> --- libiberty/getopt1.c 27 Mar 2005 14:36:20 -0000
> ***************
> *** 66,77 ****
> #endif
>
> int
> ! getopt_long (argc, argv, options, long_options, opt_index)
> ! int argc;
> ! char *const *argv;
> ! const char *options;
> ! const struct option *long_options;
> ! int *opt_index;
> {
> return _getopt_internal (argc, argv, options, long_options,
opt_index, 0);
> }
> --- 66,73 ----
> #endif
>
> int
> ! getopt_long (int argc, char *const *argv, const char *options,
> ! const struct option *long_options, int *opt_index)
> {
> return _getopt_internal (argc, argv, options, long_options,
opt_index, 0);
> }
> *************** getopt_long (argc, argv, options, long_o
> *** 82,93 ****
> instead. */
>
> int
> ! getopt_long_only (argc, argv, options, long_options, opt_index)
> ! int argc;
> ! char *const *argv;
> ! const char *options;
> ! const struct option *long_options;
> ! int *opt_index;
> {
> return _getopt_internal (argc, argv, options, long_options,
opt_index, 1);
> }
> --- 78,85 ----
> instead. */
>
> int
> ! getopt_long_only (int argc, char *const *argv, const struct
option*options,
> ! const struct option *long_options, int *opt_index)
> {
> return _getopt_internal (argc, argv, options, long_options,
opt_index, 1);
> }
> *************** getopt_long_only (argc, argv, options, l
> *** 100,108 ****
> #include <stdio.h>
>
> int
> ! main (argc, argv)
> ! int argc;
> ! char **argv;
> {
> int c;
> int digit_optind = 0;
> --- 92,98 ----
> #include <stdio.h>
>
> int
> ! main (int argc, char **argv)
> {
> int c;
> int digit_optind = 0;
> Index: libiberty/getpagesize.c
> ===================================================================
> RCS file: /cvs/gcc/gcc/libiberty/getpagesize.c,v
> retrieving revision 1.6
> diff -p -r1.6 getpagesize.c
> *** libiberty/getpagesize.c 7 Oct 2001 21:53:31 -0000 1.6
> --- libiberty/getpagesize.c 27 Mar 2005 14:36:20 -0000
> *************** BUGS
> *** 61,67 ****
> #endif /* GNU_OUR_PAGESIZE */
>
> int
> ! getpagesize ()
> {
> return (GNU_OUR_PAGESIZE);
> }
> --- 61,67 ----
> #endif /* GNU_OUR_PAGESIZE */
>
> int
> ! getpagesize (void)
> {
> return (GNU_OUR_PAGESIZE);
> }
> *************** getpagesize ()
> *** 76,82 ****
> #endif
> extern unsigned long lib$getsyi(const unsigned short *,...);
>
> ! int getpagesize ()
> {
> long pagsiz = 0L;
> unsigned short itmcod = SYI$_PAGE_SIZE;
> --- 76,82 ----
> #endif
> extern unsigned long lib$getsyi(const unsigned short *,...);
>
> ! int getpagesize (void)
> {
> long pagsiz = 0L;
> unsigned short itmcod = SYI$_PAGE_SIZE;
> Index: libiberty/getpwd.c
> ===================================================================
> RCS file: /cvs/gcc/gcc/libiberty/getpwd.c,v
> retrieving revision 1.5
> diff -p -r1.5 getpwd.c
> *** libiberty/getpwd.c 22 Jan 2004 19:10:56 -0000 1.5
> --- libiberty/getpwd.c 27 Mar 2005 14:36:20 -0000
> *************** extern char *getwd ();
> *** 67,73 ****
> yield 0 and set errno. */
>
> char *
> ! getpwd ()
> {
> static char *pwd;
> static int failure_errno;
> --- 67,73 ----
> yield 0 and set errno. */
>
> char *
> ! getpwd (void)
> {
> static char *pwd;
> static int failure_errno;
> *************** getpwd ()
> *** 114,120 ****
> #endif
>
> char *
> ! getpwd ()
> {
> static char *pwd = 0;
>
> --- 114,120 ----
> #endif
>
> char *
> ! getpwd (void)
> {
> static char *pwd = 0;
>
> Index: libiberty/getruntime.c
> ===================================================================
> RCS file: /cvs/gcc/gcc/libiberty/getruntime.c,v
> retrieving revision 1.10
> diff -p -r1.10 getruntime.c
> *** libiberty/getruntime.c 7 May 2002 18:50:53 -0000 1.10
> --- libiberty/getruntime.c 27 Mar 2005 14:36:20 -0000
> *************** process started.
> *** 90,96 ****
> */
>
> long
> ! get_run_time ()
> {
> #if defined (HAVE_GETRUSAGE) && defined (HAVE_SYS_RESOURCE_H)
> struct rusage rusage;
> --- 90,96 ----
> */
>
> long
> ! get_run_time (void)
> {
> #if defined (HAVE_GETRUSAGE) && defined (HAVE_SYS_RESOURCE_H)
> struct rusage rusage;
> Index: libiberty/gettimeofday.c
> ===================================================================
> RCS file: /cvs/gcc/gcc/libiberty/gettimeofday.c,v
> retrieving revision 1.1
> diff -p -r1.1 gettimeofday.c
> *** libiberty/gettimeofday.c 10 Mar 2005 00:57:10 -0000 1.1
> --- libiberty/gettimeofday.c 27 Mar 2005 14:36:20 -0000
> *************** that @var{tz} be NULL. Returns 0 on suc
> *** 19,27 ****
> */
>
> int
> ! gettimeofday (tp, tz)
> ! struct timeval *tp;
> ! void *tz;
> {
> if (tz)
> abort ();
> --- 19,25 ----
> */
>
> int
> ! gettimeofday (struct timeval *tp, void *tz)
> {
> if (tz)
> abort ();
> Index: libiberty/hashtab.c
> ===================================================================
> RCS file: /cvs/gcc/gcc/libiberty/hashtab.c,v
> retrieving revision 1.42
> diff -p -r1.42 hashtab.c
> *** libiberty/hashtab.c 1 Mar 2005 01:03:02 -0000 1.42
> --- libiberty/hashtab.c 27 Mar 2005 14:36:21 -0000
> *************** Boston, MA 02111-1307, USA. */
> *** 73,86 ****
>
> #define DELETED_ENTRY ((PTR) 1)
>
> ! static unsigned int higher_prime_index PARAMS ((unsigned long));
> ! static hashval_t htab_mod_1 PARAMS ((hashval_t, hashval_t, hashval_t,
int));
> ! static hashval_t htab_mod PARAMS ((hashval_t, htab_t));
> ! static hashval_t htab_mod_m2 PARAMS ((hashval_t, htab_t));
> ! static hashval_t hash_pointer PARAMS ((const void *));
> ! static int eq_pointer PARAMS ((const void *, const void *));
> ! static int htab_expand PARAMS ((htab_t));
> ! static PTR *find_empty_slot_for_expand PARAMS ((htab_t, hashval_t));
>
> /* At some point, we could make these be NULL, and modify the
> hash-table routines to handle NULL specially; that would avoid
> --- 73,86 ----
>
> #define DELETED_ENTRY ((PTR) 1)
>
> ! static unsigned int higher_prime_index (unsigned long);
> ! static hashval_t htab_mod_1 (hashval_t, hashval_t, hashval_t, int);
> ! static hashval_t htab_mod (hashval_t, htab_t);
> ! static hashval_t htab_mod_m2 (hashval_t, htab_t);
> ! static hashval_t hash_pointer (const void *);
> ! static int eq_pointer (const void *, const void *);
> ! static int htab_expand (htab_t);
> ! static PTR *find_empty_slot_for_expand (htab_t, hashval_t);
>
> /* At some point, we could make these be NULL, and modify the
> hash-table routines to handle NULL specially; that would avoid
> *************** static struct prime_ent const prime_tab[
> *** 176,183 ****
> nearest prime number which is greater than N, and near a power of
two. */
>
> static unsigned int
> ! higher_prime_index (n)
> ! unsigned long n;
> {
> unsigned int low = 0;
> unsigned int high = sizeof(prime_tab) / sizeof(prime_tab[0]);
> --- 176,182 ----
> nearest prime number which is greater than N, and near a power of
two. */
>
> static unsigned int
> ! higher_prime_index (unsigned long n)
> {
> unsigned int low = 0;
> unsigned int high = sizeof(prime_tab) / sizeof(prime_tab[0]);
> *************** higher_prime_index (n)
> *** 204,211 ****
> /* Returns a hash code for P. */
>
> static hashval_t
> ! hash_pointer (p)
> ! const PTR p;
> {
> return (hashval_t) ((long)p >> 3);
> }
> --- 203,209 ----
> /* Returns a hash code for P. */
>
> static hashval_t
> ! hash_pointer (const PTR p)
> {
> return (hashval_t) ((long)p >> 3);
> }
> *************** hash_pointer (p)
> *** 213,221 ****
> /* Returns non-zero if P1 and P2 are equal. */
>
> static int
> ! eq_pointer (p1, p2)
> ! const PTR p1;
> ! const PTR p2;
> {
> return p1 == p2;
> }
> --- 211,217 ----
> /* Returns non-zero if P1 and P2 are equal. */
>
> static int
> ! eq_pointer (const PTR p1, const PTR p2)
> {
> return p1 == p2;
> }
> *************** eq_pointer (p1, p2)
> *** 223,230 ****
> /* Return the current size of given hash table. */
>
> inline size_t
> ! htab_size (htab)
> ! htab_t htab;
> {
> return htab->size;
> }
> --- 219,225 ----
> /* Return the current size of given hash table. */
>
> inline size_t
> ! htab_size (htab_t htab)
> {
> return htab->size;
> }
> *************** htab_size (htab)
> *** 232,239 ****
> /* Return the current number of elements in given hash table. */
>
> inline size_t
> ! htab_elements (htab)
> ! htab_t htab;
> {
> return htab->n_elements - htab->n_deleted;
> }
> --- 227,233 ----
> /* Return the current number of elements in given hash table. */
>
> inline size_t
> ! htab_elements (htab_t htab)
> {
> return htab->n_elements - htab->n_deleted;
> }
> *************** htab_elements (htab)
> *** 241,249 ****
> /* Return X % Y. */
>
> static inline hashval_t
> ! htab_mod_1 (x, y, inv, shift)
> ! hashval_t x, y, inv;
> ! int shift;
> {
> /* The multiplicative inverses computed above are for 32-bit types,
and
> requires that we be able to compute a highpart multiply. */
> --- 235,241 ----
> /* Return X % Y. */
>
> static inline hashval_t
> ! htab_mod_1 (hashval_t x, hashval_t y, hashval_t inv, int shift)
> {
> /* The multiplicative inverses computed above are for 32-bit types,
and
> requires that we be able to compute a highpart multiply. */
> *************** htab_mod_1 (x, y, inv, shift)
> *** 271,279 ****
> /* Compute the primary hash for HASH given HTAB's current size. */
>
> static inline hashval_t
> ! htab_mod (hash, htab)
> ! hashval_t hash;
> ! htab_t htab;
> {
> const struct prime_ent *p = &prime_tab[htab->size_prime_index];
> return htab_mod_1 (hash, p->prime, p->inv, p->shift);
> --- 263,269 ----
> /* Compute the primary hash for HASH given HTAB's current size. */
>
> static inline hashval_t
> ! htab_mod (hashval_t hash, htab_t htab)
> {
> const struct prime_ent *p = &prime_tab[htab->size_prime_index];
> return htab_mod_1 (hash, p->prime, p->inv, p->shift);
> *************** htab_mod (hash, htab)
> *** 282,290 ****
> /* Compute the secondary hash for HASH given HTAB's current size. */
>
> static inline hashval_t
> ! htab_mod_m2 (hash, htab)
> ! hashval_t hash;
> ! htab_t htab;
> {
> const struct prime_ent *p = &prime_tab[htab->size_prime_index];
> return 1 + htab_mod_1 (hash, p->prime - 2, p->inv_m2, p->shift);
> --- 272,278 ----
> /* Compute the secondary hash for HASH given HTAB's current size. */
>
> static inline hashval_t
> ! htab_mod_m2 (hashval_t hash, htab_t htab)
> {
> const struct prime_ent *p = &prime_tab[htab->size_prime_index];
> return 1 + htab_mod_1 (hash, p->prime - 2, p->inv_m2, p->shift);
> *************** htab_mod_m2 (hash, htab)
> *** 296,308 ****
> created hash table, or NULL if memory allocation fails. */
>
> htab_t
> ! htab_create_alloc (size, hash_f, eq_f, del_f, alloc_f, free_f)
> ! size_t size;
> ! htab_hash hash_f;
> ! htab_eq eq_f;
> ! htab_del del_f;
> ! htab_alloc alloc_f;
> ! htab_free free_f;
> {
> htab_t result;
> unsigned int size_prime_index;
> --- 284,291 ----
> created hash table, or NULL if memory allocation fails. */
>
> htab_t
> ! htab_create_alloc (size_t size, htab_hash hash_f, htab_eq eq_f,
> ! htab_del del_f, htab_alloc alloc_f, htab_free
free_f)
> {
> htab_t result;
> unsigned int size_prime_index;
> *************** htab_create_alloc_ex (size, hash_f, eq_f
> *** 374,387 ****
> /* Update the function pointers and allocation parameter in the htab_t.
*/
>
> void
> ! htab_set_functions_ex (htab, hash_f, eq_f, del_f, alloc_arg,
> alloc_f, free_f)
> ! htab_t htab;
> ! htab_hash hash_f;
> ! htab_eq eq_f;
> ! htab_del del_f;
> ! PTR alloc_arg;
> ! htab_alloc_with_arg alloc_f;
> ! htab_free_with_arg free_f;
> {
> htab->hash_f = hash_f;
> htab->eq_f = eq_f;
> --- 357,365 ----
> /* Update the function pointers and allocation parameter in the htab_t.
*/
>
> void
> ! htab_set_functions_ex (htab_t htab, htab_hash hash_f, htab_eq eq_f,
> ! htab_del del_f, PTR alloc_arg,
> ! htab_alloc_with_arg alloc_f,
> htab_free_with_arg free_f)
> {
> htab->hash_f = hash_f;
> htab->eq_f = eq_f;
> *************** htab_set_functions_ex (htab, hash_f, eq_
> *** 395,415 ****
>
> #undef htab_create
> htab_t
> ! htab_create (size, hash_f, eq_f, del_f)
> ! size_t size;
> ! htab_hash hash_f;
> ! htab_eq eq_f;
> ! htab_del del_f;
> {
> return htab_create_alloc (size, hash_f, eq_f, del_f, xcalloc, free);
> }
>
> htab_t
> ! htab_try_create (size, hash_f, eq_f, del_f)
> ! size_t size;
> ! htab_hash hash_f;
> ! htab_eq eq_f;
> ! htab_del del_f;
> {
> return htab_create_alloc (size, hash_f, eq_f, del_f, calloc, free);
> }
> --- 373,385 ----
>
> #undef htab_create
> htab_t
> ! htab_create (size_t size, htab_hash hash_f, htab_eq eq_f, htab_del
del_f)
> {
> return htab_create_alloc (size, hash_f, eq_f, del_f, xcalloc, free);
> }
>
> htab_t
> ! htab_try_create (size_t size, htab_hash hash_f, htab_eq eq_f,
> htab_del del_f)
> {
> return htab_create_alloc (size, hash_f, eq_f, del_f, calloc, free);
> }
> *************** htab_try_create (size, hash_f, eq_f, del
> *** 418,425 ****
> Naturally the hash table must already exist. */
>
> void
> ! htab_delete (htab)
> ! htab_t htab;
> {
> size_t size = htab_size (htab);
> PTR *entries = htab->entries;
> --- 388,394 ----
> Naturally the hash table must already exist. */
>
> void
> ! htab_delete (htab_t htab)
> {
> size_t size = htab_size (htab);
> PTR *entries = htab->entries;
> *************** htab_delete (htab)
> *** 445,452 ****
> /* This function clears all entries in the given hash table. */
>
> void
> ! htab_empty (htab)
> ! htab_t htab;
> {
> size_t size = htab_size (htab);
> PTR *entries = htab->entries;
> --- 414,420 ----
> /* This function clears all entries in the given hash table. */
>
> void
> ! htab_empty (htab_t htab)
> {
> size_t size = htab_size (htab);
> PTR *entries = htab->entries;
> *************** htab_empty (htab)
> *** 468,476 ****
> HASH is the hash value for the element to be inserted. */
>
> static PTR *
> ! find_empty_slot_for_expand (htab, hash)
> ! htab_t htab;
> ! hashval_t hash;
> {
> hashval_t index = htab_mod (hash, htab);
> size_t size = htab_size (htab);
> --- 436,442 ----
> HASH is the hash value for the element to be inserted. */
>
> static PTR *
> ! find_empty_slot_for_expand (htab_t htab, hashval_t hash)
> {
> hashval_t index = htab_mod (hash, htab);
> size_t size = htab_size (htab);
> *************** find_empty_slot_for_expand (htab, hash)
> *** 506,513 ****
> expanded. If all goes well, it will return a non-zero value. */
>
> static int
> ! htab_expand (htab)
> ! htab_t htab;
> {
> PTR *oentries;
> PTR *olimit;
> --- 472,478 ----
> expanded. If all goes well, it will return a non-zero value. */
>
> static int
> ! htab_expand (htab_t htab)
> {
> PTR *oentries;
> PTR *olimit;
> *************** htab_expand (htab)
> *** 575,584 ****
> element. It cannot be used to insert or delete an element. */
>
> PTR
> ! htab_find_with_hash (htab, element, hash)
> ! htab_t htab;
> ! const PTR element;
> ! hashval_t hash;
> {
> hashval_t index, hash2;
> size_t size;
> --- 540,546 ----
> element. It cannot be used to insert or delete an element. */
>
> PTR
> ! htab_find_with_hash (htab_t htab, const PTR element, hashval_t hash)
> {
> hashval_t index, hash2;
> size_t size;
> *************** htab_find_with_hash (htab, element, hash
> *** 612,620 ****
> element. */
>
> PTR
> ! htab_find (htab, element)
> ! htab_t htab;
> ! const PTR element;
> {
> return htab_find_with_hash (htab, element, (*htab->hash_f)
(element));
> }
> --- 574,580 ----
> element. */
>
> PTR
> ! htab_find (htab_t htab, const PTR element)
> {
> return htab_find_with_hash (htab, element, (*htab->hash_f)
(element));
> }
> *************** htab_find (htab, element)
> *** 628,638 ****
> allocation fails. */
>
> PTR *
> ! htab_find_slot_with_hash (htab, element, hash, insert)
> ! htab_t htab;
> ! const PTR element;
> ! hashval_t hash;
> ! enum insert_option insert;
> {
> PTR *first_deleted_slot;
> hashval_t index, hash2;
> --- 588,595 ----
> allocation fails. */
>
> PTR *
> ! htab_find_slot_with_hash (htab_t htab, const PTR element,
> ! hashval_t hash, enum insert_option insert)
> {
> PTR *first_deleted_slot;
> hashval_t index, hash2;
> *************** htab_find_slot_with_hash (htab, element,
> *** 699,708 ****
> element. */
>
> PTR *
> ! htab_find_slot (htab, element, insert)
> ! htab_t htab;
> ! const PTR element;
> ! enum insert_option insert;
> {
> return htab_find_slot_with_hash (htab, element, (*htab->hash_f)
(element),
> insert);
> --- 656,662 ----
> element. */
>
> PTR *
> ! htab_find_slot (htab_t htab, const PTR element, enum insert_option
insert)
> {
> return htab_find_slot_with_hash (htab, element, (*htab->hash_f)
(element),
> insert);
> *************** htab_find_slot (htab, element, insert)
> *** 713,721 ****
> element in the hash table, this function does nothing. */
>
> void
> ! htab_remove_elt (htab, element)
> ! htab_t htab;
> ! PTR element;
> {
> htab_remove_elt_with_hash (htab, element, (*htab->hash_f) (element));
> }
> --- 667,673 ----
> element in the hash table, this function does nothing. */
>
> void
> ! htab_remove_elt (htab_t htab, PTR element)
> {
> htab_remove_elt_with_hash (htab, element, (*htab->hash_f) (element));
> }
> *************** htab_remove_elt (htab, element)
> *** 726,735 ****
> function does nothing. */
>
> void
> ! htab_remove_elt_with_hash (htab, element, hash)
> ! htab_t htab;
> ! PTR element;
> ! hashval_t hash;
> {
> PTR *slot;
>
> --- 678,684 ----
> function does nothing. */
>
> void
> ! htab_remove_elt_with_hash (htab_t htab, PTR element, hashval_t hash)
> {
> PTR *slot;
>
> *************** htab_remove_elt_with_hash (htab, element
> *** 749,757 ****
> again. */
>
> void
> ! htab_clear_slot (htab, slot)
> ! htab_t htab;
> ! PTR *slot;
> {
> if (slot < htab->entries || slot >= htab->entries + htab_size (htab)
> || *slot == EMPTY_ENTRY || *slot == DELETED_ENTRY)
> --- 698,704 ----
> again. */
>
> void
> ! htab_clear_slot (htab_t htab, PTR *slot)
> {
> if (slot < htab->entries || slot >= htab->entries + htab_size (htab)
> || *slot == EMPTY_ENTRY || *slot == DELETED_ENTRY)
> *************** htab_clear_slot (htab, slot)
> *** 770,779 ****
> argument. */
>
> void
> ! htab_traverse_noresize (htab, callback, info)
> ! htab_t htab;
> ! htab_trav callback;
> ! PTR info;
> {
> PTR *slot;
> PTR *limit;
> --- 717,723 ----
> argument. */
>
> void
> ! htab_traverse_noresize (htab_t htab, htab_trav callback, PTR info)
> {
> PTR *slot;
> PTR *limit;
> *************** htab_traverse_noresize (htab, callback,
> *** 796,805 ****
> too empty to improve effectivity of subsequent calls. */
>
> void
> ! htab_traverse (htab, callback, info)
> ! htab_t htab;
> ! htab_trav callback;
> ! PTR info;
> {
> if (htab_elements (htab) * 8 < htab_size (htab))
> htab_expand (htab);
> --- 740,746 ----
> too empty to improve effectivity of subsequent calls. */
>
> void
> ! htab_traverse (htab_t htab, htab_trav callback, PTR info)
> {
> if (htab_elements (htab) * 8 < htab_size (htab))
> htab_expand (htab);
> *************** htab_traverse (htab, callback, info)
> *** 811,818 ****
> hash table. */
>
> double
> ! htab_collisions (htab)
> ! htab_t htab;
> {
> if (htab->searches == 0)
> return 0.0;
> --- 752,758 ----
> hash table. */
>
> double
> ! htab_collisions (htab_t htab)
> {
> if (htab->searches == 0)
> return 0.0;
> *************** htab_collisions (htab)
> *** 846,853 ****
> function they just started using for Perl's hashes. */
>
> hashval_t
> ! htab_hash_string (p)
> ! const PTR p;
> {
> const unsigned char *str = (const unsigned char *) p;
> hashval_t r = 0;
> --- 786,792 ----
> function they just started using for Perl's hashes. */
>
> hashval_t
> ! htab_hash_string (const PTR p)
> {
> const unsigned char *str = (const unsigned char *) p;
> hashval_t r = 0;
> *************** acceptable. Do NOT use for cryptographi
> *** 936,945 ****
> --------------------------------------------------------------------
> */
>
> ! hashval_t iterative_hash (k_in, length, initval)
> ! const PTR k_in; /* the key */
> ! register size_t length; /* the length of the key */
> ! register hashval_t initval; /* the previous hash, or an
> arbitrary value */
> {
> register const unsigned char *k = (const unsigned char *)k_in;
> register hashval_t a,b,c,len;
> --- 875,885 ----
> --------------------------------------------------------------------
> */
>
> ! hashval_t
> ! iterative_hash (const PTR k_in /* the key */,
> ! register size_t length /* the length of the key */,
> ! register hashval_t initval /* the previous hash, or
> ! an arbitrary value */)
> {
> register const unsigned char *k = (const unsigned char *)k_in;
> register hashval_t a,b,c,len;
> Index: libiberty/hex.c
> ===================================================================
> RCS file: /cvs/gcc/gcc/libiberty/hex.c,v
> retrieving revision 1.8
> diff -p -r1.8 hex.c
> *** libiberty/hex.c 11 Jan 2005 20:22:38 -0000 1.8
> --- libiberty/hex.c 27 Mar 2005 14:36:21 -0000
> *************** unsigned char _hex_value[_hex_array_size
> *** 153,159 ****
> #endif /* not ASCII */
>
> void
> ! hex_init ()
> {
> #ifndef HEX_TABLE_INITIALIZED
> int i;
> --- 153,159 ----
> #endif /* not ASCII */
>
> void
> ! hex_init (void)
> {
> #ifndef HEX_TABLE_INITIALIZED
> int i;
> Index: libiberty/index.c
> ===================================================================
> RCS file: /cvs/gcc/gcc/libiberty/index.c,v
> retrieving revision 1.5
> diff -p -r1.5 index.c
> *** libiberty/index.c 7 Oct 2001 21:53:31 -0000 1.5
> --- libiberty/index.c 27 Mar 2005 14:36:21 -0000
> *************** deprecated in new programs in favor of @
> *** 12,23 ****
>
> */
>
> ! extern char * strchr();
>
> char *
> ! index (s, c)
> ! char *s;
> ! int c;
> {
> return strchr (s, c);
> }
> --- 12,21 ----
>
> */
>
> ! extern char * strchr(const char *, int);
>
> char *
> ! index (char *s, int c)
> {
> return strchr (s, c);
> }
> Index: libiberty/insque.c
> ===================================================================
> RCS file: /cvs/gcc/gcc/libiberty/insque.c,v
> retrieving revision 1.3
> diff -p -r1.3 insque.c
> *** libiberty/insque.c 16 Oct 2001 02:50:13 -0000 1.3
> --- libiberty/insque.c 27 Mar 2005 14:36:21 -0000
> *************** struct qelem {
> *** 33,41 ****
>
>
> void
> ! insque (elem, pred)
> ! struct qelem *elem;
> ! struct qelem *pred;
> {
> elem -> q_forw = pred -> q_forw;
> pred -> q_forw -> q_back = elem;
> --- 33,39 ----
>
>
> void
> ! insque (struct qelem *elem, struct qelem *pred)
> {
> elem -> q_forw = pred -> q_forw;
> pred -> q_forw -> q_back = elem;
> *************** insque (elem, pred)
> *** 45,52 ****
>
>
> void
> ! remque (elem)
> ! struct qelem *elem;
> {
> elem -> q_forw -> q_back = elem -> q_back;
> elem -> q_back -> q_forw = elem -> q_forw;
> --- 43,49 ----
>
>
> void
> ! remque (struct qelem *elem)
> {
> elem -> q_forw -> q_back = elem -> q_back;
> elem -> q_back -> q_forw = elem -> q_forw;
> Index: libiberty/lbasename.c
> ===================================================================
> RCS file: /cvs/gcc/gcc/libiberty/lbasename.c,v
> retrieving revision 1.5
> diff -p -r1.5 lbasename.c
> *** libiberty/lbasename.c 22 Dec 2003 19:21:37 -0000 1.5
> --- libiberty/lbasename.c 27 Mar 2005 14:36:21 -0000
> *************** and a path ending in @code{/} returns th
> *** 43,50 ****
> #include "filenames.h"
>
> const char *
> ! lbasename (name)
> ! const char *name;
> {
> const char *base;
>
> --- 43,49 ----
> #include "filenames.h"
>
> const char *
> ! lbasename (const char *name)
> {
> const char *base;
>
> Index: libiberty/lrealpath.c
> ===================================================================
> RCS file: /cvs/gcc/gcc/libiberty/lrealpath.c,v
> retrieving revision 1.2
> diff -p -r1.2 lrealpath.c
> *** libiberty/lrealpath.c 29 Jun 2004 11:37:20 -0000 1.2
> --- libiberty/lrealpath.c 27 Mar 2005 14:36:21 -0000
> *************** extern char *canonicalize_file_name (con
> *** 73,80 ****
> #endif
>
> char *
> ! lrealpath (filename)
> ! const char *filename;
> {
> /* Method 1: The system has a compile time upper bound on a filename
> path. Use that and realpath() to canonicalize the name. This is
> --- 73,79 ----
> #endif
>
> char *
> ! lrealpath (const char *filename)
> {
> /* Method 1: The system has a compile time upper bound on a filename
> path. Use that and realpath() to canonicalize the name. This is
> Index: libiberty/make-relative-prefix.c
> ===================================================================
> RCS file: /cvs/gcc/gcc/libiberty/make-relative-prefix.c,v
> retrieving revision 1.4
> diff -p -r1.4 make-relative-prefix.c
> *** libiberty/make-relative-prefix.c 20 Feb 2003 22:10:58 -0000 1.4
> --- libiberty/make-relative-prefix.c 27 Mar 2005 14:36:21 -0000
> *************** relative prefix can be found, return @co
> *** 95,108 ****
>
> #define DIR_UP ".."
>
> ! static char *save_string PARAMS ((const char *, int));
> ! static char **split_directories PARAMS ((const char *, int *));
> ! static void free_split_directories PARAMS ((char **));
>
> static char *
> ! save_string (s, len)
> ! const char *s;
> ! int len;
> {
> char *result = malloc (len + 1);
>
> --- 95,106 ----
>
> #define DIR_UP ".."
>
> ! static char *save_string (const char *, int);
> ! static char **split_directories (const char *, int *);
> ! static void free_split_directories (char **);
>
> static char *
> ! save_string (const char *s, int len)
> {
> char *result = malloc (len + 1);
>
> *************** save_string (s, len)
> *** 114,122 ****
> /* Split a filename into component directories. */
>
> static char **
> ! split_directories (name, ptr_num_dirs)
> ! const char *name;
> ! int *ptr_num_dirs;
> {
> int num_dirs = 0;
> char **dirs;
> --- 112,118 ----
> /* Split a filename into component directories. */
>
> static char **
> ! split_directories (const char *name, int *ptr_num_dirs)
> {
> int num_dirs = 0;
> char **dirs;
> *************** split_directories (name, ptr_num_dirs)
> *** 201,208 ****
> /* Release storage held by split directories. */
>
> static void
> ! free_split_directories (dirs)
> ! char **dirs;
> {
> int i = 0;
>
> --- 197,203 ----
> /* Release storage held by split directories. */
>
> static void
> ! free_split_directories (char **dirs)
> {
> int i = 0;
>
> *************** free_split_directories (dirs)
> *** 223,232 ****
> If no relative prefix can be found, return NULL. */
>
> char *
> ! make_relative_prefix (progname, bin_prefix, prefix)
> ! const char *progname;
> ! const char *bin_prefix;
> ! const char *prefix;
> {
> char **prog_dirs, **bin_dirs, **prefix_dirs;
> int prog_num, bin_num, prefix_num;
> --- 218,225 ----
> If no relative prefix can be found, return NULL. */
>
> char *
> ! make_relative_prefix (const char *progname,
> ! const char *bin_prefix, const char *prefix)
> {
> char **prog_dirs, **bin_dirs, **prefix_dirs;
> int prog_num, bin_num, prefix_num;
> Index: libiberty/make-temp-file.c
> ===================================================================
> RCS file: /cvs/gcc/gcc/libiberty/make-temp-file.c,v
> retrieving revision 1.5
> diff -p -r1.5 make-temp-file.c
> *** libiberty/make-temp-file.c 17 Oct 2001 21:15:41 -0000 1.5
> --- libiberty/make-temp-file.c 27 Mar 2005 14:36:21 -0000
> *************** Boston, MA 02111-1307, USA. */
> *** 43,49 ****
> #endif
>
> #include "libiberty.h"
> ! extern int mkstemps PARAMS ((char *, int));
>
> /* '/' works just fine on MS-DOS based systems. */
> #ifndef DIR_SEPARATOR
> --- 43,49 ----
> #endif
>
> #include "libiberty.h"
> ! extern int mkstemps (char *, int);
>
> /* '/' works just fine on MS-DOS based systems. */
> #ifndef DIR_SEPARATOR
> *************** extern int mkstemps PARAMS ((char *, int
> *** 61,71 ****
> If success, DIR is returned.
> Otherwise NULL is returned. */
>
> ! static inline const char *try PARAMS ((const char *, const char *));
>
> static inline const char *
> ! try (dir, base)
> ! const char *dir, *base;
> {
> if (base != 0)
> return base;
> --- 61,70 ----
> If success, DIR is returned.
> Otherwise NULL is returned. */
>
> ! static inline const char *try (const char *, const char *);
>
> static inline const char *
> ! try (const char *dir, const char *base)
> {
> if (base != 0)
> return base;
> *************** files in.
> *** 95,101 ****
> */
>
> char *
> ! choose_tmpdir ()
> {
> const char *base = 0;
> char *tmpdir;
> --- 94,100 ----
> */
>
> char *
> ! choose_tmpdir (void)
> {
> const char *base = 0;
> char *tmpdir;
> *************** string is @code{malloc}ed, and the tempo
> *** 146,153 ****
> */
>
> char *
> ! make_temp_file (suffix)
> ! const char *suffix;
> {
> const char *base = choose_tmpdir ();
> char *temp_filename;
> --- 145,151 ----
> */
>
> char *
> ! make_temp_file (const char *suffix)
> {
> const char *base = choose_tmpdir ();
> char *temp_filename;
> Index: libiberty/md5.c
> ===================================================================
> RCS file: /cvs/gcc/gcc/libiberty/md5.c,v
> retrieving revision 1.6
> diff -p -r1.6 md5.c
> *** libiberty/md5.c 16 Nov 2002 12:38:43 -0000 1.6
> --- libiberty/md5.c 27 Mar 2005 14:36:21 -0000
> *************** static const unsigned char fillbuf[64] =
> *** 62,69 ****
> /* Initialize structure containing state of computation.
> (RFC 1321, 3.3: Step 3) */
> void
> ! md5_init_ctx (ctx)
> ! struct md5_ctx *ctx;
> {
> ctx->A = (md5_uint32) 0x67452301;
> ctx->B = (md5_uint32) 0xefcdab89;
> --- 62,68 ----
> /* Initialize structure containing state of computation.
> (RFC 1321, 3.3: Step 3) */
> void
> ! md5_init_ctx (struct md5_ctx *ctx)
> {
> ctx->A = (md5_uint32) 0x67452301;
> ctx->B = (md5_uint32) 0xefcdab89;
> *************** md5_init_ctx (ctx)
> *** 80,88 ****
> IMPORTANT: On some systems it is required that RESBUF is correctly
> aligned for a 32 bits value. */
> void *
> ! md5_read_ctx (ctx, resbuf)
> ! const struct md5_ctx *ctx;
> ! void *resbuf;
> {
> ((md5_uint32 *) resbuf)[0] = SWAP (ctx->A);
> ((md5_uint32 *) resbuf)[1] = SWAP (ctx->B);
> --- 79,85 ----
> IMPORTANT: On some systems it is required that RESBUF is correctly
> aligned for a 32 bits value. */
> void *
> ! md5_read_ctx (const struct md5_ctx *ctx, void *resbuf)
> {
> ((md5_uint32 *) resbuf)[0] = SWAP (ctx->A);
> ((md5_uint32 *) resbuf)[1] = SWAP (ctx->B);
> *************** md5_read_ctx (ctx, resbuf)
> *** 98,106 ****
> IMPORTANT: On some systems it is required that RESBUF is correctly
> aligned for a 32 bits value. */
> void *
> ! md5_finish_ctx (ctx, resbuf)
> ! struct md5_ctx *ctx;
> ! void *resbuf;
> {
> /* Take yet unprocessed bytes into account. */
> md5_uint32 bytes = ctx->buflen;
> --- 95,101 ----
> IMPORTANT: On some systems it is required that RESBUF is correctly
> aligned for a 32 bits value. */
> void *
> ! md5_finish_ctx (struct md5_ctx *ctx, void *resbuf)
> {
> /* Take yet unprocessed bytes into account. */
> md5_uint32 bytes = ctx->buflen;
> *************** md5_finish_ctx (ctx, resbuf)
> *** 129,137 ****
> resulting message digest number will be written into the 16 bytes
> beginning at RESBLOCK. */
> int
> ! md5_stream (stream, resblock)
> ! FILE *stream;
> ! void *resblock;
> {
> /* Important: BLOCKSIZE must be a multiple of 64. */
> #define BLOCKSIZE 4096
> --- 124,130 ----
> resulting message digest number will be written into the 16 bytes
> beginning at RESBLOCK. */
> int
> ! md5_stream (FILE *stream, void *resblock)
> {
> /* Important: BLOCKSIZE must be a multiple of 64. */
> #define BLOCKSIZE 4096
> *************** md5_stream (stream, resblock)
> *** 186,195 ****
> output yields to the wanted ASCII representation of the message
> digest. */
> void *
> ! md5_buffer (buffer, len, resblock)
> ! const char *buffer;
> ! size_t len;
> ! void *resblock;
> {
> struct md5_ctx ctx;
>
> --- 179,185 ----
> output yields to the wanted ASCII representation of the message
> digest. */
> void *
> ! md5_buffer (const char *buffer, size_t len, void *resblock)
> {
> struct md5_ctx ctx;
>
> *************** md5_buffer (buffer, len, resblock)
> *** 205,214 ****
>
>
> void
> ! md5_process_bytes (buffer, len, ctx)
> ! const void *buffer;
> ! size_t len;
> ! struct md5_ctx *ctx;
> {
> /* When we already have some bits in our internal buffer concatenate
> both inputs first. */
> --- 195,201 ----
>
>
> void
> ! md5_process_bytes (const void *buffer, size_t len, struct md5_ctx *ctx)
> {
> /* When we already have some bits in our internal buffer concatenate
> both inputs first. */
> *************** md5_process_bytes (buffer, len, ctx)
> *** 263,272 ****
> It is assumed that LEN % 64 == 0. */
>
> void
> ! md5_process_block (buffer, len, ctx)
> ! const void *buffer;
> ! size_t len;
> ! struct md5_ctx *ctx;
> {
> md5_uint32 correct_words[16];
> const md5_uint32 *words = (const md5_uint32 *) buffer;
> --- 250,256 ----
> It is assumed that LEN % 64 == 0. */
>
> void
> ! md5_process_block (const void *buffer, size_t len, struct md5_ctx *ctx)
> {
> md5_uint32 correct_words[16];
> const md5_uint32 *words = (const md5_uint32 *) buffer;
> Index: libiberty/memchr.c
> ===================================================================
> RCS file: /cvs/gcc/gcc/libiberty/memchr.c,v
> retrieving revision 1.7
> diff -p -r1.7 memchr.c
> *** libiberty/memchr.c 15 Apr 2003 03:35:47 -0000 1.7
> --- libiberty/memchr.c 27 Mar 2005 14:36:21 -0000
> *************** returned.
> *** 15,31 ****
> */
>
> #include <ansidecl.h>
> - #ifdef ANSI_PROTOTYPES
> #include <stddef.h>
> - #else
> - #define size_t unsigned long
> - #endif
>
> PTR
> ! memchr (src_void, c, length)
> ! register const PTR src_void;
> ! int c;
> ! size_t length;
> {
> const unsigned char *src = (const unsigned char *)src_void;
>
> --- 15,24 ----
> */
>
> #include <ansidecl.h>
> #include <stddef.h>
>
> PTR
> ! memchr (register const PTR src_void, int c, size_t length)
> {
> const unsigned char *src = (const unsigned char *)src_void;
>
> Index: libiberty/memcmp.c
> ===================================================================
> RCS file: /cvs/gcc/gcc/libiberty/memcmp.c,v
> retrieving revision 1.5
> diff -p -r1.5 memcmp.c
> *** libiberty/memcmp.c 15 Apr 2003 03:35:47 -0000 1.5
> --- libiberty/memcmp.c 27 Mar 2005 14:36:21 -0000
> *************** as if comparing unsigned char arrays.
> *** 16,32 ****
> */
>
> #include <ansidecl.h>
> - #ifdef ANSI_PROTOTYPES
> #include <stddef.h>
> - #else
> - #define size_t unsigned long
> - #endif
>
> int
> ! memcmp (str1, str2, count)
> ! const PTR str1;
> ! const PTR str2;
> ! size_t count;
> {
> register const unsigned char *s1 = (const unsigned char*)str1;
> register const unsigned char *s2 = (const unsigned char*)str2;
> --- 16,25 ----
> */
>
> #include <ansidecl.h>
> #include <stddef.h>
>
> int
> ! memcmp (const PTR str1, const PTR str2, size_t count)
> {
> register const unsigned char *s1 = (const unsigned char*)str1;
> register const unsigned char *s2 = (const unsigned char*)str2;
> Index: libiberty/memcpy.c
> ===================================================================
> RCS file: /cvs/gcc/gcc/libiberty/memcpy.c,v
> retrieving revision 1.5
> diff -p -r1.5 memcpy.c
> *** libiberty/memcpy.c 15 Apr 2003 03:35:47 -0000 1.5
> --- libiberty/memcpy.c 27 Mar 2005 14:36:21 -0000
> *************** Copies @var{length} bytes from memory re
> *** 19,31 ****
> #define size_t unsigned long
> #endif
>
> ! void bcopy PARAMS((const void*, void*, size_t));
>
> PTR
> ! memcpy (out, in, length)
> ! PTR out;
> ! const PTR in;
> ! size_t length;
> {
> bcopy(in, out, length);
> return out;
> --- 19,28 ----
> #define size_t unsigned long
> #endif
>
> ! void bcopy (const void*, void*, size_t);
>
> PTR
> ! memcpy (PTR out, const PTR in, size_t length)
> {
> bcopy(in, out, length);
> return out;
> Index: libiberty/memmove.c
> ===================================================================
> RCS file: /cvs/gcc/gcc/libiberty/memmove.c,v
> retrieving revision 1.5
> diff -p -r1.5 memmove.c
> *** libiberty/memmove.c 15 Apr 2003 03:35:47 -0000 1.5
> --- libiberty/memmove.c 27 Mar 2005 14:36:21 -0000
> *************** Copies @var{count} bytes from memory are
> *** 19,31 ****
> #define size_t unsigned long
> #endif
>
> ! void bcopy PARAMS ((const void*, void*, size_t));
>
> PTR
> ! memmove (s1, s2, n)
> ! PTR s1;
> ! const PTR s2;
> ! size_t n;
> {
> bcopy (s2, s1, n);
> return s1;
> --- 19,28 ----
> #define size_t unsigned long
> #endif
>
> ! void bcopy (const void*, void*, size_t);
>
> PTR
> ! memmove (PTR s1, const PTR s2, size_t n)
> {
> bcopy (s2, s1, n);
> return s1;
More information about the Gcc-patches
mailing list