* cvt.c (convert_to_void): Avoid C++ keywords.

	* decl.c (walk_namespaces_r, wrapup_globals_for_namespace):
	Likewise.
	* friend.c (is_friend): Likewise.
	* init.c (perform_member_init): Likewise.
	* mangle.c (write_template_prefix, write_template_template_param):
	Likewise.
	* name-lookup.c (do_namespace_alias, do_using_directive,
	parse_using_directive, ambiguous_decl, arg_assoc): Likewise.
	* parser.c (cp_parser_template_id, cp_parser_namespace_definition,
	cp_parser_objc_typename, cp_parser_objc_method_keyword_params):
	Likewise.
	* pt.c (is_specialization_of_friend, lookup_template_class,
	push_tinst_level, instantiate_class_template,
	tsubst_copy_and_build): Likewise.
	* tree.c (add_stmt_to_compound): Likewise.
	* typeck.c (finish_class_member_access_expr): Likewise.



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

11 files changed, 206 insertions, 186 deletions

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index a664d0f9bc9..d67a10b0283 100644
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,23 @@
+2008-07-18  Kaveh R. Ghazi  <ghazi@caip.rutgers.edu>
+
+	* cvt.c (convert_to_void): Avoid C++ keywords.
+	* decl.c (walk_namespaces_r, wrapup_globals_for_namespace):
+	Likewise.
+	* friend.c (is_friend): Likewise.
+	* init.c (perform_member_init): Likewise.
+	* mangle.c (write_template_prefix, write_template_template_param):
+	Likewise.
+	* name-lookup.c (do_namespace_alias, do_using_directive,
+	parse_using_directive, ambiguous_decl, arg_assoc): Likewise.
+	* parser.c (cp_parser_template_id, cp_parser_namespace_definition,
+	cp_parser_objc_typename, cp_parser_objc_method_keyword_params):
+	Likewise.
+	* pt.c (is_specialization_of_friend, lookup_template_class,
+	push_tinst_level, instantiate_class_template,
+	tsubst_copy_and_build): Likewise.
+	* tree.c (add_stmt_to_compound): Likewise.
+	* typeck.c (finish_class_member_access_expr): Likewise.
+
 2008-07-17  Julian Brown  <julian@codesourcery.com>
 	    Mark Mitchell  <mark@codesourcery.com>
 
