This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[gcc-in-cxx] Revert unnecessary changes


With all the work on mainline, a bunch of changes on the gcc-in-cxx
branch are now unnecessary.  There are mostly residues of things which
were fixed differently on mainline, and which I did not eliminate in the
merge.  I committed this patch to the gcc-in-cxx branch to eliminate
these unnecessary changes.  This helps clarify which changes on the
branch are really required.  Tested by bootstrapping the gcc-in-cxx
branch on i686-pc-linux-gnu.

Ian


gcc/ChangeLog.cxx:

2009-05-20  Ian Lance Taylor  <iant@google.com>

	Revert the following patches:
	2009-02-06  Ian Lance Taylor  <iant@google.com>
	* timevar.c (timevar_pop_1): Ignore TV_NONE.
	2009-01-31  Ian Lance Taylor  <iant@google.com>
	* targhooks.h (default_branch_target_register_class): Declare.
	2008-09-17  Tom Tromey  <tromey@redhat.com>
	* timevar.c (timevar_print): Ignore TV_NONE.
	(timevar_push_1): Likewise.
	2008-09-10  Ian Lance Taylor  <iant@google.com>
	* df.h (enum df_ref_flags): Define DF_REF_NONE.
	* df-problems.c (df_rd_bb_local_compute): Change 0 to enum
	constant.
	(df_chain_create_bb): Likewise.
	(df_chain_add_problem): Change flags to unsigned int.
	* gimple.h (gimplify_expr: Update declaration.
	* gimplify.c (gimplify_compound_lval): Change fallback to int.
	(gimplify_cond_expr, gimplify_expr): Likewise.
	* ira-costs.c (record_reg_classes): Add cast to enum type.
	* predict.c (combine_predictions_for_insn): Add cast to enum
	type.
	(combine_predictions_for_bb): Likewise.
	* postreload.c (reload_cse_simplify_operands): Add cast to enum
	type.
	* reload.c (find_reloads): Add cast to enum type.
	* rtl.h (alloc_reg_note): Declare.
	* cp/parser.c (cp_parser_omp_var_list_no_open): Change integer
	constant to enum constant.
	* cp/pt.c (process_template_parm): Change integer constant to enum
	constant.
	* fortran/module.c (import_iso_c_binding_module): Use new
	iso_c_binding_symbol local.  Add cast to enum type.
	* objcp/objcp-lang.c (objcp_tsubst_copy_and_build): Change
	complain to int.
	2008-07-03  Tom Tromey  <tromey@redhat.com>
	* stringpool.c (alloc_node): Update.

	* gimple.c (gimple_range_check_failed): Remove.
	* tree-ssa-alias.c: Add trailing blank line.
	* tree-ssa-dse.c: Remove trailing blank line.

libcpp/ChangeLog.cxx:

2009-05-20  Ian Lance Taylor  <iant@google.com>

	Revert the following patches:
	2008-07-03  Tom Tromey  <tromey@redhat.com>
	* include/symtab.h (cpp_hash_table): Rename from hash_table.
	* symtab.c, init.c, identifiers.c, internal.h: Update all users.


Index: gcc/targhooks.h
===================================================================
--- gcc/targhooks.h	(revision 147619)
+++ gcc/targhooks.h	(working copy)
@@ -89,7 +89,6 @@ extern int hook_int_CUMULATIVE_ARGS_mode
   (CUMULATIVE_ARGS *, enum machine_mode, tree, bool);
 extern const char *hook_invalid_arg_for_unprototyped_fn
   (const_tree, const_tree, const_tree);
-extern enum reg_class default_branch_target_register_class (void);
 extern bool hook_bool_const_rtx_commutative_p (const_rtx, int);
 extern rtx default_function_value (const_tree, const_tree, bool);
 extern rtx default_internal_arg_pointer (void);
Index: gcc/postreload.c
===================================================================
--- gcc/postreload.c	(revision 147619)
+++ gcc/postreload.c	(working copy)
@@ -569,8 +569,7 @@ reload_cse_simplify_operands (rtx insn, 
 		     alternative yet and the operand being replaced is not
 		     a cheap CONST_INT.  */
 		  if (op_alt_regno[i][j] == -1
-		      && reg_fits_class_p (testreg, (enum reg_class) rclass,
-					   0, mode)
+		      && reg_fits_class_p (testreg, rclass, 0, mode)
 		      && (GET_CODE (recog_data.operand[i]) != CONST_INT
 			  || (rtx_cost (recog_data.operand[i], SET,
 			  		optimize_bb_for_speed_p (BLOCK_FOR_INSN (insn)))
Index: gcc/reload.c
===================================================================
--- gcc/reload.c	(revision 147619)
+++ gcc/reload.c	(working copy)
@@ -3191,8 +3191,7 @@ find_reloads (rtx insn, int replace, int
 					   recog_data.operand_loc[loc1],
 					   recog_data.operand_loc[loc2],
 					   operand_mode[i], operand_mode[m],
-					   (enum reg_class) this_alternative[m],
-					   -1,
+					   this_alternative[m], -1,
 					   this_alternative_earlyclobber[m]);
 
 		    if (value != 0)
@@ -3445,8 +3444,7 @@ find_reloads (rtx insn, int replace, int
 		  break;
 		winreg = 1;
 		if (REG_P (operand)
-		    && reg_fits_class_p (operand,
-					 (enum reg_class) this_alternative[i],
+		    && reg_fits_class_p (operand, this_alternative[i],
 					 offset, GET_MODE (recog_data.operand[i])))
 		  win = 1;
 		break;
@@ -3578,7 +3576,7 @@ find_reloads (rtx insn, int replace, int
 	      && reg_class_size [(int) preferred_class[i]] > 0
 	      && ! SMALL_REGISTER_CLASS_P (preferred_class[i]))
 	    {
-	      if (! reg_class_subset_p ((enum reg_class) this_alternative[i],
+	      if (! reg_class_subset_p (this_alternative[i],
 					preferred_class[i]))
 		{
 		  /* Since we don't have a way of forming the intersection,
@@ -3586,7 +3584,7 @@ find_reloads (rtx insn, int replace, int
 		     is a subset of the class we have; that's the most
 		     common case anyway.  */
 		  if (reg_class_subset_p (preferred_class[i],
-					  (enum reg_class) this_alternative[i]))
+					  this_alternative[i]))
 		    this_alternative[i] = preferred_class[i];
 		  else
 		    reject += (2 + 2 * pref_or_nothing[i]);
Index: gcc/tree-ssa-dse.c
===================================================================
--- gcc/tree-ssa-dse.c	(revision 147619)
+++ gcc/tree-ssa-dse.c	(working copy)
@@ -469,3 +469,4 @@ struct gimple_opt_pass pass_dse = 
     | TODO_verify_ssa		/* todo_flags_finish */
  }
 };
+
Index: gcc/objcp/objcp-lang.c
===================================================================
--- gcc/objcp/objcp-lang.c	(revision 147619)
+++ gcc/objcp/objcp-lang.c	(working copy)
@@ -58,7 +58,7 @@ const struct lang_hooks lang_hooks = LAN
    there should be very few (if any) routines below.  */
 
 tree
-objcp_tsubst_copy_and_build (tree t, tree args, int complain, 
+objcp_tsubst_copy_and_build (tree t, tree args, tsubst_flags_t complain, 
 			     tree in_decl, bool function_p ATTRIBUTE_UNUSED)
 {
 #define RECURSE(NODE)							\
Index: gcc/cp/pt.c
===================================================================
--- gcc/cp/pt.c	(revision 147619)
+++ gcc/cp/pt.c	(working copy)
@@ -3008,7 +3008,7 @@ process_template_parm (tree list, tree p
 	   The top-level cv-qualifiers on the template-parameter are
 	   ignored when determining its type.  */
 	TREE_TYPE (parm) = TYPE_MAIN_VARIANT (TREE_TYPE (parm));
-	if (invalid_nontype_parm_type_p (TREE_TYPE (parm), tf_error))
+	if (invalid_nontype_parm_type_p (TREE_TYPE (parm), 1))
           {
             err_parm_list = build_tree_list (defval, parm);
             TREE_VALUE (err_parm_list) = error_mark_node;
Index: gcc/cp/parser.c
===================================================================
--- gcc/cp/parser.c	(revision 147619)
+++ gcc/cp/parser.c	(working copy)
@@ -20361,7 +20361,7 @@ cp_parser_omp_var_list_no_open (cp_parse
       decl = cp_parser_lookup_name_simple (parser, name, token->location);
       if (decl == error_mark_node)
 	cp_parser_name_lookup_error (parser, name, decl, NULL, token->location);
-      else if (kind != OMP_CLAUSE_ERROR)
+      else if (kind != 0)
 	{
 	  tree u = build_omp_clause (kind);
 	  OMP_CLAUSE_DECL (u) = decl;
Index: gcc/tree-ssa-alias.c
===================================================================
--- gcc/tree-ssa-alias.c	(revision 147619)
+++ gcc/tree-ssa-alias.c	(working copy)
@@ -1157,3 +1157,4 @@ walk_aliased_vdefs (tree ref, tree vdef,
 
   return ret;
 }
+
Index: gcc/predict.c
===================================================================
--- gcc/predict.c	(revision 147619)
+++ gcc/predict.c	(working copy)
@@ -728,8 +728,7 @@ combine_predictions_for_insn (rtx insn, 
 					 INTVAL (XEXP (XEXP (*pnote, 0), 0)));
 	  int probability = INTVAL (XEXP (XEXP (*pnote, 0), 1));
 
-	  dump_prediction (dump_file, (enum br_predictor) predictor,
-			   probability, bb,
+	  dump_prediction (dump_file, predictor, probability, bb,
 			   !first_match || best_predictor == predictor);
 	  *pnote = XEXP (*pnote, 1);
 	}
@@ -896,8 +895,7 @@ combine_predictions_for_bb (basic_block 
 
 	  if (pred->ep_edge != EDGE_SUCC (bb, 0))
 	    probability = REG_BR_PROB_BASE - probability;
-	  dump_prediction (dump_file, (enum br_predictor) predictor,
-			   probability, bb,
+	  dump_prediction (dump_file, predictor, probability, bb,
 			   !first_match || best_predictor == predictor);
 	}
     }
Index: gcc/timevar.c
===================================================================
--- gcc/timevar.c	(revision 147619)
+++ gcc/timevar.c	(working copy)
@@ -1,5 +1,5 @@
 /* Timing variables for measuring compiler performance.
-   Copyright (C) 2000, 2003, 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
+   Copyright (C) 2000, 2003, 2004, 2005, 2007 Free Software Foundation, Inc.
    Contributed by Alex Samuel <samuel@codesourcery.com>
 
 This file is part of GCC.
@@ -266,10 +266,6 @@ timevar_push_1 (timevar_id_t timevar)
   struct timevar_stack_def *context;
   struct timevar_time_def now;
 
-  /* Completely ignore TV_NONE.  */
-  if (timevar == TV_NONE)
-    return;
-
   /* Mark this timing variable as used.  */
   tv->used = 1;
 
@@ -316,10 +312,6 @@ timevar_pop_1 (timevar_id_t timevar)
   struct timevar_time_def now;
   struct timevar_stack_def *popped = stack;
 
-  /* Completely ignore TV_NONE.  */
-  if (timevar == TV_NONE)
-    return;
-
   gcc_assert (&timevars[timevar] == stack->timevar);
   
   /* What time is it?  */
@@ -426,9 +418,6 @@ timevar_print (FILE *fp)
 	 end.  */
       if ((timevar_id_t) id == TV_TOTAL)
 	continue;
-      /* Always ignore TV_NONE.  */
-      if ((timevar_id_t) id == TV_NONE)
-	continue;
 
       /* Don't print timing variables that were never used.  */
       if (!tv->used)
Index: gcc/fortran/module.c
===================================================================
--- gcc/fortran/module.c	(revision 147619)
+++ gcc/fortran/module.c	(working copy)
@@ -4997,12 +4997,9 @@ import_iso_c_binding_module (void)
       
       for (u = gfc_rename_list; u; u = u->next)
 	{
-	  iso_c_binding_symbol is;
+	  i = get_c_kind (u->use_name, c_interop_kinds_table);
 
-	  is = (iso_c_binding_symbol) get_c_kind (u->use_name,
-						  c_interop_kinds_table);
-
-	  if (is == ISOCBINDING_INVALID || is == ISOCBINDING_LAST)
+	  if (i == ISOCBINDING_INVALID || i == ISOCBINDING_LAST)
 	    {
 	      gfc_error ("Symbol '%s' referenced at %L does not exist in "
 			 "intrinsic module ISO_C_BINDING.", u->use_name,
Index: gcc/df.h
===================================================================
--- gcc/df.h	(revision 147619)
+++ gcc/df.h	(working copy)
@@ -82,8 +82,6 @@ enum df_ref_type {DF_REF_REG_DEF, DF_REF
 
 enum df_ref_flags
   {
-    DF_REF_NONE = 0,
-
     /* This flag is set if this ref occurs inside of a conditional
        execution instruction.  */
     DF_REF_CONDITIONAL = 1 << 0,
Index: gcc/gimplify.c
===================================================================
--- gcc/gimplify.c	(revision 147619)
+++ gcc/gimplify.c	(working copy)
@@ -1993,7 +1993,7 @@ gimplify_var_or_parm_decl (tree *expr_p)
 
 static enum gimplify_status
 gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
-			int fallback)
+			fallback_t fallback)
 {
   tree *p;
   VEC(tree,heap) *stack;
@@ -2915,7 +2915,7 @@ generic_expr_could_trap_p (tree expr)
       *EXPR_P should be stored.  */
 
 static enum gimplify_status
-gimplify_cond_expr (tree *expr_p, gimple_seq *pre_p, int fallback)
+gimplify_cond_expr (tree *expr_p, gimple_seq *pre_p, fallback_t fallback)
 {
   tree expr = *expr_p;
   tree tmp, type, arm1, arm2;
@@ -6385,7 +6385,7 @@ gimplify_omp_atomic (tree *expr_p, gimpl
 
 enum gimplify_status
 gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
-	       bool (*gimple_test_f) (tree), int fallback)
+	       bool (*gimple_test_f) (tree), fallback_t fallback)
 {
   tree tmp;
   gimple_seq internal_pre = NULL;
Index: gcc/stringpool.c
===================================================================
--- gcc/stringpool.c	(revision 147619)
+++ gcc/stringpool.c	(working copy)
@@ -47,7 +47,7 @@ const char digit_vector[] = {
 
 struct ht *ident_hash;
 
-static hashnode alloc_node (cpp_hash_table *);
+static hashnode alloc_node (hash_table *);
 static int mark_ident (struct cpp_reader *, hashnode, const void *);
 
 static void *
@@ -68,7 +68,7 @@ init_stringpool (void)
 
 /* Allocate a hash node.  */
 static hashnode
-alloc_node (cpp_hash_table *table ATTRIBUTE_UNUSED)
+alloc_node (hash_table *table ATTRIBUTE_UNUSED)
 {
   return GCC_IDENT_TO_HT_IDENT (make_node (IDENTIFIER_NODE));
 }
Index: gcc/ira-costs.c
===================================================================
--- gcc/ira-costs.c	(revision 147619)
+++ gcc/ira-costs.c	(working copy)
@@ -681,8 +681,7 @@ record_reg_classes (int n_alts, int n_op
 		rclass = cost_classes[k];
 		if (TEST_HARD_REG_BIT (reg_class_contents[rclass], regno)
 		    && (reg_class_size[rclass]
-			== (unsigned) CLASS_MAX_NREGS ((enum reg_class) rclass,
-						       mode)))
+			== (unsigned) CLASS_MAX_NREGS (rclass, mode)))
 		  {
 		    if (reg_class_size[rclass] == 1)
 		      op_costs[i]->cost[k] = -frequency;
Index: gcc/rtl.h
===================================================================
--- gcc/rtl.h	(revision 147619)
+++ gcc/rtl.h	(working copy)
@@ -1758,7 +1758,6 @@ extern int find_reg_fusage (const_rtx, e
 extern int find_regno_fusage (const_rtx, enum rtx_code, unsigned int);
 extern rtx alloc_reg_note (enum reg_note, rtx, rtx);
 extern void add_reg_note (rtx, enum reg_note, rtx);
-extern rtx alloc_reg_note (enum reg_note, rtx, rtx);
 extern void remove_note (rtx, const_rtx);
 extern void remove_reg_equal_equiv_notes (rtx);
 extern int side_effects_p (const_rtx);
Index: gcc/df-problems.c
===================================================================
--- gcc/df-problems.c	(revision 147619)
+++ gcc/df-problems.c	(working copy)
@@ -442,7 +442,7 @@ df_rd_bb_local_compute (unsigned int bb_
   if (!(df->changeable_flags & DF_NO_HARD_REGS))
     df_rd_bb_local_compute_process_def (bb_info, 
 					df_get_artificial_defs (bb_index),
-					DF_REF_NONE);
+					0);
 
   FOR_BB_INSNS_REVERSE (bb, insn)
     {
@@ -452,8 +452,7 @@ df_rd_bb_local_compute (unsigned int bb_
 	continue;
 
       df_rd_bb_local_compute_process_def (bb_info, 
-					  DF_INSN_UID_DEFS (uid),
-					  DF_REF_NONE);
+					  DF_INSN_UID_DEFS (uid), 0);
 
       /* This complex dance with the two bitmaps is required because
 	 instructions can assign twice to the same pseudo.  This
@@ -2172,7 +2171,7 @@ df_chain_create_bb (unsigned int bb_inde
   if (!(df->changeable_flags & DF_NO_HARD_REGS))
     df_chain_create_bb_process_use (cpy,
 				    df_get_artificial_uses (bb->index), 
-				    DF_REF_NONE);
+				    0);
 
   BITMAP_FREE (cpy);
 }
Index: gcc/gimple.c
===================================================================
--- gcc/gimple.c	(revision 147619)
+++ gcc/gimple.c	(working copy)
@@ -1122,41 +1122,6 @@ gimple_check_failed (const_gimple gs, co
 		    : "",
 		  function, trim_filename (file), line);
 }
-
-/* Similar to gimple_check_failed, except that instead of specifying a
-   dozen codes, use the knowledge that they're all sequential.  */
-
-void
-gimple_range_check_failed (const_gimple gs, const char *file, int line,
-		           const char *function, enum gimple_code c1,
-		           enum gimple_code c2)
-{
-  char *buffer;
-  unsigned length = 0;
-  int c;
-
-  for (c = c1; c <= c2; ++c)
-    length += 4 + strlen (gimple_code_name[c]);
-
-  length += strlen ("expected ");
-  buffer = XALLOCAVAR (char, length);
-  length = 0;
-
-  for (c = c1; c <= c2; ++c)
-    {
-      const char *prefix = length ? " or " : "expected ";
-
-      strcpy (buffer + length, prefix);
-      length += strlen (prefix);
-      strcpy (buffer + length, gimple_code_name[c]);
-      length += strlen (gimple_code_name[c]);
-    }
-
-  internal_error ("gimple check: %s, have %s in %s, at %s:%d",
-		  buffer, gimple_code_name[gimple_code (gs)],
-		  function, trim_filename (file), line);
-}
-
 #endif /* ENABLE_GIMPLE_CHECKING */
 
 
Index: gcc/gimple.h
===================================================================
--- gcc/gimple.h	(revision 147619)
+++ gcc/gimple.h	(working copy)
@@ -952,7 +952,7 @@ struct gimplify_ctx
 };
 
 extern enum gimplify_status gimplify_expr (tree *, gimple_seq *, gimple_seq *,
-					   bool (*) (tree), int);
+					   bool (*) (tree), fallback_t);
 extern void gimplify_type_sizes (tree, gimple_seq *);
 extern void gimplify_one_sizepos (tree *, gimple_seq *);
 extern bool gimplify_stmt (tree *, gimple_seq *);
Index: libcpp/symtab.c
===================================================================
--- libcpp/symtab.c	(revision 147619)
+++ libcpp/symtab.c	(working copy)
@@ -31,7 +31,7 @@ along with this program; see the file CO
    existing entry with a potential new one.  */
 
 static unsigned int calc_hash (const unsigned char *, size_t);
-static void ht_expand (cpp_hash_table *);
+static void ht_expand (hash_table *);
 static double approx_sqrt (double);
 
 /* A deleted entry.  */
@@ -53,13 +53,13 @@ calc_hash (const unsigned char *str, siz
 
 /* Initialize an identifier hashtable.  */
 
-cpp_hash_table *
+hash_table *
 ht_create (unsigned int order)
 {
   unsigned int nslots = 1 << order;
-  cpp_hash_table *table;
+  hash_table *table;
 
-  table = XCNEW (cpp_hash_table);
+  table = XCNEW (hash_table);
 
   /* Strings need no alignment.  */
   _obstack_begin (&table->stack, 0, 0,
@@ -77,7 +77,7 @@ ht_create (unsigned int order)
 /* Frees all memory associated with a hash table.  */
 
 void
-ht_destroy (cpp_hash_table *table)
+ht_destroy (hash_table *table)
 {
   obstack_free (&table->stack, NULL);
   if (table->entries_owned)
@@ -91,7 +91,7 @@ ht_destroy (cpp_hash_table *table)
    returns NULL.  Otherwise insert and returns a new entry.  A new
    string is allocated.  */
 hashnode
-ht_lookup (cpp_hash_table *table, const unsigned char *str, size_t len,
+ht_lookup (hash_table *table, const unsigned char *str, size_t len,
 	   enum ht_lookup_option insert)
 {
   return ht_lookup_with_hash (table, str, len, calc_hash (str, len),
@@ -99,7 +99,7 @@ ht_lookup (cpp_hash_table *table, const 
 }
 
 hashnode
-ht_lookup_with_hash (cpp_hash_table *table, const unsigned char *str,
+ht_lookup_with_hash (hash_table *table, const unsigned char *str,
 		     size_t len, unsigned int hash,
 		     enum ht_lookup_option insert)
 {
@@ -182,7 +182,7 @@ ht_lookup_with_hash (cpp_hash_table *tab
 /* Double the size of a hash table, re-hashing existing entries.  */
 
 static void
-ht_expand (cpp_hash_table *table)
+ht_expand (hash_table *table)
 {
   hashnode *nentries, *p, *limit;
   unsigned int size, sizemask;
@@ -224,7 +224,7 @@ ht_expand (cpp_hash_table *table)
 /* For all nodes in TABLE, callback CB with parameters TABLE->PFILE,
    the node, and V.  */
 void
-ht_forall (cpp_hash_table *table, ht_cb cb, const void *v)
+ht_forall (hash_table *table, ht_cb cb, const void *v)
 {
   hashnode *p, *limit;
 
@@ -242,7 +242,7 @@ ht_forall (cpp_hash_table *table, ht_cb 
 /* Like ht_forall, but a nonzero return from the callback means that
    the entry should be removed from the table.  */
 void
-ht_purge (cpp_hash_table *table, ht_cb cb, const void *v)
+ht_purge (hash_table *table, ht_cb cb, const void *v)
 {
   hashnode *p, *limit;
 
@@ -259,7 +259,7 @@ ht_purge (cpp_hash_table *table, ht_cb c
 
 /* Restore the hash table.  */
 void
-ht_load (cpp_hash_table *ht, hashnode *entries,
+ht_load (hash_table *ht, hashnode *entries,
 	 unsigned int nslots, unsigned int nelements,
 	 bool own)
 {
@@ -274,7 +274,7 @@ ht_load (cpp_hash_table *ht, hashnode *e
 /* Dump allocation statistics to stderr.  */
 
 void
-ht_dump_statistics (cpp_hash_table *table)
+ht_dump_statistics (hash_table *table)
 {
   size_t nelts, nids, overhead, headers;
   size_t total_bytes, longest, deleted = 0;
Index: libcpp/include/symtab.h
===================================================================
--- libcpp/include/symtab.h	(revision 147619)
+++ libcpp/include/symtab.h	(working copy)
@@ -41,7 +41,7 @@ struct GTY(()) ht_identifier {
 #define HT_LEN(NODE) ((NODE)->len)
 #define HT_STR(NODE) ((NODE)->str)
 
-typedef struct ht cpp_hash_table;
+typedef struct ht hash_table;
 typedef struct ht_identifier *hashnode;
 
 enum ht_lookup_option {HT_NO_INSERT = 0, HT_ALLOC};
@@ -54,7 +54,7 @@ struct ht
 
   hashnode *entries;
   /* Call back, allocate a node.  */
-  hashnode (*alloc_node) (cpp_hash_table *);
+  hashnode (*alloc_node) (hash_table *);
   /* Call back, allocate something that hangs off a node like a cpp_macro.  
      NULL means use the usual allocator.  */
   void * (*alloc_subobject) (size_t);
@@ -74,14 +74,14 @@ struct ht
 };
 
 /* Initialize the hashtable with 2 ^ order entries.  */
-extern cpp_hash_table *ht_create (unsigned int order);
+extern hash_table *ht_create (unsigned int order);
 
 /* Frees all memory associated with a hash table.  */
-extern void ht_destroy (cpp_hash_table *);
+extern void ht_destroy (hash_table *);
 
-extern hashnode ht_lookup (cpp_hash_table *, const unsigned char *,
+extern hashnode ht_lookup (hash_table *, const unsigned char *,
 			   size_t, enum ht_lookup_option);
-extern hashnode ht_lookup_with_hash (cpp_hash_table *, const unsigned char *,
+extern hashnode ht_lookup_with_hash (hash_table *, const unsigned char *,
                                      size_t, unsigned int,
                                      enum ht_lookup_option);
 #define HT_HASHSTEP(r, c) ((r) * 67 + ((c) - 113));
@@ -91,18 +91,18 @@ extern hashnode ht_lookup_with_hash (cpp
    TABLE->PFILE, the node, and a PTR, and the callback sequence stops
    if the callback returns zero.  */
 typedef int (*ht_cb) (struct cpp_reader *, hashnode, const void *);
-extern void ht_forall (cpp_hash_table *, ht_cb, const void *);
+extern void ht_forall (hash_table *, ht_cb, const void *);
 
 /* For all nodes in TABLE, call the callback.  If the callback returns
    a nonzero value, the node is removed from the table.  */
-extern void ht_purge (cpp_hash_table *, ht_cb, const void *);
+extern void ht_purge (hash_table *, ht_cb, const void *);
 
 /* Restore the hash table.  */
-extern void ht_load (cpp_hash_table *ht, hashnode *entries,
+extern void ht_load (hash_table *ht, hashnode *entries,
 		     unsigned int nslots, unsigned int nelements, bool own);
 
 /* Dump allocation statistics to stderr.  */
-extern void ht_dump_statistics (cpp_hash_table *);
+extern void ht_dump_statistics (hash_table *);
 
 #ifdef __cplusplus
 }
Index: libcpp/init.c
===================================================================
--- libcpp/init.c	(revision 147619)
+++ libcpp/init.c	(working copy)
@@ -140,7 +140,7 @@ init_library (void)
 
 /* Initialize a cpp_reader structure.  */
 cpp_reader *
-cpp_create_reader (enum c_lang lang, cpp_hash_table *table,
+cpp_create_reader (enum c_lang lang, hash_table *table,
 		   struct line_maps *line_table)
 {
   cpp_reader *pfile;
@@ -307,7 +307,7 @@ cpp_destroy (cpp_reader *pfile)
    "builtin" macros: these are handled by builtin_macro() in
    macro.c.  Builtin is somewhat of a misnomer -- the property of
    interest is that these macros require special code to compute their
-   expansions.  The value is a "cpp_builtin_type" enumerator.
+   expansions.  The value is a "builtin_type" enumerator.
 
    operator_array holds the C++ named operators.  These are keywords
    which act as aliases for punctuators.  In C++, they cannot be
Index: libcpp/identifiers.c
===================================================================
--- libcpp/identifiers.c	(revision 147619)
+++ libcpp/identifiers.c	(working copy)
@@ -28,12 +28,12 @@ along with this program; see the file CO
 #include "cpplib.h"
 #include "internal.h"
 
-static hashnode alloc_node (cpp_hash_table *);
+static hashnode alloc_node (hash_table *);
 
 /* Return an identifier node for hashtable.c.  Used by cpplib except
    when integrated with the C front ends.  */
 static hashnode
-alloc_node (cpp_hash_table *table)
+alloc_node (hash_table *table)
 {
   cpp_hashnode *node;
 
@@ -45,7 +45,7 @@ alloc_node (cpp_hash_table *table)
 /* Set up the identifier hash table.  Use TABLE if non-null, otherwise
    create our own.  */
 void
-_cpp_init_hashtable (cpp_reader *pfile, cpp_hash_table *table)
+_cpp_init_hashtable (cpp_reader *pfile, hash_table *table)
 {
   struct spec_nodes *s;
 
Index: libcpp/internal.h
===================================================================
--- libcpp/internal.h	(revision 147619)
+++ libcpp/internal.h	(working copy)
@@ -535,7 +535,7 @@ extern void _cpp_push_token_context (cpp
 extern void _cpp_backup_tokens_direct (cpp_reader *, unsigned int);
 
 /* In identifiers.c */
-extern void _cpp_init_hashtable (cpp_reader *, cpp_hash_table *);
+extern void _cpp_init_hashtable (cpp_reader *, hash_table *);
 extern void _cpp_destroy_hashtable (cpp_reader *);
 
 /* In files.c */

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]