This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
Patch for bzero uses
- To: <gcc-patches at gcc dot gnu dot org>
- Subject: Patch for bzero uses
- From: "Joseph S. Myers" <jsm28 at cam dot ac dot uk>
- Date: Fri, 3 Nov 2000 23:23:30 +0000 (GMT)
This patch changes uses of bzero () to memset ().
Bootstrapped with no regressions on i686-pc-linux-gnu. OK to commit?
gcc/ChangeLog:
2000-11-03 Joseph S. Myers <jsm28@cam.ac.uk>
* alias.c (init_alias_analysis), calls.c (expand_call,
emit_library_call_value_1), combine.c (init_reg_last_arrays),
cse.c (new_basic_block), dbxout.c (dbxout_type), diagnostic.c
(init_output_buffer, set_diagnostic_context), dwarf2out.c
(equate_decl_number_to_die, build_abbrev_table), emit-rtl.c
(init_emit_once), fold-const.c (mul_double, div_and_round_double),
function.c (assign_parms), gcse.c (compute_can_copy,
alloc_gcse_mem, alloc_reg_set_mem, record_one_set,
compute_hash_table, compute_set_hash_table,
compute_expr_hash_table), genattrtab.c (optimize_attrs), global.c
(global_alloc, global_conflicts), haifa-sched.c (compute_trg_info,
clear_units, schedule_block), integrate.c (initialize_for_inline,
expand_inline_function), jump.c (thread_jumps), local-alloc.c
(local_alloc), loop.c (combine_movables, count_loop_regs_set,
load_mems_and_recount_loop_regs_set), print-tree.c (debug_tree),
regclass.c (init_reg_sets, init_reg_sets_1, regclass,
record_reg_classes, allocate_reg_info), reload.c
(get_secondary_mem, remove_address_replacements, find_reloads),
reload1.c (reload, set_initial_label_offsets, finish_spills,
reload_as_needed, choose_reload_regs_init,
reload_cse_simplify_operands), reorg.c (dbr_schedule), sbitmap.c
(sbitmap_zero), simplify-rtx.c (simplify_plus_minus), ssa.c
(rename_registers), stmt.c (expand_end_case), unroll.c
(unroll_loop), varray.c (varray_grow), objc/objc-act.c: Use memset
() instead of bzero ().
gcc/ch/ChangeLog:
2000-11-03 Joseph S. Myers <jsm28@cam.ac.uk>
* actions.c (check_missing_cases), typeck.c (build_chill_slice,
build_chill_cast): Use memset () instead of bzero ().
gcc/cp/ChangeLog:
2000-11-03 Joseph S. Myers <jsm28@cam.ac.uk>
* class.c (duplicate_tag_error, build_vtbl_initializer), decl.c
(push_binding_level), error.c (cp_tree_printer), pt.c
(process_partial_specialization, tsubst_template_arg_vector),
search.c (lookup_member): Use memset () instead of bzero ().
gcc/java/ChangeLog:
2000-11-03 Joseph S. Myers <jsm28@cam.ac.uk>
* expr.c (note_instructions), jcf-io.c (find_class), jcf-parse.c
(init_outgoing_cpool), lex.c (java_init_lex): Use memset ()
instead of bzero ().
--- alias.c.orig Wed Oct 25 06:53:07 2000
+++ alias.c Fri Nov 3 19:44:45 2000
@@ -2053,7 +2053,7 @@ init_alias_analysis ()
/* ??? Why are we realloc'ing if we're just going to zero it? */
alias_invariant = (rtx *)xrealloc (alias_invariant,
reg_base_value_size * sizeof (rtx));
- bzero ((char *)alias_invariant, reg_base_value_size * sizeof (rtx));
+ memset ((char *)alias_invariant, 0, reg_base_value_size * sizeof (rtx));
}
@@ -2091,10 +2091,10 @@ init_alias_analysis ()
copying_arguments = 1;
/* Wipe the potential alias information clean for this pass. */
- bzero ((char *) new_reg_base_value, reg_base_value_size * sizeof (rtx));
+ memset ((char *) new_reg_base_value, 0, reg_base_value_size * sizeof (rtx));
/* Wipe the reg_seen array clean. */
- bzero ((char *) reg_seen, reg_base_value_size);
+ memset ((char *) reg_seen, 0, reg_base_value_size);
/* Mark all hard registers which may contain an address.
The stack, frame and argument pointers may contain an address.
--- calls.c.orig Fri Oct 27 20:18:30 2000
+++ calls.c Fri Nov 3 19:44:45 2000
@@ -2377,7 +2377,7 @@ expand_call (exp, target, ignore)
/* Make a vector to hold all the information about each arg. */
args = (struct arg_data *) alloca (num_actuals * sizeof (struct arg_data));
- bzero ((char *) args, num_actuals * sizeof (struct arg_data));
+ memset ((char *) args, 0, num_actuals * sizeof (struct arg_data));
/* Build up entries inthe ARGS array, compute the size of the arguments
into ARGS_SIZE, etc. */
@@ -2787,7 +2787,7 @@ expand_call (exp, target, ignore)
initial_highest_arg_in_use);
if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
- bzero (&stack_usage_map[initial_highest_arg_in_use],
+ memset (&stack_usage_map[initial_highest_arg_in_use], 0,
(highest_outgoing_arg_in_use
- initial_highest_arg_in_use));
needed = 0;
@@ -2876,7 +2876,7 @@ expand_call (exp, target, ignore)
/* Make a new map for the new argument list. */
stack_usage_map = (char *)
alloca (highest_outgoing_arg_in_use);
- bzero (stack_usage_map, highest_outgoing_arg_in_use);
+ memset (stack_usage_map, 0, highest_outgoing_arg_in_use);
highest_outgoing_arg_in_use = 0;
}
allocate_dynamic_stack_space (push_size, NULL_RTX,
@@ -3578,7 +3578,7 @@ emit_library_call_value_1 (retval, orgfu
library functions shouldn't have many args. */
argvec = (struct arg *) alloca ((nargs + 1) * sizeof (struct arg));
- bzero ((char *) argvec, (nargs + 1) * sizeof (struct arg));
+ memset ((char *) argvec, 0, (nargs + 1) * sizeof (struct arg));
INIT_CUMULATIVE_ARGS (args_so_far, NULL_TREE, fun, 0);
@@ -3771,7 +3771,7 @@ emit_library_call_value_1 (retval, orgfu
initial_highest_arg_in_use);
if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
- bzero (&stack_usage_map[initial_highest_arg_in_use],
+ memset (&stack_usage_map[initial_highest_arg_in_use], 0,
highest_outgoing_arg_in_use - initial_highest_arg_in_use);
needed = 0;
--- combine.c.orig Thu Nov 2 22:26:30 2000
+++ combine.c Fri Nov 3 19:44:45 2000
@@ -789,15 +789,15 @@ init_reg_last_arrays ()
{
unsigned int nregs = combine_max_regno;
- bzero ((char *) reg_last_death, nregs * sizeof (rtx));
- bzero ((char *) reg_last_set, nregs * sizeof (rtx));
- bzero ((char *) reg_last_set_value, nregs * sizeof (rtx));
- bzero ((char *) reg_last_set_table_tick, nregs * sizeof (int));
- bzero ((char *) reg_last_set_label, nregs * sizeof (int));
- bzero (reg_last_set_invalid, nregs * sizeof (char));
- bzero ((char *) reg_last_set_mode, nregs * sizeof (enum machine_mode));
- bzero ((char *) reg_last_set_nonzero_bits, nregs * sizeof (HOST_WIDE_INT));
- bzero (reg_last_set_sign_bit_copies, nregs * sizeof (char));
+ memset ((char *) reg_last_death, 0, nregs * sizeof (rtx));
+ memset ((char *) reg_last_set, 0, nregs * sizeof (rtx));
+ memset ((char *) reg_last_set_value, 0, nregs * sizeof (rtx));
+ memset ((char *) reg_last_set_table_tick, 0, nregs * sizeof (int));
+ memset ((char *) reg_last_set_label, 0, nregs * sizeof (int));
+ memset (reg_last_set_invalid, 0, nregs * sizeof (char));
+ memset ((char *) reg_last_set_mode, 0, nregs * sizeof (enum machine_mode));
+ memset ((char *) reg_last_set_nonzero_bits, 0, nregs * sizeof (HOST_WIDE_INT));
+ memset (reg_last_set_sign_bit_copies, 0, nregs * sizeof (char));
}
/* Set up any promoted values for incoming argument registers. */
--- cse.c.orig Thu Oct 26 04:56:38 2000
+++ cse.c Fri Nov 3 19:44:45 2000
@@ -993,7 +993,7 @@ new_basic_block ()
/* Clear out hash table state for this pass. */
- bzero ((char *) reg_hash, sizeof reg_hash);
+ memset ((char *) reg_hash, 0, sizeof reg_hash);
if (cse_reg_info_used_list)
{
--- dbxout.c.orig Tue Oct 10 06:33:40 2000
+++ dbxout.c Fri Nov 3 19:44:45 2000
@@ -1043,7 +1043,7 @@ dbxout_type (type, full, show_arg_types)
typevec
= (struct typeinfo *) xrealloc (typevec,
typevec_len * 2 * sizeof typevec[0]);
- bzero ((char *) (typevec + typevec_len),
+ memset ((char *) (typevec + typevec_len), 0,
typevec_len * sizeof typevec[0]);
typevec_len *= 2;
}
--- diagnostic.c.orig Sat Oct 21 18:03:22 2000
+++ diagnostic.c Fri Nov 3 19:44:45 2000
@@ -331,7 +331,7 @@ init_output_buffer (buffer, prefix, maxi
const char *prefix;
int maximum_length;
{
- bzero (buffer, sizeof (output_buffer));
+ memset (buffer, 0, sizeof (output_buffer));
obstack_init (&buffer->obstack);
ideal_line_wrap_cutoff (buffer) = maximum_length;
prefixing_policy (buffer) = current_prefixing_rule;
@@ -1692,7 +1692,7 @@ set_diagnostic_context (dc, message, arg
int line;
int warn;
{
- bzero (dc, sizeof (diagnostic_context));
+ memset (dc, 0, sizeof (diagnostic_context));
diagnostic_message (dc) = message;
diagnostic_argument_list (dc) = args_ptr;
diagnostic_file_location (dc) = file;
--- dwarf2out.c.orig Thu Nov 2 00:44:35 2000
+++ dwarf2out.c Fri Nov 3 19:44:45 2000
@@ -4849,7 +4849,7 @@ equate_decl_number_to_die (decl, decl_di
= (dw_die_ref *) xrealloc (decl_die_table,
sizeof (dw_die_ref) * num_allocated);
- bzero ((char *) &decl_die_table[decl_die_table_allocated],
+ memset ((char *) &decl_die_table[decl_die_table_allocated], 0,
(num_allocated - decl_die_table_allocated) * sizeof (dw_die_ref));
decl_die_table_allocated = num_allocated;
}
@@ -5481,7 +5481,7 @@ build_abbrev_table (die)
= (dw_die_ref *) xrealloc (abbrev_die_table,
sizeof (dw_die_ref) * n_alloc);
- bzero ((char *) &abbrev_die_table[abbrev_die_table_allocated],
+ memset ((char *) &abbrev_die_table[abbrev_die_table_allocated], 0,
(n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
abbrev_die_table_allocated = n_alloc;
}
--- emit-rtl.c.orig Wed Oct 18 06:44:02 2000
+++ emit-rtl.c Fri Nov 3 19:44:45 2000
@@ -4106,7 +4106,7 @@ init_emit_once (line_numbers)
rtx tem = rtx_alloc (CONST_DOUBLE);
union real_extract u;
- bzero ((char *) &u, sizeof u); /* Zero any holes in a structure. */
+ memset ((char *) &u, 0, sizeof u); /* Zero any holes in a structure. */
u.d = i == 0 ? dconst0 : i == 1 ? dconst1 : dconst2;
bcopy ((char *) &u, (char *) &CONST_DOUBLE_LOW (tem), sizeof u);
--- fold-const.c.orig Wed Nov 1 17:07:15 2000
+++ fold-const.c Fri Nov 3 19:44:45 2000
@@ -324,7 +324,7 @@ mul_double (l1, h1, l2, h2, lv, hv)
encode (arg1, l1, h1);
encode (arg2, l2, h2);
- bzero ((char *) prod, sizeof prod);
+ memset ((char *) prod, 0, sizeof prod);
for (i = 0; i < 4; i++)
{
@@ -576,10 +576,10 @@ div_and_round_double (code, uns,
goto finish_up;
}
- bzero ((char *) quo, sizeof quo);
+ memset ((char *) quo, 0, sizeof quo);
- bzero ((char *) num, sizeof num); /* to zero 9th element */
- bzero ((char *) den, sizeof den);
+ memset ((char *) num, 0, sizeof num); /* to zero 9th element */
+ memset ((char *) den, 0, sizeof den);
encode (num, lnum, hnum);
encode (den, lden, hden);
--- function.c.orig Fri Oct 20 19:43:27 2000
+++ function.c Fri Nov 3 19:44:45 2000
@@ -4787,7 +4787,7 @@ assign_parms (fndecl)
max_parm_reg = regno + 1;
new = (rtx *) xrealloc (parm_reg_stack_loc,
max_parm_reg * sizeof (rtx));
- bzero ((char *) (new + old_max_parm_reg),
+ memset ((char *) (new + old_max_parm_reg), 0,
(max_parm_reg - old_max_parm_reg) * sizeof (rtx));
parm_reg_stack_loc = new;
}
--- gcse.c.orig Wed Oct 25 00:00:47 2000
+++ gcse.c Fri Nov 3 19:44:45 2000
@@ -817,7 +817,7 @@ compute_can_copy ()
#ifndef AVOID_CCMODE_COPIES
rtx reg,insn;
#endif
- bzero (can_copy_p, NUM_MACHINE_MODES);
+ memset (can_copy_p, 0, NUM_MACHINE_MODES);
start_sequence ();
for (i = 0; i < NUM_MACHINE_MODES; i++)
@@ -890,7 +890,7 @@ alloc_gcse_mem (f)
max_uid = get_max_uid ();
n = (max_uid + 1) * sizeof (int);
uid_cuid = (int *) gmalloc (n);
- bzero ((char *) uid_cuid, n);
+ memset ((char *) uid_cuid, 0, n);
for (insn = f, i = 0; insn; insn = NEXT_INSN (insn))
{
if (INSN_P (insn))
@@ -904,7 +904,7 @@ alloc_gcse_mem (f)
max_cuid = i;
n = (max_cuid + 1) * sizeof (rtx);
cuid_insn = (rtx *) gmalloc (n);
- bzero ((char *) cuid_insn, n);
+ memset ((char *) cuid_insn, 0, n);
for (insn = f, i = 0; insn; insn = NEXT_INSN (insn))
if (INSN_P (insn))
CUID_INSN (i++) = insn;
@@ -1095,7 +1095,7 @@ alloc_reg_set_mem (n_regs)
reg_set_table_size = n_regs + REG_SET_TABLE_SLOP;
n = reg_set_table_size * sizeof (struct reg_set *);
reg_set_table = (struct reg_set **) gmalloc (n);
- bzero ((char *) reg_set_table, n);
+ memset ((char *) reg_set_table, 0, n);
gcc_obstack_init (®_set_obstack);
}
@@ -1125,7 +1125,7 @@ record_one_set (regno, insn)
reg_set_table
= (struct reg_set **) grealloc ((char *) reg_set_table,
new_size * sizeof (struct reg_set *));
- bzero ((char *) (reg_set_table + reg_set_table_size),
+ memset ((char *) (reg_set_table + reg_set_table_size), 0,
(new_size - reg_set_table_size) * sizeof (struct reg_set *));
reg_set_table_size = new_size;
}
@@ -2154,7 +2154,7 @@ compute_hash_table (set_p)
??? This isn't needed during const/copy propagation, but it's cheap to
compute. Later. */
sbitmap_vector_zero (reg_set_in_block, n_basic_blocks);
- bzero ((char *) mem_set_in_block, n_basic_blocks);
+ memset ((char *) mem_set_in_block, 0, n_basic_blocks);
/* Some working arrays used to track first and last set in each block. */
/* ??? One could use alloca here, but at some size a threshold is crossed
@@ -2282,7 +2282,7 @@ compute_set_hash_table ()
{
/* Initialize count of number of entries in hash table. */
n_sets = 0;
- bzero ((char *) set_hash_table,
+ memset ((char *) set_hash_table, 0,
set_hash_table_size * sizeof (struct expr *));
compute_hash_table (1);
@@ -2326,7 +2326,7 @@ compute_expr_hash_table ()
{
/* Initialize count of number of entries in hash table. */
n_exprs = 0;
- bzero ((char *) expr_hash_table,
+ memset ((char *) expr_hash_table, 0,
expr_hash_table_size * sizeof (struct expr *));
compute_hash_table (0);
--- genattrtab.c.orig Fri Oct 13 07:25:34 2000
+++ genattrtab.c Fri Nov 3 19:44:46 2000
@@ -3459,7 +3459,7 @@ optimize_attrs ()
insn_code_values
= (struct attr_value_list **) alloca ((insn_code_number + 2)
* sizeof (struct attr_value_list *));
- bzero ((char *) insn_code_values,
+ memset ((char *) insn_code_values, 0,
(insn_code_number + 2) * sizeof (struct attr_value_list *));
/* Offset the table address so we can index by -2 or -1. */
--- global.c.orig Thu Aug 24 21:37:44 2000
+++ global.c Fri Nov 3 19:44:46 2000
@@ -454,8 +454,8 @@ global_alloc (file)
/* Calculate amount of usage of each hard reg by pseudos
allocated by local-alloc. This is to see if we want to
override it. */
- bzero ((char *) local_reg_live_length, sizeof local_reg_live_length);
- bzero ((char *) local_reg_n_refs, sizeof local_reg_n_refs);
+ memset ((char *) local_reg_live_length, 0, sizeof local_reg_live_length);
+ memset ((char *) local_reg_n_refs, 0, sizeof local_reg_n_refs);
for (i = FIRST_PSEUDO_REGISTER; i < (size_t) max_regno; i++)
if (reg_renumber[i] >= 0)
{
@@ -637,7 +637,7 @@ global_conflicts ()
for (b = 0; b < n_basic_blocks; b++)
{
- bzero ((char *) allocnos_live, allocno_row_words * sizeof (INT_TYPE));
+ memset ((char *) allocnos_live, 0, allocno_row_words * sizeof (INT_TYPE));
/* Initialize table of registers currently live
to the state at the beginning of this basic block.
--- haifa-sched.c.orig Fri Oct 20 06:38:04 2000
+++ haifa-sched.c Fri Nov 3 19:44:46 2000
@@ -2054,7 +2054,7 @@ compute_trg_info (trg)
up with a lot of duplicates. We need to weed them out to avoid
overrunning the end of the bblst_table. */
update_blocks = (char *) alloca (n_basic_blocks);
- bzero (update_blocks, n_basic_blocks);
+ memset (update_blocks, 0, n_basic_blocks);
update_idx = 0;
for (j = 0; j < el.nr_members; j++)
@@ -2917,9 +2917,9 @@ static int unit_n_insns[FUNCTION_UNITS_S
static void
clear_units ()
{
- bzero ((char *) unit_last_insn, sizeof (unit_last_insn));
- bzero ((char *) unit_tick, sizeof (unit_tick));
- bzero ((char *) unit_n_insns, sizeof (unit_n_insns));
+ memset ((char *) unit_last_insn, 0, sizeof (unit_last_insn));
+ memset ((char *) unit_tick, 0, sizeof (unit_tick));
+ memset ((char *) unit_n_insns, 0, sizeof (unit_n_insns));
}
/* Return the issue-delay of an insn. */
@@ -6019,7 +6019,7 @@ schedule_block (bb, rgn_n_insns)
q_ptr = 0;
q_size = 0;
last_clock_var = 0;
- bzero ((char *) insn_queue, sizeof (insn_queue));
+ memset ((char *) insn_queue, 0, sizeof (insn_queue));
/* Start just before the beginning of time. */
clock_var = -1;
--- integrate.c.orig Sun Oct 29 10:45:46 2000
+++ integrate.c Fri Nov 3 19:44:46 2000
@@ -275,7 +275,7 @@ initialize_for_inline (fndecl)
tree parms;
/* Clear out PARMDECL_MAP. It was allocated in the caller's frame. */
- bzero ((char *) parmdecl_map, max_parm_reg * sizeof (tree));
+ memset ((char *) parmdecl_map, 0, max_parm_reg * sizeof (tree));
arg_vector = rtvec_alloc (list_length (DECL_ARGUMENTS (fndecl)));
for (parms = DECL_ARGUMENTS (fndecl), i = 0;
@@ -1094,7 +1094,7 @@ expand_inline_function (fndecl, parms, t
/* Initialize label_map. get_label_from_map will actually make
the labels. */
- bzero ((char *) &map->label_map[min_labelno],
+ memset ((char *) &map->label_map[min_labelno], 0,
(max_labelno - min_labelno) * sizeof (rtx));
/* Make copies of the decls of the symbols in the inline function, so that
--- jump.c.orig Fri Oct 6 11:55:12 2000
+++ jump.c Fri Nov 3 19:44:46 2000
@@ -3745,7 +3745,7 @@ thread_jumps (f, max_reg, flag_before_lo
|| ! any_condjump_p (b1) || JUMP_LABEL (b1) == 0)
continue;
- bzero (modified_regs, max_reg * sizeof (char));
+ memset (modified_regs, 0, max_reg * sizeof (char));
modified_mem = 0;
bcopy ((char *) all_reset, (char *) same_regs,
--- local-alloc.c.orig Mon Oct 23 21:55:56 2000
+++ local-alloc.c Fri Nov 3 19:44:46 2000
@@ -411,7 +411,7 @@ local_alloc ()
else
{
#define CLEAR(vector) \
- bzero ((char *) (vector), (sizeof (*(vector))) * next_qty);
+ memset ((char *) (vector), 0, (sizeof (*(vector))) * next_qty);
CLEAR (qty_phys_copy_sugg);
CLEAR (qty_phys_num_copy_sugg);
--- loop.c.orig Sat Oct 21 12:43:35 2000
+++ loop.c Fri Nov 3 19:44:46 2000
@@ -1344,7 +1344,7 @@ combine_movables (movables, regs)
register struct movable *m1;
int regno = m->regno;
- bzero (matched_regs, regs->num);
+ memset (matched_regs, 0, regs->num);
matched_regs[regno] = 1;
/* We want later insns to match the first one. Don't make the first
@@ -3367,7 +3367,7 @@ count_loop_regs_set (loop, may_not_move,
}
if (GET_CODE (insn) == CODE_LABEL || GET_CODE (insn) == JUMP_INSN)
- bzero ((char *) last_set, nregs * sizeof (rtx));
+ memset ((char *) last_set, 0, nregs * sizeof (rtx));
}
*count_ptr = count;
@@ -8664,9 +8664,9 @@ load_mems_and_recount_loop_regs_set (loo
VARRAY_GROW (regs->single_usage, nregs);
}
/* Clear the arrays */
- bzero ((char *) ®s->set_in_loop->data, nregs * sizeof (int));
- bzero ((char *) ®s->may_not_optimize->data, nregs * sizeof (char));
- bzero ((char *) ®s->single_usage->data, nregs * sizeof (rtx));
+ memset ((char *) ®s->set_in_loop->data, 0, nregs * sizeof (int));
+ memset ((char *) ®s->may_not_optimize->data, 0, nregs * sizeof (char));
+ memset ((char *) ®s->single_usage->data, 0, nregs * sizeof (rtx));
count_loop_regs_set (loop, regs->may_not_optimize, regs->single_usage,
insn_count, nregs);
--- print-tree.c.orig Fri Oct 13 07:25:35 2000
+++ print-tree.c Fri Nov 3 19:44:46 2000
@@ -47,7 +47,7 @@ debug_tree (node)
tree node;
{
table = (struct bucket **) permalloc (HASH_SIZE * sizeof (struct bucket *));
- bzero ((char *) table, HASH_SIZE * sizeof (struct bucket *));
+ memset ((char *) table, 0, HASH_SIZE * sizeof (struct bucket *));
print_node (stderr, "", node, 0);
table = 0;
fprintf (stderr, "\n");
--- regclass.c.orig Fri Sep 15 09:29:16 2000
+++ regclass.c Fri Nov 3 19:44:46 2000
@@ -269,7 +269,7 @@ init_reg_sets ()
bcopy (initial_fixed_regs, fixed_regs, sizeof fixed_regs);
bcopy (initial_call_used_regs, call_used_regs, sizeof call_used_regs);
- bzero (global_regs, sizeof global_regs);
+ memset (global_regs, 0, sizeof global_regs);
/* Do any additional initialization regsets may need */
INIT_ONCE_REG_SET ();
@@ -297,7 +297,7 @@ init_reg_sets_1 ()
/* Compute number of hard regs in each class. */
- bzero ((char *) reg_class_size, sizeof reg_class_size);
+ memset ((char *) reg_class_size, 0, sizeof reg_class_size);
for (i = 0; i < N_REG_CLASSES; i++)
for (j = 0; j < FIRST_PSEUDO_REGISTER; j++)
if (TEST_HARD_REG_BIT (reg_class_contents[i], j))
@@ -1122,10 +1122,10 @@ regclass (f, nregs, dump)
fprintf (dump, "\n\nPass %i\n\n",pass);
/* Zero out our accumulation of the cost of each class for each reg. */
- bzero ((char *) costs, nregs * sizeof (struct costs));
+ memset ((char *) costs, 0, nregs * sizeof (struct costs));
#ifdef FORBIDDEN_INC_DEC_CLASSES
- bzero (in_inc_dec, nregs);
+ memset (in_inc_dec, 0, nregs);
#endif
/* Scan the instructions and record each time it would
@@ -1337,7 +1337,7 @@ record_reg_classes (n_alts, n_ops, ops,
if (*p == 0)
{
if (GET_CODE (op) == REG && REGNO (op) >= FIRST_PSEUDO_REGISTER)
- bzero ((char *) &this_op_costs[i], sizeof this_op_costs[i]);
+ memset ((char *) &this_op_costs[i], 0, sizeof this_op_costs[i]);
continue;
}
@@ -2122,7 +2122,7 @@ allocate_reg_info (num_regs, new_p, renu
if (!reg_data->used_p) /* page just allocated with calloc */
reg_data->used_p = 1; /* no need to zero */
else
- bzero ((char *) ®_data->data[local_min],
+ memset ((char *) ®_data->data[local_min], 0,
sizeof (reg_info) * (max - min_index - local_min + 1));
for (i = min_index+local_min; i <= max; i++)
--- reload.c.orig Thu Nov 2 22:26:31 2000
+++ reload.c Fri Nov 3 19:44:46 2000
@@ -647,7 +647,7 @@ get_secondary_mem (x, mode, opnum, type)
void
clear_secondary_mem ()
{
- bzero ((char *) secondary_memlocs, sizeof secondary_memlocs);
+ memset ((char *) secondary_memlocs, 0, sizeof secondary_memlocs);
}
#endif /* SECONDARY_MEMORY_NEEDED */
@@ -1558,7 +1558,7 @@ remove_address_replacements (in_rtx)
char reload_flags[MAX_RELOADS];
int something_changed = 0;
- bzero (reload_flags, sizeof reload_flags);
+ memset (reload_flags, 0, sizeof reload_flags);
for (i = 0, j = 0; i < n_replacements; i++)
{
if (loc_mentioned_in_p (replacements[i].where, in_rtx))
@@ -2451,7 +2451,7 @@ find_reloads (insn, replace, ind_levels,
/* The eliminated forms of any secondary memory locations are per-insn, so
clear them out here. */
- bzero ((char *) secondary_memlocs_elim, sizeof secondary_memlocs_elim);
+ memset ((char *) secondary_memlocs_elim, 0, sizeof secondary_memlocs_elim);
#endif
/* Dispose quickly of (set (reg..) (reg..)) if both have hard regs and it
--- reload1.c.orig Sat Oct 28 20:38:58 2000
+++ reload1.c Fri Nov 3 19:44:46 2000
@@ -631,8 +631,8 @@ reload (first, global)
#endif
/* We don't have a stack slot for any spill reg yet. */
- bzero ((char *) spill_stack_slot, sizeof spill_stack_slot);
- bzero ((char *) spill_stack_slot_width, sizeof spill_stack_slot_width);
+ memset ((char *) spill_stack_slot, 0, sizeof spill_stack_slot);
+ memset ((char *) spill_stack_slot_width, 0, sizeof spill_stack_slot_width);
/* Initialize the save area information for caller-save, in case some
are needed. */
@@ -3270,7 +3270,7 @@ static void
set_initial_label_offsets ()
{
rtx x;
- bzero ((char *) &offsets_known_at[get_first_label_num ()], num_labels);
+ memset ((char *) &offsets_known_at[get_first_label_num ()], 0, num_labels);
for (x = forced_labels; x; x = XEXP (x, 1))
if (XEXP (x, 0))
@@ -3544,7 +3544,7 @@ finish_spills (global)
/* Retry global register allocation if possible. */
if (global)
{
- bzero ((char *) pseudo_forbidden_regs, max_regno * sizeof (HARD_REG_SET));
+ memset ((char *) pseudo_forbidden_regs, 0, max_regno * sizeof (HARD_REG_SET));
/* For every insn that needs reloads, set the registers used as spill
regs in pseudo_forbidden_regs for every pseudo live across the
insn. */
@@ -3715,8 +3715,8 @@ reload_as_needed (live_known)
#endif
rtx x;
- bzero ((char *) spill_reg_rtx, sizeof spill_reg_rtx);
- bzero ((char *) spill_reg_store, sizeof spill_reg_store);
+ memset ((char *) spill_reg_rtx, 0, sizeof spill_reg_rtx);
+ memset ((char *) spill_reg_store, 0, sizeof spill_reg_store);
reg_last_reload_reg = (rtx *) xcalloc (max_regno, sizeof (rtx));
reg_has_output_reload = (char *) xmalloc (max_regno);
CLEAR_HARD_REG_SET (reg_reloaded_valid);
@@ -3777,7 +3777,7 @@ reload_as_needed (live_known)
rtx's for those pseudo regs. */
else
{
- bzero (reg_has_output_reload, max_regno);
+ memset (reg_has_output_reload, 0, max_regno);
CLEAR_HARD_REG_SET (reg_is_output_reload);
find_reloads (insn, 1, spill_indirect_levels, live_known,
@@ -5087,9 +5087,9 @@ choose_reload_regs_init (chain, save_rel
for (i = 0; i < n_reloads; i++)
rld[i].reg_rtx = save_reload_reg_rtx[i];
- bzero (reload_inherited, MAX_RELOADS);
- bzero ((char *) reload_inheritance_insn, MAX_RELOADS * sizeof (rtx));
- bzero ((char *) reload_override_in, MAX_RELOADS * sizeof (rtx));
+ memset (reload_inherited, 0, MAX_RELOADS);
+ memset ((char *) reload_inheritance_insn, 0, MAX_RELOADS * sizeof (rtx));
+ memset ((char *) reload_override_in, 0, MAX_RELOADS * sizeof (rtx));
CLEAR_HARD_REG_SET (reload_reg_used);
CLEAR_HARD_REG_SET (reload_reg_used_at_all);
@@ -8115,8 +8115,8 @@ reload_cse_simplify_operands (insn)
alternative_reject = (int *) alloca (recog_data.n_alternatives * sizeof (int));
alternative_nregs = (int *) alloca (recog_data.n_alternatives * sizeof (int));
alternative_order = (int *) alloca (recog_data.n_alternatives * sizeof (int));
- bzero ((char *)alternative_reject, recog_data.n_alternatives * sizeof (int));
- bzero ((char *)alternative_nregs, recog_data.n_alternatives * sizeof (int));
+ memset ((char *)alternative_reject, 0, recog_data.n_alternatives * sizeof (int));
+ memset ((char *)alternative_nregs, 0, recog_data.n_alternatives * sizeof (int));
/* For each operand, find out which regs are equivalent. */
for (i = 0; i < recog_data.n_operands; i++)
--- reorg.c.orig Wed Oct 18 06:44:03 2000
+++ reorg.c Fri Nov 3 19:44:46 2000
@@ -3589,8 +3589,8 @@ dbr_schedule (first, file)
end_of_function_label = 0;
/* Initialize the statistics for this function. */
- bzero ((char *) num_insns_needing_delays, sizeof num_insns_needing_delays);
- bzero ((char *) num_filled_delays, sizeof num_filled_delays);
+ memset ((char *) num_insns_needing_delays, 0, sizeof num_insns_needing_delays);
+ memset ((char *) num_filled_delays, 0, sizeof num_filled_delays);
/* Now do the delay slot filling. Try everything twice in case earlier
changes make more slots fillable. */
@@ -3667,8 +3667,8 @@ dbr_schedule (first, file)
fprintf (file, "\n");
}
}
- bzero ((char *) total_delay_slots, sizeof total_delay_slots);
- bzero ((char *) total_annul_slots, sizeof total_annul_slots);
+ memset ((char *) total_delay_slots, 0, sizeof total_delay_slots);
+ memset ((char *) total_annul_slots, 0, sizeof total_annul_slots);
for (insn = first; insn; insn = NEXT_INSN (insn))
{
if (! INSN_DELETED_P (insn)
--- sbitmap.c.orig Fri May 19 22:27:27 2000
+++ sbitmap.c Fri Nov 3 19:44:46 2000
@@ -106,7 +106,7 @@ void
sbitmap_zero (bmap)
sbitmap bmap;
{
- bzero ((PTR) bmap->elms, bmap->bytes);
+ memset ((PTR) bmap->elms, 0, bmap->bytes);
}
/* Set all elements in a bitmap to ones. */
--- simplify-rtx.c.orig Thu Oct 26 04:56:39 2000
+++ simplify-rtx.c Fri Nov 3 19:44:46 2000
@@ -1510,7 +1510,7 @@ simplify_plus_minus (code, mode, op0, op
int first = 1, negate = 0, changed;
int i, j;
- bzero ((char *) ops, sizeof ops);
+ memset ((char *) ops, 0, sizeof ops);
/* Set up the two operands and then expand them until nothing has been
changed. If we run out of room in our array, give up; this should
--- ssa.c.orig Sat Oct 21 00:53:17 2000
+++ ssa.c Fri Nov 3 19:44:46 2000
@@ -1127,8 +1127,8 @@ rename_registers (nregs, idom)
ssa_rename_from_initialize ();
ssa_rename_to_pseudo = (rtx *) alloca (nregs * sizeof(rtx));
- bzero ((char *) ssa_rename_to_pseudo, nregs * sizeof(rtx));
- bzero ((char *) ssa_rename_to_hard,
+ memset ((char *) ssa_rename_to_pseudo, 0, nregs * sizeof(rtx));
+ memset ((char *) ssa_rename_to_hard, 0,
FIRST_PSEUDO_REGISTER * NUM_MACHINE_MODES * sizeof (rtx));
rename_block (0, idom);
--- stmt.c.orig Wed Nov 1 21:39:06 2000
+++ stmt.c Fri Nov 3 19:44:46 2000
@@ -5612,7 +5612,7 @@ expand_end_case (orig_index)
ncases = TREE_INT_CST_LOW (range) + 1;
labelvec = (rtx *) alloca (ncases * sizeof (rtx));
- bzero ((char *) labelvec, ncases * sizeof (rtx));
+ memset ((char *) labelvec, 0, ncases * sizeof (rtx));
for (n = thiscase->data.case_stmt.case_list; n; n = n->right)
{
--- unroll.c.orig Tue Sep 19 16:08:58 2000
+++ unroll.c Fri Nov 3 19:43:32 2000
@@ -1072,10 +1072,10 @@ unroll_loop (loop, insn_count, end_inser
emit_label_after (labels[unroll_number - i],
PREV_INSN (loop_start));
- bzero ((char *) map->insn_map, max_insnno * sizeof (rtx));
- bzero ((char *) &VARRAY_CONST_EQUIV (map->const_equiv_varray, 0),
- (VARRAY_SIZE (map->const_equiv_varray)
- * sizeof (struct const_equiv_data)));
+ memset ((char *) map->insn_map, 0, max_insnno * sizeof (rtx));
+ memset ((char *) &VARRAY_CONST_EQUIV (map->const_equiv_varray, 0),
+ 0, (VARRAY_SIZE (map->const_equiv_varray)
+ * sizeof (struct const_equiv_data)));
map->const_age = 0;
for (j = 0; j < max_labelno; j++)
@@ -1219,9 +1219,9 @@ unroll_loop (loop, insn_count, end_inser
for (i = 0; i < unroll_number; i++)
{
- bzero ((char *) map->insn_map, max_insnno * sizeof (rtx));
- bzero ((char *) &VARRAY_CONST_EQUIV (map->const_equiv_varray, 0),
- VARRAY_SIZE (map->const_equiv_varray) * sizeof (struct const_equiv_data));
+ memset ((char *) map->insn_map, 0, max_insnno * sizeof (rtx));
+ memset ((char *) &VARRAY_CONST_EQUIV (map->const_equiv_varray, 0), 0,
+ VARRAY_SIZE (map->const_equiv_varray) * sizeof (struct const_equiv_data));
map->const_age = 0;
for (j = 0; j < max_labelno; j++)
--- varray.c.orig Mon Jan 17 17:16:19 2000
+++ varray.c Fri Nov 3 19:44:46 2000
@@ -64,7 +64,7 @@ varray_grow (va, n)
va = (varray_type) xrealloc ((char *)va, VARRAY_HDR_SIZE + data_size);
va->num_elements = n;
if (n > old_elements)
- bzero (&va->data.c[old_data_size], data_size - old_data_size);
+ memset (&va->data.c[old_data_size], 0, data_size - old_data_size);
}
return va;
--- ch/actions.c.orig Sat Mar 25 18:34:06 2000
+++ ch/actions.c Fri Nov 3 19:54:09 2000
@@ -1464,7 +1464,7 @@ check_missing_cases (type)
warning ("too many cases to do CASE completeness testing");
else
{
- bzero (cases_seen, bytes_needed);
+ memset (cases_seen, 0, bytes_needed);
mark_seen_cases (type, cases_seen, size, is_sparse);
print_missing_cases (type, cases_seen, size);
free (cases_seen);
--- ch/typeck.c.orig Wed Jun 14 05:30:03 2000
+++ ch/typeck.c Fri Nov 3 19:54:09 2000
@@ -253,7 +253,7 @@ build_chill_slice (array, min_value, len
* (tree_low_cst (min_value, 0)
- tree_low_cst (domain_min, 0)));
- bzero (buffer, type_size);
+ memset (buffer, 0, type_size);
if (expand_constant_to_buffer (array, buffer, type_size))
{
result = extract_constant_from_buffer (slice_type,
@@ -1193,7 +1193,7 @@ build_chill_cast (type, expr)
{
unsigned char *buffer = (unsigned char*) alloca (type_size);
tree value;
- bzero (buffer, type_size);
+ memset (buffer, 0, type_size);
if (!expand_constant_to_buffer (expr, buffer, type_size))
{
error ("not implemented: constant conversion from that kind of expression");
--- cp/class.c.orig Tue Oct 31 11:33:46 2000
+++ cp/class.c Fri Nov 3 19:54:09 2000
@@ -2351,7 +2351,7 @@ duplicate_tag_error (t)
tree template_info = CLASSTYPE_TEMPLATE_INFO (t);
int use_template = CLASSTYPE_USE_TEMPLATE (t);
- bzero ((char *) TYPE_LANG_SPECIFIC (t), sizeof (struct lang_type));
+ memset ((char *) TYPE_LANG_SPECIFIC (t), 0, sizeof (struct lang_type));
BINFO_BASETYPES(binfo) = NULL_TREE;
TYPE_BINFO (t) = binfo;
@@ -7231,7 +7231,7 @@ build_vtbl_initializer (binfo, orig_binf
vtbl_init_data vid;
/* Initialize VID. */
- bzero (&vid, sizeof (vid));
+ memset (&vid, 0, sizeof (vid));
vid.binfo = binfo;
vid.derived = t;
vid.last_init = &vid.inits;
--- cp/decl.c.orig Sun Oct 22 10:34:18 2000
+++ cp/decl.c Fri Nov 3 19:54:09 2000
@@ -565,7 +565,7 @@ push_binding_level (newlevel, tag_transp
{
/* Add this level to the front of the chain (stack) of levels that
are active. */
- bzero ((char*) newlevel, sizeof (struct binding_level));
+ memset ((char*) newlevel, 0, sizeof (struct binding_level));
newlevel->level_chain = current_binding_level;
current_binding_level = newlevel;
newlevel->tag_transparent = tag_transparent;
--- cp/error.c.orig Wed Nov 1 11:40:46 2000
+++ cp/error.c Fri Nov 3 19:54:09 2000
@@ -2650,7 +2650,7 @@ cp_tree_printer (buffer)
int be_verbose = 0;
tree_formatting_info tfi;
- bzero (&tfi, sizeof (tree_formatting_info));
+ memset (&tfi, 0, sizeof (tree_formatting_info));
if (*output_buffer_text_cursor (buffer) == '+')
++output_buffer_text_cursor (buffer);
--- cp/pt.c.orig Tue Oct 31 11:33:53 2000
+++ cp/pt.c Fri Nov 3 19:54:10 2000
@@ -2108,10 +2108,10 @@ process_partial_specialization (decl)
or some such would have been OK. */
tpd.level = TMPL_PARMS_DEPTH (current_template_parms);
tpd.parms = alloca (sizeof (int) * ntparms);
- bzero ((PTR) tpd.parms, sizeof (int) * ntparms);
+ memset ((PTR) tpd.parms, 0, sizeof (int) * ntparms);
tpd.arg_uses_template_parms = alloca (sizeof (int) * nargs);
- bzero ((PTR) tpd.arg_uses_template_parms, sizeof (int) * nargs);
+ memset ((PTR) tpd.arg_uses_template_parms, 0, sizeof (int) * nargs);
for (i = 0; i < nargs; ++i)
{
tpd.current_arg = i;
@@ -2195,7 +2195,7 @@ process_partial_specialization (decl)
template, not in the specialization. */
tpd2.current_arg = i;
tpd2.arg_uses_template_parms[i] = 0;
- bzero ((PTR) tpd2.parms, sizeof (int) * nargs);
+ memset ((PTR) tpd2.parms, 0, sizeof (int) * nargs);
for_each_template_parm (type,
&mark_template_parm,
&tpd2);
@@ -5195,7 +5195,7 @@ tsubst_template_arg_vector (t, args, com
int len = TREE_VEC_LENGTH (t), need_new = 0, i;
tree *elts = (tree *) alloca (len * sizeof (tree));
- bzero ((char *) elts, len * sizeof (tree));
+ memset ((char *) elts, 0, len * sizeof (tree));
for (i = 0; i < len; i++)
{
--- cp/search.c.orig Fri Oct 13 07:25:43 2000
+++ cp/search.c Fri Nov 3 19:54:10 2000
@@ -1538,7 +1538,7 @@ lookup_member (xbasetype, name, protect,
n_calls_lookup_field++;
#endif /* GATHER_STATISTICS */
- bzero ((PTR) &lfi, sizeof (lfi));
+ memset ((PTR) &lfi, 0, sizeof (lfi));
lfi.type = type;
lfi.name = name;
lfi.want_type = want_type;
--- java/expr.c.orig Fri Oct 13 22:47:54 2000
+++ java/expr.c Fri Nov 3 19:54:10 2000
@@ -2507,7 +2507,7 @@ note_instructions (jcf, method)
JCF_SEEK (jcf, DECL_CODE_OFFSET (method));
byte_ops = jcf->read_ptr;
instruction_bits = xrealloc (instruction_bits, length + 1);
- bzero (instruction_bits, length + 1);
+ memset (instruction_bits, 0, length + 1);
/* This pass figures out which PC can be the targets of jumps. */
for (PC = 0; PC < length;)
--- java/jcf-io.c.orig Wed Sep 6 17:40:19 2000
+++ java/jcf-io.c Fri Nov 3 19:54:10 2000
@@ -319,7 +319,7 @@ DEFUN(find_class, (classname, classname_
null pointer when we're copying it below. */
int buflen = jcf_path_max_len () + classname_length + 10;
char *buffer = (char *) ALLOC (buflen);
- bzero (buffer, buflen);
+ memset (buffer, 0, buflen);
java_buffer = (char *) alloca (buflen);
--- java/jcf-parse.c.orig Thu Oct 19 06:58:28 2000
+++ java/jcf-parse.c Fri Nov 3 19:54:10 2000
@@ -648,7 +648,7 @@ init_outgoing_cpool ()
{
current_constant_pool_data_ref = NULL_TREE;
outgoing_cpool = (struct CPool *)xmalloc (sizeof (struct CPool));
- bzero (outgoing_cpool, sizeof (struct CPool));
+ memset (outgoing_cpool, 0, sizeof (struct CPool));
}
static void
--- java/lex.c.orig Thu Oct 26 04:56:39 2000
+++ java/lex.c Fri Nov 3 19:54:10 2000
@@ -112,8 +112,8 @@ java_init_lex (finput, encoding)
CPC_INITIALIZER_LIST (ctxp) = CPC_STATIC_INITIALIZER_LIST (ctxp) =
CPC_INSTANCE_INITIALIZER_LIST (ctxp) = ctxp->incomplete_class = NULL_TREE;
- bzero ((PTR) ctxp->modifier_ctx, 11*sizeof (ctxp->modifier_ctx[0]));
- bzero ((PTR) current_jcf, sizeof (JCF));
+ memset ((PTR) ctxp->modifier_ctx, 0, 11*sizeof (ctxp->modifier_ctx[0]));
+ memset ((PTR) current_jcf, 0, sizeof (JCF));
ctxp->current_parsed_class = NULL;
ctxp->package = NULL_TREE;
#endif
--- objc/objc-act.c.orig Sun Sep 17 15:40:17 2000
+++ objc/objc-act.c Fri Nov 3 19:54:10 2000
@@ -3627,7 +3627,7 @@ error_with_ivar (message, decl, rawdecl)
fprintf (stderr, "%s:%d: ",
DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
- bzero (errbuf, BUFSIZE);
+ memset (errbuf, 0, BUFSIZE);
fprintf (stderr, "%s `%s'\n", message, gen_declaration (rawdecl, errbuf));
}
@@ -4740,7 +4740,7 @@ build_keyword_selector (selector)
}
buf = (char *)alloca (len + 1);
- bzero (buf, len + 1);
+ memset (buf, 0, len + 1);
for (key_chain = selector; key_chain; key_chain = TREE_CHAIN (key_chain))
{
@@ -4979,7 +4979,7 @@ build_message_expr (mess)
/* Allow any type that matches objc_class_type. */
&& ! comptypes (rtype, objc_class_type))
{
- bzero (errbuf, BUFSIZE);
+ memset (errbuf, 0, BUFSIZE);
warning ("invalid receiver type `%s'",
gen_declaration (rtype, errbuf));
}
@@ -7079,7 +7079,7 @@ warn_with_method (message, mtype, method
fprintf (stderr, "%s:%d: warning: ",
DECL_SOURCE_FILE (method), DECL_SOURCE_LINE (method));
- bzero (errbuf, BUFSIZE);
+ memset (errbuf, 0, BUFSIZE);
fprintf (stderr, "%s `%c%s'\n",
message, mtype, gen_method_decl (method, errbuf));
}
@@ -8088,7 +8088,7 @@ dump_interface (fp, chain)
fprintf (fp, "{\n");
do
{
- bzero (buf, 256);
+ memset (buf, 0, 256);
fprintf (fp, "\t%s;\n", gen_declaration (ivar_decls, buf));
ivar_decls = TREE_CHAIN (ivar_decls);
}
@@ -8098,14 +8098,14 @@ dump_interface (fp, chain)
while (nst_methods)
{
- bzero (buf, 256);
+ memset (buf, 0, 256);
fprintf (fp, "- %s;\n", gen_method_decl (nst_methods, buf));
nst_methods = TREE_CHAIN (nst_methods);
}
while (cls_methods)
{
- bzero (buf, 256);
+ memset (buf, 0, 256);
fprintf (fp, "+ %s;\n", gen_method_decl (cls_methods, buf));
cls_methods = TREE_CHAIN (cls_methods);
}
@@ -8501,7 +8501,7 @@ objc_debug (fp)
if (TREE_CODE (loop) == FUNCTION_DECL && DECL_INITIAL (loop))
{
/* We have a function definition: generate prototype. */
- bzero (errbuf, BUFSIZE);
+ memset (errbuf, 0, BUFSIZE);
gen_declaration (loop, errbuf);
fprintf (fp, "%s;\n", errbuf);
}
@@ -8521,7 +8521,7 @@ objc_debug (fp)
fprintf (fp, "\n\nnst_method_hash_list[%d]:\n", i);
do
{
- bzero (buf, 256);
+ memset (buf, 0, 256);
fprintf (fp, "-%s;\n", gen_method_decl (hashlist->key, buf));
hashlist = hashlist->next;
}
@@ -8536,7 +8536,7 @@ objc_debug (fp)
fprintf (fp, "\n\ncls_method_hash_list[%d]:\n", i);
do
{
- bzero (buf, 256);
+ memset (buf, 0, 256);
fprintf (fp, "-%s;\n", gen_method_decl (hashlist->key, buf));
hashlist = hashlist->next;
}
--
Joseph S. Myers
jsm28@cam.ac.uk