diff --git a/gcc/cp/cvt.c b/gcc/cp/cvt.c
index 70ef00a4fce..3ee3ba7956b 100644
--- a/gcc/cp/cvt.c
+++ b/gcc/cp/cvt.c
@@ -938,7 +938,7 @@ convert_to_void (tree expr, const char *implicit, tsubst_flags_t complain)
 	    {
 	      tree e;
 	      enum tree_code code;
-	      enum tree_code_class class;
+	      enum tree_code_class tclass;
 
 	      e = expr;
 	      /* We might like to warn about (say) "(int) f()", as the
@@ -955,10 +955,10 @@ convert_to_void (tree expr, const char *implicit, tsubst_flags_t complain)
 		e = TREE_OPERAND (e, 0);
 
 	      code = TREE_CODE (e);
-	      class = TREE_CODE_CLASS (code);
-	      if ((class == tcc_comparison
-		   || class == tcc_unary
-		   || (class == tcc_binary
+	      tclass = TREE_CODE_CLASS (code);
+	      if ((tclass == tcc_comparison
+		   || tclass == tcc_unary
+		   || (tclass == tcc_binary
 		       && !(code == MODIFY_EXPR
 			    || code == INIT_EXPR
 			    || code == PREDECREMENT_EXPR
diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
index 83d2c4ea5a7..cd6f287c857 100644
--- a/gcc/cp/decl.c
+++ b/gcc/cp/decl.c
@@ -800,12 +800,12 @@ insert_block (tree block)
    itself, calling F for each.  The DATA is passed to F as well.  */
 
 static int
-walk_namespaces_r (tree namespace, walk_namespaces_fn f, void* data)
+walk_namespaces_r (tree name_space, walk_namespaces_fn f, void* data)
 {
   int result = 0;
-  tree current = NAMESPACE_LEVEL (namespace)->namespaces;
+  tree current = NAMESPACE_LEVEL (name_space)->namespaces;
 
-  result |= (*f) (namespace, data);
+  result |= (*f) (name_space, data);
 
   for (; current; current = TREE_CHAIN (current))
     result |= walk_namespaces_r (current, f, data);
@@ -827,9 +827,9 @@ walk_namespaces (walk_namespaces_fn f, void* data)
    wrapup_global_declarations for this NAMESPACE.  */
 
 int
-wrapup_globals_for_namespace (tree namespace, void* data)
+wrapup_globals_for_namespace (tree name_space, void* data)
 {
-  struct cp_binding_level *level = NAMESPACE_LEVEL (namespace);
+  struct cp_binding_level *level = NAMESPACE_LEVEL (name_space);
   VEC(tree,gc) *statics = level->static_decls;
   tree *vec = VEC_address (tree, statics);
   int len = VEC_length (tree, statics);
diff --git a/gcc/cp/friend.c b/gcc/cp/friend.c
index 96c6dc653ba..090f84db288 100644
--- a/gcc/cp/friend.c
+++ b/gcc/cp/friend.c
@@ -59,15 +59,15 @@ is_friend (tree type, tree supplicant)
 	      tree friends = FRIEND_DECLS (list);
 	      for (; friends ; friends = TREE_CHAIN (friends))
 		{
-		  tree friend = TREE_VALUE (friends);
+		  tree this_friend = TREE_VALUE (friends);
 
-		  if (friend == NULL_TREE)
+		  if (this_friend == NULL_TREE)
 		    continue;
 
-		  if (supplicant == friend)
+		  if (supplicant == this_friend)
 		    return 1;
 
-		  if (is_specialization_of_friend (supplicant, friend))
+		  if (is_specialization_of_friend (supplicant, this_friend))
 		    return 1;
 		}
 	      break;
diff --git a/gcc/cp/init.c b/gcc/cp/init.c
index 3e9e612f2b4..add7596b97a 100644
--- a/gcc/cp/init.c
+++ b/gcc/cp/init.c
@@ -469,13 +469,13 @@ perform_member_init (tree member, tree init)
 {
   tree decl;
   tree type = TREE_TYPE (member);
-  bool explicit;
+  bool is_explicit;
 
-  explicit = (init != NULL_TREE);
+  is_explicit = (init != NULL_TREE);
 
   /* Effective C++ rule 12 requires that all data members be
      initialized.  */
-  if (warn_ecpp && !explicit && TREE_CODE (type) != ARRAY_TYPE)
+  if (warn_ecpp && !is_explicit && TREE_CODE (type) != ARRAY_TYPE)
     warning (OPT_Weffc__, "%J%qD should be initialized in the member initialization "
 	     "list", current_function_decl, member);
 
@@ -503,7 +503,7 @@ perform_member_init (tree member, tree init)
     }
   else if (TYPE_NEEDS_CONSTRUCTING (type))
     {
-      if (explicit
+      if (is_explicit
 	  && TREE_CODE (type) == ARRAY_TYPE
 	  && init != NULL_TREE
 	  && TREE_CHAIN (init) == NULL_TREE
@@ -523,7 +523,7 @@ perform_member_init (tree member, tree init)
     {
       if (init == NULL_TREE)
 	{
-	  if (explicit)
+	  if (is_explicit)
 	    {
 	      init = build_default_init (type, /*nelts=*/NULL_TREE);
 	      if (TREE_CODE (type) == REFERENCE_TYPE)
diff --git a/gcc/cp/mangle.c b/gcc/cp/mangle.c
index b27b2db9b3a..1bc72b86a2d 100644
--- a/gcc/cp/mangle.c
+++ b/gcc/cp/mangle.c
@@ -974,19 +974,19 @@ write_template_prefix (const tree node)
   tree type = DECL_P (node) ? TREE_TYPE (node) : node;
   tree context = CP_DECL_CONTEXT (decl);
   tree template_info;
-  tree template;
+  tree templ;
   tree substitution;
 
   MANGLE_TRACE_TREE ("template-prefix", node);
 
   /* Find the template decl.  */
   if (decl_is_template_id (decl, &template_info))
-    template = TI_TEMPLATE (template_info);
+    templ = TI_TEMPLATE (template_info);
   else
     {
       gcc_assert (CLASSTYPE_TEMPLATE_ID_P (type));
 
-      template = TYPE_TI_TEMPLATE (type);
+      templ = TYPE_TI_TEMPLATE (type);
     }
 
   /* For a member template, though, the template name for the
@@ -1012,21 +1012,21 @@ write_template_prefix (const tree node)
      substitution candidate by a TREE_LIST whose purpose is `Outer<int>'
      and whose value is `Outer<T>::Inner<U>'.  */
   if (TYPE_P (context))
-    substitution = build_tree_list (context, template);
+    substitution = build_tree_list (context, templ);
   else
-    substitution = template;
+    substitution = templ;
 
   if (find_substitution (substitution))
     return;
 
   /* In G++ 3.2, the name of the template template parameter was used.  */
-  if (TREE_CODE (TREE_TYPE (template)) == TEMPLATE_TEMPLATE_PARM
+  if (TREE_CODE (TREE_TYPE (templ)) == TEMPLATE_TEMPLATE_PARM
       && !abi_version_at_least (2))
     G.need_abi_warning = true;
 
-  if (TREE_CODE (TREE_TYPE (template)) == TEMPLATE_TEMPLATE_PARM
+  if (TREE_CODE (TREE_TYPE (templ)) == TEMPLATE_TEMPLATE_PARM
       && abi_version_at_least (2))
-    write_template_param (TREE_TYPE (template));
+    write_template_param (TREE_TYPE (templ));
   else
     {
       write_prefix (context);
@@ -2480,24 +2480,24 @@ write_template_param (const tree parm)
 static void
 write_template_template_param (const tree parm)
 {
-  tree template = NULL_TREE;
+  tree templ = NULL_TREE;
 
   /* PARM, a TEMPLATE_TEMPLATE_PARM, is an instantiation of the
      template template parameter.  The substitution candidate here is
      only the template.  */
   if (TREE_CODE (parm) == BOUND_TEMPLATE_TEMPLATE_PARM)
     {
-      template
+      templ
 	= TI_TEMPLATE (TEMPLATE_TEMPLATE_PARM_TEMPLATE_INFO (parm));
-      if (find_substitution (template))
+      if (find_substitution (templ))
 	return;
     }
 
   /* <template-param> encodes only the template parameter position,
      not its template arguments, which is fine here.  */
   write_template_param (parm);
-  if (template)
-    add_substitution (template);
+  if (templ)
+    add_substitution (templ);
 }
 
 /* Non-terminal <substitution>.
diff --git a/gcc/cp/name-lookup.c b/gcc/cp/name-lookup.c
index 45899c535e6..edf74f9c81f 100644
--- a/gcc/cp/name-lookup.c
+++ b/gcc/cp/name-lookup.c
@@ -3310,18 +3310,18 @@ namespace_ancestor (tree ns1, tree ns2)
 /* Process a namespace-alias declaration.  */
 
 void
-do_namespace_alias (tree alias, tree namespace)
+do_namespace_alias (tree alias, tree name_space)
 {
-  if (namespace == error_mark_node)
+  if (name_space == error_mark_node)
     return;
 
-  gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL);
+  gcc_assert (TREE_CODE (name_space) == NAMESPACE_DECL);
 
-  namespace = ORIGINAL_NAMESPACE (namespace);
+  name_space = ORIGINAL_NAMESPACE (name_space);
 
   /* Build the alias.  */
   alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
-  DECL_NAMESPACE_ALIAS (alias) = namespace;
+  DECL_NAMESPACE_ALIAS (alias) = name_space;
   DECL_EXTERNAL (alias) = 1;
   DECL_CONTEXT (alias) = FROB_CONTEXT (current_scope ());
   pushdecl (alias);
@@ -3459,46 +3459,46 @@ do_toplevel_using_decl (tree decl, tree scope, tree name)
 /* Process a using-directive.  */
 
 void
-do_using_directive (tree namespace)
+do_using_directive (tree name_space)
 {
   tree context = NULL_TREE;
 
-  if (namespace == error_mark_node)
+  if (name_space == error_mark_node)
     return;
 
-  gcc_assert (TREE_CODE (namespace) == NAMESPACE_DECL);
+  gcc_assert (TREE_CODE (name_space) == NAMESPACE_DECL);
 
   if (building_stmt_tree ())
-    add_stmt (build_stmt (USING_STMT, namespace));
-  namespace = ORIGINAL_NAMESPACE (namespace);
+    add_stmt (build_stmt (USING_STMT, name_space));
+  name_space = ORIGINAL_NAMESPACE (name_space);
 
   if (!toplevel_bindings_p ())
     {
-      push_using_directive (namespace);
+      push_using_directive (name_space);
       context = current_scope ();
     }
   else
     {
       /* direct usage */
-      add_using_namespace (current_namespace, namespace, 0);
+      add_using_namespace (current_namespace, name_space, 0);
       if (current_namespace != global_namespace)
 	context = current_namespace;
     }
 
   /* Emit debugging info.  */
   if (!processing_template_decl)
-    (*debug_hooks->imported_module_or_decl) (namespace, context);
+    (*debug_hooks->imported_module_or_decl) (name_space, context);
 }
 
 /* Deal with a using-directive seen by the parser.  Currently we only
    handle attributes here, since they cannot appear inside a template.  */
 
 void
-parse_using_directive (tree namespace, tree attribs)
+parse_using_directive (tree name_space, tree attribs)
 {
   tree a;
 
-  do_using_directive (namespace);
+  do_using_directive (name_space);
 
   for (a = attribs; a; a = TREE_CHAIN (a))
     {
@@ -3507,14 +3507,14 @@ parse_using_directive (tree namespace, tree attribs)
 	{
 	  if (!toplevel_bindings_p ())
 	    error ("strong using only meaningful at namespace scope");
-	  else if (namespace != error_mark_node)
+	  else if (name_space != error_mark_node)
 	    {
-	      if (!is_ancestor (current_namespace, namespace))
+	      if (!is_ancestor (current_namespace, name_space))
 		error ("current namespace %qD does not enclose strongly used namespace %qD",
-		       current_namespace, namespace);
-	      DECL_NAMESPACE_ASSOCIATIONS (namespace)
+		       current_namespace, name_space);
+	      DECL_NAMESPACE_ASSOCIATIONS (name_space)
 		= tree_cons (current_namespace, 0,
-			     DECL_NAMESPACE_ASSOCIATIONS (namespace));
+			     DECL_NAMESPACE_ASSOCIATIONS (name_space));
 	    }
 	}
       else
@@ -3603,25 +3603,25 @@ merge_functions (tree s1, tree s2)
 /* This should return an error not all definitions define functions.
    It is not an error if we find two functions with exactly the
    same signature, only if these are selected in overload resolution.
-   old is the current set of bindings, new the freshly-found binding.
+   old is the current set of bindings, new_binding the freshly-found binding.
    XXX Do we want to give *all* candidates in case of ambiguity?
    XXX In what way should I treat extern declarations?
    XXX I don't want to repeat the entire duplicate_decls here */
 
 static void
-ambiguous_decl (struct scope_binding *old, cxx_binding *new, int flags)
+ambiguous_decl (struct scope_binding *old, cxx_binding *new_binding, int flags)
 {
   tree val, type;
   gcc_assert (old != NULL);
 
   /* Copy the type.  */
-  type = new->type;
+  type = new_binding->type;
   if (LOOKUP_NAMESPACES_ONLY (flags)
       || (type && hidden_name_p (type) && !(flags & LOOKUP_HIDDEN)))
     type = NULL_TREE;
 
   /* Copy the value.  */
-  val = new->value;
+  val = new_binding->value;
   if (val)
     {
       if (hidden_name_p (val) && !(flags & LOOKUP_HIDDEN))
@@ -4772,21 +4772,21 @@ arg_assoc (struct arg_lookup *k, tree n)
 	 If T is a template-id, its associated namespaces and classes
 	 are the namespace in which the template is defined; for
 	 member templates, the member template's class...  */
-      tree template = TREE_OPERAND (n, 0);
+      tree templ = TREE_OPERAND (n, 0);
       tree args = TREE_OPERAND (n, 1);
       tree ctx;
       int ix;
 
-      if (TREE_CODE (template) == COMPONENT_REF)
-	template = TREE_OPERAND (template, 1);
+      if (TREE_CODE (templ) == COMPONENT_REF)
+	templ = TREE_OPERAND (templ, 1);
 
       /* First, the template.  There may actually be more than one if
 	 this is an overloaded function template.  But, in that case,
 	 we only need the first; all the functions will be in the same
 	 namespace.  */
-      template = OVL_CURRENT (template);
+      templ = OVL_CURRENT (templ);
 
-      ctx = CP_DECL_CONTEXT (template);
+      ctx = CP_DECL_CONTEXT (templ);
 
       if (TREE_CODE (ctx) == NAMESPACE_DECL)
 	{
diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
index 567f04eea96..02fb6607130 100644
--- a/gcc/cp/parser.c
+++ b/gcc/cp/parser.c
@@ -9890,7 +9890,7 @@ cp_parser_template_id (cp_parser *parser,
 		       bool is_declaration)
 {
   int i;
-  tree template;
+  tree templ;
   tree arguments;
   tree template_id;
   cp_token_position start_of_id = 0;
@@ -9945,14 +9945,14 @@ cp_parser_template_id (cp_parser *parser,
   /* Parse the template-name.  */
   is_identifier = false;
   token = cp_lexer_peek_token (parser->lexer);
-  template = cp_parser_template_name (parser, template_keyword_p,
-				      check_dependency_p,
-				      is_declaration,
-				      &is_identifier);
-  if (template == error_mark_node || is_identifier)
+  templ = cp_parser_template_name (parser, template_keyword_p,
+				   check_dependency_p,
+				   is_declaration,
+				   &is_identifier);
+  if (templ == error_mark_node || is_identifier)
     {
       pop_deferring_access_checks ();
-      return template;
+      return templ;
     }
 
   /* If we find the sequence `[:' after a template-name, it's probably
@@ -10015,10 +10015,10 @@ cp_parser_template_id (cp_parser *parser,
     }
 
   /* Build a representation of the specialization.  */
-  if (TREE_CODE (template) == IDENTIFIER_NODE)
-    template_id = build_min_nt (TEMPLATE_ID_EXPR, template, arguments);
-  else if (DECL_CLASS_TEMPLATE_P (template)
-	   || DECL_TEMPLATE_TEMPLATE_PARM_P (template))
+  if (TREE_CODE (templ) == IDENTIFIER_NODE)
+    template_id = build_min_nt (TEMPLATE_ID_EXPR, templ, arguments);
+  else if (DECL_CLASS_TEMPLATE_P (templ)
+	   || DECL_TEMPLATE_TEMPLATE_PARM_P (templ))
     {
       bool entering_scope;
       /* In "template <typename T> ... A<T>::", A<T> is the abstract A
@@ -10030,17 +10030,17 @@ cp_parser_template_id (cp_parser *parser,
 			&& cp_lexer_next_token_is (parser->lexer,
 						   CPP_SCOPE));
       template_id
-	= finish_template_type (template, arguments, entering_scope);
+	= finish_template_type (templ, arguments, entering_scope);
     }
   else
     {
       /* If it's not a class-template or a template-template, it should be
 	 a function-template.  */
-      gcc_assert ((DECL_FUNCTION_TEMPLATE_P (template)
-		   || TREE_CODE (template) == OVERLOAD
-		   || BASELINK_P (template)));
+      gcc_assert ((DECL_FUNCTION_TEMPLATE_P (templ)
+		   || TREE_CODE (templ) == OVERLOAD
+		   || BASELINK_P (templ)));
 
-      template_id = lookup_template_function (template, arguments);
+      template_id = lookup_template_function (templ, arguments);
     }
 
   /* If parsing tentatively, replace the sequence of tokens that makes
@@ -11901,14 +11901,14 @@ cp_parser_namespace_definition (cp_parser* parser)
      followed by a strong using directive.  */
   if (is_inline)
     {
-      tree namespace = current_namespace;
+      tree name_space = current_namespace;
       /* Set up namespace association.  */
-      DECL_NAMESPACE_ASSOCIATIONS (namespace)
-	= tree_cons (CP_DECL_CONTEXT (namespace), NULL_TREE,
-		     DECL_NAMESPACE_ASSOCIATIONS (namespace));
+      DECL_NAMESPACE_ASSOCIATIONS (name_space)
+	= tree_cons (CP_DECL_CONTEXT (name_space), NULL_TREE,
+		     DECL_NAMESPACE_ASSOCIATIONS (name_space));
       /* Import the contents of the inline namespace.  */
       pop_namespace ();
-      do_using_directive (namespace);
+      do_using_directive (name_space);
       push_namespace (identifier);
     }
 
@@ -19169,7 +19169,7 @@ cp_parser_objc_protocol_qualifiers (cp_parser* parser)
 static tree
 cp_parser_objc_typename (cp_parser* parser)
 {
-  tree typename = NULL_TREE;
+  tree type_name = NULL_TREE;
 
   if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN))
     {
@@ -19184,10 +19184,10 @@ cp_parser_objc_typename (cp_parser* parser)
 	cp_type = cp_parser_type_id (parser);
 
       cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>");
-      typename = build_tree_list (proto_quals, cp_type);
+      type_name = build_tree_list (proto_quals, cp_type);
     }
 
-  return typename;
+  return type_name;
 }
 
 /* Check to see if TYPE refers to an Objective-C selector name.  */
@@ -19244,7 +19244,7 @@ cp_parser_objc_method_keyword_params (cp_parser* parser)
 
   while (cp_parser_objc_selector_p (token->type) || token->type == CPP_COLON)
     {
-      tree selector = NULL_TREE, typename, identifier;
+      tree selector = NULL_TREE, type_name, identifier;
 
       if (token->type != CPP_COLON)
 	selector = cp_parser_objc_selector (parser);
@@ -19256,13 +19256,13 @@ cp_parser_objc_method_keyword_params (cp_parser* parser)
 
       maybe_unary_selector_p = false;
       cp_parser_require (parser, CPP_COLON, "%<:%>");
-      typename = cp_parser_objc_typename (parser);
+      type_name = cp_parser_objc_typename (parser);
       identifier = cp_parser_identifier (parser);
 
       params
 	= chainon (params,
 		   objc_build_keyword_decl (selector,
-					    typename,
+					    type_name,
 					    identifier));
 
       token = cp_lexer_peek_token (parser->lexer);
diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index 1378e5618dc..8b2d8c3507d 100644
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -1022,10 +1022,10 @@ is_specialization_of (tree decl, tree tmpl)
 }
 
 /* Returns nonzero iff DECL is a specialization of friend declaration
-   FRIEND according to [temp.friend].  */
+   FRIEND_DECL according to [temp.friend].  */
 
 bool
-is_specialization_of_friend (tree decl, tree friend)
+is_specialization_of_friend (tree decl, tree friend_decl)
 {
   bool need_template = true;
   int template_depth;
@@ -1033,26 +1033,26 @@ is_specialization_of_friend (tree decl, tree friend)
   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
 	      || TREE_CODE (decl) == TYPE_DECL);
 
-  /* For [temp.friend/6] when FRIEND is an ordinary member function
+  /* For [temp.friend/6] when FRIEND_DECL is an ordinary member function
      of a template class, we want to check if DECL is a specialization
      if this.  */
-  if (TREE_CODE (friend) == FUNCTION_DECL
-      && DECL_TEMPLATE_INFO (friend)
-      && !DECL_USE_TEMPLATE (friend))
+  if (TREE_CODE (friend_decl) == FUNCTION_DECL
+      && DECL_TEMPLATE_INFO (friend_decl)
+      && !DECL_USE_TEMPLATE (friend_decl))
     {
       /* We want a TEMPLATE_DECL for `is_specialization_of'.  */
-      friend = DECL_TI_TEMPLATE (friend);
+      friend_decl = DECL_TI_TEMPLATE (friend_decl);
       need_template = false;
     }
-  else if (TREE_CODE (friend) == TEMPLATE_DECL
-	   && !PRIMARY_TEMPLATE_P (friend))
+  else if (TREE_CODE (friend_decl) == TEMPLATE_DECL
+	   && !PRIMARY_TEMPLATE_P (friend_decl))
     need_template = false;
 
   /* There is nothing to do if this is not a template friend.  */
-  if (TREE_CODE (friend) != TEMPLATE_DECL)
+  if (TREE_CODE (friend_decl) != TEMPLATE_DECL)
     return false;
 
-  if (is_specialization_of (decl, friend))
+  if (is_specialization_of (decl, friend_decl))
     return true;
 
   /* [temp.friend/6]
@@ -1075,14 +1075,14 @@ is_specialization_of_friend (tree decl, tree friend)
      nonzero.  To determine if DECL is a friend of FRIEND, we first
      check if the enclosing class is a specialization of another.  */
 
-  template_depth = template_class_depth (DECL_CONTEXT (friend));
+  template_depth = template_class_depth (DECL_CONTEXT (friend_decl));
   if (template_depth
       && DECL_CLASS_SCOPE_P (decl)
       && is_specialization_of (TYPE_NAME (DECL_CONTEXT (decl)),
-			       CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend))))
+			       CLASSTYPE_TI_TEMPLATE (DECL_CONTEXT (friend_decl))))
     {
       /* Next, we check the members themselves.  In order to handle
-	 a few tricky cases, such as when FRIEND's are
+	 a few tricky cases, such as when FRIEND_DECL's are
 
 	   template <class T> friend void A<T>::g(T t);
 	   template <class T> template <T t> friend void A<T>::h();
@@ -1122,7 +1122,7 @@ is_specialization_of_friend (tree decl, tree friend)
 	  tree friend_args_type;
 	  tree decl_args_type;
 
-	  /* Make sure that both DECL and FRIEND are templates or
+	  /* Make sure that both DECL and FRIEND_DECL are templates or
 	     non-templates.  */
 	  is_template = DECL_TEMPLATE_INFO (decl)
 			&& PRIMARY_TEMPLATE_P (DECL_TI_TEMPLATE (decl));
@@ -1132,7 +1132,7 @@ is_specialization_of_friend (tree decl, tree friend)
 	    {
 	      /* If both are templates, check template parameter list.  */
 	      tree friend_parms
-		= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend),
+		= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl),
 					 args, tf_none);
 	      if (!comp_template_parms
 		     (DECL_TEMPLATE_PARMS (DECL_TI_TEMPLATE (decl)),
@@ -1144,7 +1144,7 @@ is_specialization_of_friend (tree decl, tree friend)
 	  else
 	    decl_type = TREE_TYPE (decl);
 
-	  friend_type = tsubst_function_type (TREE_TYPE (friend), args,
+	  friend_type = tsubst_function_type (TREE_TYPE (friend_decl), args,
 					      tf_none, NULL_TREE);
 	  if (friend_type == error_mark_node)
 	    return false;
@@ -1157,7 +1157,7 @@ is_specialization_of_friend (tree decl, tree friend)
 	     `this' parameter.  */
 	  friend_args_type = TYPE_ARG_TYPES (friend_type);
 	  decl_args_type = TYPE_ARG_TYPES (decl_type);
-	  if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend))
+	  if (DECL_NONSTATIC_MEMBER_FUNCTION_P (friend_decl))
 	    friend_args_type = TREE_CHAIN (friend_args_type);
 	  if (DECL_NONSTATIC_MEMBER_FUNCTION_P (decl))
 	    decl_args_type = TREE_CHAIN (decl_args_type);
@@ -1170,7 +1170,7 @@ is_specialization_of_friend (tree decl, tree friend)
 	  bool is_template;
 	  tree decl_type = TREE_TYPE (decl);
 
-	  /* Make sure that both DECL and FRIEND are templates or
+	  /* Make sure that both DECL and FRIEND_DECL are templates or
 	     non-templates.  */
 	  is_template
 	    = CLASSTYPE_TEMPLATE_INFO (decl_type)
@@ -1184,12 +1184,12 @@ is_specialization_of_friend (tree decl, tree friend)
 	      /* If both are templates, check the name of the two
 		 TEMPLATE_DECL's first because is_friend didn't.  */
 	      if (DECL_NAME (CLASSTYPE_TI_TEMPLATE (decl_type))
-		  != DECL_NAME (friend))
+		  != DECL_NAME (friend_decl))
 		return false;
 
 	      /* Now check template parameter list.  */
 	      friend_parms
-		= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend),
+		= tsubst_template_parms (DECL_TEMPLATE_PARMS (friend_decl),
 					 args, tf_none);
 	      return comp_template_parms
 		(DECL_TEMPLATE_PARMS (CLASSTYPE_TI_TEMPLATE (decl_type)),
@@ -1197,7 +1197,7 @@ is_specialization_of_friend (tree decl, tree friend)
 	    }
 	  else
 	    return (DECL_NAME (decl)
-		    == DECL_NAME (friend));
+		    == DECL_NAME (friend_decl));
 	}
     }
   return false;
@@ -5536,7 +5536,7 @@ lookup_template_class (tree d1,
 		       int entering_scope,
 		       tsubst_flags_t complain)
 {
-  tree template = NULL_TREE, parmlist;
+  tree templ = NULL_TREE, parmlist;
   tree t;
 
   timevar_push (TV_NAME_LOOKUP);
@@ -5545,18 +5545,18 @@ lookup_template_class (tree d1,
     {
       tree value = innermost_non_namespace_value (d1);
       if (value && DECL_TEMPLATE_TEMPLATE_PARM_P (value))
-	template = value;
+	templ = value;
       else
 	{
 	  if (context)
 	    push_decl_namespace (context);
-	  template = lookup_name (d1);
-	  template = maybe_get_template_decl_from_type_decl (template);
+	  templ = lookup_name (d1);
+	  templ = maybe_get_template_decl_from_type_decl (templ);
 	  if (context)
 	    pop_decl_namespace ();
 	}
-      if (template)
-	context = DECL_CONTEXT (template);
+      if (templ)
+	context = DECL_CONTEXT (templ);
     }
   else if (TREE_CODE (d1) == TYPE_DECL && MAYBE_CLASS_TYPE_P (TREE_TYPE (d1)))
     {
@@ -5569,37 +5569,37 @@ lookup_template_class (tree d1,
 
       if (CLASSTYPE_TEMPLATE_INFO (type))
 	{
-	  template = CLASSTYPE_TI_TEMPLATE (type);
-	  d1 = DECL_NAME (template);
+	  templ = CLASSTYPE_TI_TEMPLATE (type);
+	  d1 = DECL_NAME (templ);
 	}
     }
   else if (TREE_CODE (d1) == ENUMERAL_TYPE
 	   || (TYPE_P (d1) && MAYBE_CLASS_TYPE_P (d1)))
     {
-      template = TYPE_TI_TEMPLATE (d1);
-      d1 = DECL_NAME (template);
+      templ = TYPE_TI_TEMPLATE (d1);
+      d1 = DECL_NAME (templ);
     }
   else if (TREE_CODE (d1) == TEMPLATE_DECL
 	   && TREE_CODE (DECL_TEMPLATE_RESULT (d1)) == TYPE_DECL)
     {
-      template = d1;
-      d1 = DECL_NAME (template);
-      context = DECL_CONTEXT (template);
+      templ = d1;
+      d1 = DECL_NAME (templ);
+      context = DECL_CONTEXT (templ);
     }
 
   /* Issue an error message if we didn't find a template.  */
-  if (! template)
+  if (! templ)
     {
       if (complain & tf_error)
 	error ("%qT is not a template", d1);
       POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
     }
 
-  if (TREE_CODE (template) != TEMPLATE_DECL
+  if (TREE_CODE (templ) != TEMPLATE_DECL
 	 /* Make sure it's a user visible template, if it was named by
 	    the user.  */
-      || ((complain & tf_user) && !DECL_TEMPLATE_PARM_P (template)
-	  && !PRIMARY_TEMPLATE_P (template)))
+      || ((complain & tf_user) && !DECL_TEMPLATE_PARM_P (templ)
+	  && !PRIMARY_TEMPLATE_P (templ)))
     {
       if (complain & tf_error)
 	{
@@ -5612,7 +5612,7 @@ lookup_template_class (tree d1,
 
   complain &= ~tf_user;
 
-  if (DECL_TEMPLATE_TEMPLATE_PARM_P (template))
+  if (DECL_TEMPLATE_TEMPLATE_PARM_P (templ))
     {
       /* Create a new TEMPLATE_DECL and TEMPLATE_TEMPLATE_PARM node to store
 	 template arguments */
@@ -5621,7 +5621,7 @@ lookup_template_class (tree d1,
       tree arglist2;
       tree outer;
 
-      parmlist = DECL_INNERMOST_TEMPLATE_PARMS (template);
+      parmlist = DECL_INNERMOST_TEMPLATE_PARMS (templ);
 
       /* Consider an example where a template template parameter declared as
 
@@ -5639,7 +5639,7 @@ lookup_template_class (tree d1,
 	 level 1, and T at level 2, while the template arguments at level 1
 	 becomes {std::vector} and the inner level 2 is {int}.  */
 
-      outer = DECL_CONTEXT (template);
+      outer = DECL_CONTEXT (templ);
       if (outer)
 	outer = TI_ARGS (get_template_info (DECL_TEMPLATE_RESULT (outer)));
       else if (current_template_parms)
@@ -5650,21 +5650,21 @@ lookup_template_class (tree d1,
       if (outer)
 	arglist = add_to_template_args (outer, arglist);
 
-      arglist2 = coerce_template_parms (parmlist, arglist, template,
+      arglist2 = coerce_template_parms (parmlist, arglist, templ,
 					complain,
 					/*require_all_args=*/true,
 					/*use_default_args=*/true);
       if (arglist2 == error_mark_node
 	  || (!uses_template_parms (arglist2)
-	      && check_instantiated_args (template, arglist2, complain)))
+	      && check_instantiated_args (templ, arglist2, complain)))
 	POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
 
-      parm = bind_template_template_parm (TREE_TYPE (template), arglist2);
+      parm = bind_template_template_parm (TREE_TYPE (templ), arglist2);
       POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, parm);
     }
   else
     {
-      tree template_type = TREE_TYPE (template);
+      tree template_type = TREE_TYPE (templ);
       tree gen_tmpl;
       tree type_decl;
       tree found = NULL_TREE;
@@ -5672,7 +5672,7 @@ lookup_template_class (tree d1,
       int parm_depth;
       int is_partial_instantiation;
 
-      gen_tmpl = most_general_template (template);
+      gen_tmpl = most_general_template (templ);
       parmlist = DECL_TEMPLATE_PARMS (gen_tmpl);
       parm_depth = TMPL_PARMS_DEPTH (parmlist);
       arg_depth = TMPL_ARGS_DEPTH (arglist);
@@ -5692,7 +5692,7 @@ lookup_template_class (tree d1,
 	     <class U> struct S1<T>::S2'.  We must fill in the missing
 	     arguments.  */
 	  arglist
-	    = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (template)),
+	    = add_outermost_template_args (TYPE_TI_ARGS (TREE_TYPE (templ)),
 					   arglist);
 	  arg_depth = TMPL_ARGS_DEPTH (arglist);
 	}
@@ -5702,7 +5702,7 @@ lookup_template_class (tree d1,
 
       /* From here on, we're only interested in the most general
 	 template.  */
-      template = gen_tmpl;
+      templ = gen_tmpl;
 
       /* Calculate the BOUND_ARGS.  These will be the args that are
 	 actually tsubst'd into the definition to create the
@@ -5716,12 +5716,12 @@ lookup_template_class (tree d1,
 	  tree bound_args = make_tree_vec (parm_depth);
 
 	  for (i = saved_depth,
-		 t = DECL_TEMPLATE_PARMS (template);
+		 t = DECL_TEMPLATE_PARMS (templ);
 	       i > 0 && t != NULL_TREE;
 	       --i, t = TREE_CHAIN (t))
 	    {
 	      tree a = coerce_template_parms (TREE_VALUE (t),
-					      arglist, template,
+					      arglist, templ,
 					      complain,
 					      /*require_all_args=*/true,
 					      /*use_default_args=*/true);
@@ -5752,7 +5752,7 @@ lookup_template_class (tree d1,
 	arglist
 	  = coerce_template_parms (INNERMOST_TEMPLATE_PARMS (parmlist),
 				   INNERMOST_TEMPLATE_ARGS (arglist),
-				   template,
+				   templ,
 				   complain,
 				   /*require_all_args=*/true,
 				   /*use_default_args=*/true);
@@ -5774,7 +5774,7 @@ lookup_template_class (tree d1,
 	{
 	  found = template_type;
 
-	  if (!entering_scope && PRIMARY_TEMPLATE_P (template))
+	  if (!entering_scope && PRIMARY_TEMPLATE_P (templ))
 	    {
 	      tree ctx;
 
@@ -5796,7 +5796,7 @@ lookup_template_class (tree d1,
 	POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
 
       /* If we already have this specialization, return it.  */
-      found = retrieve_specialization (template, arglist,
+      found = retrieve_specialization (templ, arglist,
 				       /*class_specializations_p=*/false);
       if (found)
 	POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
@@ -5810,22 +5810,22 @@ lookup_template_class (tree d1,
       /* If the deduced arguments are invalid, then the binding
 	 failed.  */
       if (!is_partial_instantiation
-	  && check_instantiated_args (template,
+	  && check_instantiated_args (templ,
 				      INNERMOST_TEMPLATE_ARGS (arglist),
 				      complain))
 	POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, error_mark_node);
 
       if (!is_partial_instantiation
-	  && !PRIMARY_TEMPLATE_P (template)
-	  && TREE_CODE (CP_DECL_CONTEXT (template)) == NAMESPACE_DECL)
+	  && !PRIMARY_TEMPLATE_P (templ)
+	  && TREE_CODE (CP_DECL_CONTEXT (templ)) == NAMESPACE_DECL)
 	{
-	  found = xref_tag_from_type (TREE_TYPE (template),
-				      DECL_NAME (template),
+	  found = xref_tag_from_type (TREE_TYPE (templ),
+				      DECL_NAME (templ),
 				      /*tag_scope=*/ts_global);
 	  POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, found);
 	}
 
-      context = tsubst (DECL_CONTEXT (template), arglist,
+      context = tsubst (DECL_CONTEXT (templ), arglist,
 			complain, in_decl);
       if (!context)
 	context = global_namespace;
@@ -5855,7 +5855,7 @@ lookup_template_class (tree d1,
 
 	  /* A local class.  Make sure the decl gets registered properly.  */
 	  if (context == current_function_decl)
-	    pushtag (DECL_NAME (template), t, /*tag_scope=*/ts_current);
+	    pushtag (DECL_NAME (templ), t, /*tag_scope=*/ts_current);
 
 	  if (comp_template_args (CLASSTYPE_TI_ARGS (template_type), arglist))
 	    /* This instantiation is another name for the primary
@@ -5875,7 +5875,7 @@ lookup_template_class (tree d1,
 	{
 	  TYPE_CONTEXT (t) = FROB_CONTEXT (context);
 
-	  type_decl = create_implicit_typedef (DECL_NAME (template), t);
+	  type_decl = create_implicit_typedef (DECL_NAME (templ), t);
 	  DECL_CONTEXT (type_decl) = TYPE_CONTEXT (t);
 	  TYPE_STUB_DECL (t) = type_decl;
 	  DECL_SOURCE_LOCATION (type_decl)
@@ -5889,7 +5889,7 @@ lookup_template_class (tree d1,
       TREE_PROTECTED (type_decl)
 	= TREE_PROTECTED (TYPE_STUB_DECL (template_type));
       DECL_IN_SYSTEM_HEADER (type_decl)
-	= DECL_IN_SYSTEM_HEADER (template);
+	= DECL_IN_SYSTEM_HEADER (templ);
       if (CLASSTYPE_VISIBILITY_SPECIFIED (template_type))
 	{
 	  DECL_VISIBILITY_SPECIFIED (type_decl) = 1;
@@ -5900,15 +5900,15 @@ lookup_template_class (tree d1,
 	 template is the immediate parent if this is a full
 	 instantiation.  */
       if (parm_depth == 1 || is_partial_instantiation
-	  || !PRIMARY_TEMPLATE_P (template))
+	  || !PRIMARY_TEMPLATE_P (templ))
 	/* This case is easy; there are no member templates involved.  */
-	found = template;
+	found = templ;
       else
 	{
 	  /* This is a full instantiation of a member template.  Look
 	     for a partial instantiation of which this is an instance.  */
 
-	  for (found = DECL_TEMPLATE_INSTANTIATIONS (template);
+	  for (found = DECL_TEMPLATE_INSTANTIATIONS (templ);
 	       found; found = TREE_CHAIN (found))
 	    {
 	      int success;
@@ -5953,15 +5953,15 @@ lookup_template_class (tree d1,
 		 Create the partial instantiation.
 	       */
 	      TREE_VEC_LENGTH (arglist)--;
-	      found = tsubst (template, arglist, complain, NULL_TREE);
+	      found = tsubst (templ, arglist, complain, NULL_TREE);
 	      TREE_VEC_LENGTH (arglist)++;
 	    }
 	}
 
       SET_TYPE_TEMPLATE_INFO (t, tree_cons (found, arglist, NULL_TREE));
-      DECL_TEMPLATE_INSTANTIATIONS (template)
+      DECL_TEMPLATE_INSTANTIATIONS (templ)
 	= tree_cons (arglist, t,
-		     DECL_TEMPLATE_INSTANTIATIONS (template));
+		     DECL_TEMPLATE_INSTANTIATIONS (templ));
 
       if (TREE_CODE (t) == ENUMERAL_TYPE
 	  && !is_partial_instantiation)
@@ -6292,7 +6292,7 @@ static int last_template_error_tick;
 static int
 push_tinst_level (tree d)
 {
-  struct tinst_level *new;
+  struct tinst_level *new_level;
 
   if (tinst_depth >= max_tinst_depth)
     {
@@ -6312,12 +6312,12 @@ push_tinst_level (tree d)
       return 0;
     }
 
-  new = GGC_NEW (struct tinst_level);
-  new->decl = d;
-  new->locus = input_location;
-  new->in_system_header_p = in_system_header;
-  new->next = current_tinst_level;
-  current_tinst_level = new;
+  new_level = GGC_NEW (struct tinst_level);
+  new_level->decl = d;
+  new_level->locus = input_location;
+  new_level->in_system_header_p = in_system_header;
+  new_level->next = current_tinst_level;
+  current_tinst_level = new_level;
 
   ++tinst_depth;
 #ifdef GATHER_STATISTICS
@@ -6839,7 +6839,7 @@ apply_late_template_attributes (tree *decl_p, tree attributes, int attr_flags,
 tree
 instantiate_class_template (tree type)
 {
-  tree template, args, pattern, t, member;
+  tree templ, args, pattern, t, member;
   tree typedecl;
   tree pbinfo;
   tree base_list;
@@ -6853,12 +6853,12 @@ instantiate_class_template (tree type)
     return type;
 
   /* Figure out which template is being instantiated.  */
-  template = most_general_template (CLASSTYPE_TI_TEMPLATE (type));
-  gcc_assert (TREE_CODE (template) == TEMPLATE_DECL);
+  templ = most_general_template (CLASSTYPE_TI_TEMPLATE (type));
+  gcc_assert (TREE_CODE (templ) == TEMPLATE_DECL);
 
   /* Determine what specialization of the original template to
      instantiate.  */
-  t = most_specialized_class (type, template);
+  t = most_specialized_class (type, templ);
   if (t == error_mark_node)
     {
       TYPE_BEING_DEFINED (type) = 1;
@@ -6881,7 +6881,7 @@ instantiate_class_template (tree type)
     }
   else
     {
-      pattern = TREE_TYPE (template);
+      pattern = TREE_TYPE (templ);
       args = CLASSTYPE_TI_ARGS (type);
     }
 
@@ -7303,7 +7303,7 @@ instantiate_class_template (tree type)
   /* Now that the class is complete, instantiate default arguments for
      any member functions.  We don't do this earlier because the
      default arguments may reference members of the class.  */
-  if (!PRIMARY_TEMPLATE_P (template))
+  if (!PRIMARY_TEMPLATE_P (templ))
     for (t = TYPE_METHODS (type); t; t = TREE_CHAIN (t))
       if (TREE_CODE (t) == FUNCTION_DECL
 	  /* Implicitly generated member functions will not have template
@@ -10943,26 +10943,26 @@ tsubst_copy_and_build (tree t,
     case TEMPLATE_ID_EXPR:
       {
 	tree object;
-	tree template = RECUR (TREE_OPERAND (t, 0));
+	tree templ = RECUR (TREE_OPERAND (t, 0));
 	tree targs = TREE_OPERAND (t, 1);
 
 	if (targs)
 	  targs = tsubst_template_args (targs, args, complain, in_decl);
 
-	if (TREE_CODE (template) == COMPONENT_REF)
+	if (TREE_CODE (templ) == COMPONENT_REF)
 	  {
-	    object = TREE_OPERAND (template, 0);
-	    template = TREE_OPERAND (template, 1);
+	    object = TREE_OPERAND (templ, 0);
+	    templ = TREE_OPERAND (templ, 1);
 	  }
 	else
 	  object = NULL_TREE;
-	template = lookup_template_function (template, targs);
+	templ = lookup_template_function (templ, targs);
 
 	if (object)
-	  return build3 (COMPONENT_REF, TREE_TYPE (template),
-			 object, template, NULL_TREE);
+	  return build3 (COMPONENT_REF, TREE_TYPE (templ),
+			 object, templ, NULL_TREE);
 	else
-	  return baselink_for_fns (template);
+	  return baselink_for_fns (templ);
       }
 
     case INDIRECT_REF:
diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c
index b7c0a8d33b8..b288c5bbfca 100644
--- a/gcc/cp/tree.c
+++ b/gcc/cp/tree.c
@@ -2594,17 +2594,17 @@ stabilize_expr (tree exp, tree* initp)
   return exp;
 }
 
-/* Add NEW, an expression whose value we don't care about, after the
+/* Add NEW_EXPR, an expression whose value we don't care about, after the
    similar expression ORIG.  */
 
 tree
-add_stmt_to_compound (tree orig, tree new)
+add_stmt_to_compound (tree orig, tree new_expr)
 {
-  if (!new || !TREE_SIDE_EFFECTS (new))
+  if (!new_expr || !TREE_SIDE_EFFECTS (new_expr))
     return orig;
   if (!orig || !TREE_SIDE_EFFECTS (orig))
-    return new;
-  return build2 (COMPOUND_EXPR, void_type_node, orig, new);
+    return new_expr;
+  return build2 (COMPOUND_EXPR, void_type_node, orig, new_expr);
 }
 
 /* Like stabilize_expr, but for a call whose arguments we want to
diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
index 409f34068d4..ad297106a6e 100644
--- a/gcc/cp/typeck.c
+++ b/gcc/cp/typeck.c
@@ -2315,10 +2315,10 @@ finish_class_member_access_expr (tree object, tree name, bool template_p,
 
       if (is_template_id)
 	{
-	  tree template = member;
+	  tree templ = member;
 
-	  if (BASELINK_P (template))
-	    template = lookup_template_function (template, template_args);
+	  if (BASELINK_P (templ))
+	    templ = lookup_template_function (templ, template_args);
 	  else
 	    {
 	      if (complain & tf_error)