decl.c: Fix comment formatting.

	* decl.c: Fix comment formatting.
	* decl2.c: Likewise.

From-SVN: r57104

gcc/cp/ChangeLog

+2002-09-13  Kazu Hirata  <kazu@cs.umass.edu>
+
+	* decl.c: Fix comment formatting.
+	* decl2.c: Likewise.
+
 2002-09-12  Kazu Hirata  <kazu@cs.umass.edu>
 
 	* call.c: Fix comment formatting.

gcc/cp/decl.c

@@ -203,7 +203,7 @@ tree cp_global_trees[CPTI_MAX];
 
 static GTY(()) tree global_type_node;
 
-/* Expect only namespace names now. */
+/* Expect only namespace names now.  */
 static int only_namespace_names;
 
 /* Used only for jumps to as-yet undefined labels, since jumps to
@@ -329,11 +329,11 @@ struct cp_binding_level GTY(())
        component_bindings.  */
     tree tags;
 
-    /* A list of USING_DECL nodes. */
+    /* A list of USING_DECL nodes.  */
     tree usings;
 
     /* A list of used namespaces. PURPOSE is the namespace,
-       VALUE the common ancestor with this binding_level's namespace. */
+       VALUE the common ancestor with this binding_level's namespace.  */
     tree using_directives;
 
     /* If this binding level is the binding level for a class, then
@@ -576,7 +576,7 @@ resume_binding_level (b)
      struct cp_binding_level *b;
 {
   /* Resuming binding levels is meant only for namespaces,
-     and those cannot nest into classes. */
+     and those cannot nest into classes.  */
   my_friendly_assert(!class_binding_level, 386);
   /* Also, resuming a non-directly nested namespace is a no-no.  */
   my_friendly_assert(b->level_chain == current_binding_level, 386);
@@ -2053,11 +2053,11 @@ print_binding_stack ()
 /* Namespace binding access routines: The namespace_bindings field of
    the identifier is polymorphic, with three possible values:
    NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
-   indicating the BINDING_VALUE of global_namespace. */
+   indicating the BINDING_VALUE of global_namespace.  */
 
 /* Check whether the a binding for the name to scope is known.
    Assumes that the bindings of the name are already a list
-   of bindings. Returns the binding found, or NULL_TREE. */
+   of bindings. Returns the binding found, or NULL_TREE.  */
 
 static tree
 find_binding (name, scope)
@@ -2075,7 +2075,7 @@ find_binding (name, scope)
       if (BINDING_SCOPE (iter) == scope)
 	{
 	  /* Move binding found to the front of the list, so
-             subsequent lookups will find it faster. */
+             subsequent lookups will find it faster.  */
 	  if (prev)
 	    {
 	      TREE_CHAIN (prev) = TREE_CHAIN (iter);
@@ -2091,7 +2091,7 @@ find_binding (name, scope)
 
 /* Always returns a binding for name in scope. If the
    namespace_bindings is not a list, convert it to one first.
-   If no binding is found, make a new one. */
+   If no binding is found, make a new one.  */
 
 tree
 binding_for_name (name, scope)
@@ -2105,14 +2105,14 @@ binding_for_name (name, scope)
 
   if (b && TREE_CODE (b) != CPLUS_BINDING)
     {
-      /* Get rid of optimization for global scope. */
+      /* Get rid of optimization for global scope.  */
       IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
       BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
       b = IDENTIFIER_NAMESPACE_BINDINGS (name);
     }
   if (b && (result = find_binding (name, scope)))
     return result;
-  /* Not found, make a new one. */
+  /* Not found, make a new one.  */
   result = make_node (CPLUS_BINDING);
   TREE_CHAIN (result) = b;
   IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
@@ -2123,7 +2123,7 @@ binding_for_name (name, scope)
 }
 
 /* Return the binding value for name in scope, considering that
-   namespace_binding may or may not be a list of CPLUS_BINDINGS. */
+   namespace_binding may or may not be a list of CPLUS_BINDINGS.  */
 
 tree
 namespace_binding (name, scope)
@@ -2144,7 +2144,7 @@ namespace_binding (name, scope)
 }
 
 /* Set the binding value for name in scope. If modifying the binding
-   of global_namespace is attempted, try to optimize it. */
+   of global_namespace is attempted, try to optimize it.  */
 
 void
 set_namespace_binding (name, scope, val)
@@ -2183,7 +2183,7 @@ push_namespace (name)
   int global = 0;
   if (!global_namespace)
     {
-      /* This must be ::. */
+      /* This must be ::.  */
       my_friendly_assert (name == get_identifier ("::"), 377);
       global = 1;
     }
@@ -2202,7 +2202,7 @@ push_namespace (name)
     }
   else
     {
-      /* Check whether this is an extended namespace definition. */
+      /* Check whether this is an extended namespace definition.  */
       d = IDENTIFIER_NAMESPACE_VALUE (name);
       if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
         {
@@ -2218,7 +2218,7 @@ push_namespace (name)
 
   if (need_new)
     {
-      /* Make a new namespace, binding the name to it. */
+      /* Make a new namespace, binding the name to it.  */
       d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
       /* The global namespace is not pushed, and the global binding
 	 level is set elsewhere.  */
@@ -2236,7 +2236,7 @@ push_namespace (name)
 
   if (implicit_use)
     do_using_directive (d);
-  /* Enter the name space. */
+  /* Enter the name space.  */
   current_namespace = d;
 }
 
@@ -2455,7 +2455,7 @@ set_identifier_type_value_with_scope (id, type, b)
   if (!b->namespace_p)
     {
       /* Shadow the marker, not the real thing, so that the marker
-	 gets restored later. */
+	 gets restored later.  */
       tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
       b->type_shadowed
 	= tree_cons (id, old_type_value, b->type_shadowed);
@@ -2464,7 +2464,7 @@ set_identifier_type_value_with_scope (id, type, b)
     {
       tree binding = binding_for_name (id, current_namespace);
       BINDING_TYPE (binding) = type;
-      /* Store marker instead of real type. */
+      /* Store marker instead of real type.  */
       type = global_type_node;
     }
   SET_IDENTIFIER_TYPE_VALUE (id, type);
@@ -2480,20 +2480,20 @@ set_identifier_type_value (id, type)
   set_identifier_type_value_with_scope (id, type, current_binding_level);
 }
 
-/* Return the type associated with id. */
+/* Return the type associated with id.  */
 
 tree
 identifier_type_value (id)
      tree id;
 {
-  /* There is no type with that name, anywhere. */
+  /* There is no type with that name, anywhere.  */
   if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
     return NULL_TREE;
-  /* This is not the type marker, but the real thing. */
+  /* This is not the type marker, but the real thing.  */
   if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
     return REAL_IDENTIFIER_TYPE_VALUE (id);
   /* Have to search for it. It must be on the global level, now.
-     Ask lookup_name not to return non-types. */
+     Ask lookup_name not to return non-types.  */
   id = lookup_name_real (id, 2, 1, 0);
   if (id)
     return TREE_TYPE (id);
@@ -2666,7 +2666,7 @@ pushtag (name, type, globalize)
 		 /* We may be defining a new type in the initializer
 		    of a static member variable. We allow this when
 		    not pedantic, and it is particularly useful for
-		    type punning via an anonymous union. */
+		    type punning via an anonymous union.  */
 		 || COMPLETE_TYPE_P (b->this_class))))
     b = b->level_chain;
 
@@ -3025,7 +3025,7 @@ duplicate_decls (newdecl, olddecl)
 	}
     }
 
-  /* Check for redeclaration and other discrepancies. */
+  /* Check for redeclaration and other discrepancies.  */
   if (TREE_CODE (olddecl) == FUNCTION_DECL
       && DECL_ARTIFICIAL (olddecl))
     {
@@ -3227,7 +3227,7 @@ duplicate_decls (newdecl, olddecl)
   else if (TREE_CODE (newdecl) == NAMESPACE_DECL
            && DECL_NAMESPACE_ALIAS (newdecl)
            && DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
-    /* Redeclaration of namespace alias, ignore it. */
+    /* Redeclaration of namespace alias, ignore it.  */
     return 1;
   else
     {
@@ -3357,9 +3357,9 @@ duplicate_decls (newdecl, olddecl)
          definition.  */
       if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
 	  && !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
-	  /* Don't warn about extern decl followed by definition. */
+	  /* Don't warn about extern decl followed by definition.  */
 	  && !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
-	  /* Don't warn about friends, let add_friend take care of it. */
+	  /* Don't warn about friends, let add_friend take care of it.  */
 	  && ! (DECL_FRIEND_P (newdecl) || DECL_FRIEND_P (olddecl)))
 	{
 	  warning ("redundant redeclaration of `%D' in same scope", newdecl);
@@ -3860,7 +3860,7 @@ pushdecl (x)
 	  else if ((DECL_EXTERN_C_FUNCTION_P (x)
 		    || DECL_FUNCTION_TEMPLATE_P (x))
 		   && is_overloaded_fn (t))
-	    /* Don't do anything just yet. */;
+	    /* Don't do anything just yet.  */;
 	  else if (t == wchar_decl_node)
 	    {
 	      if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
@@ -3931,7 +3931,7 @@ pushdecl (x)
 
       /* If declaring a type as a typedef, copy the type (unless we're
 	 at line 0), and install this TYPE_DECL as the new type's typedef
-	 name.  See the extensive comment in ../c-decl.c (pushdecl). */
+	 name.  See the extensive comment in ../c-decl.c (pushdecl).  */
       if (TREE_CODE (x) == TYPE_DECL)
 	{
 	  tree type = TREE_TYPE (x);
@@ -4301,7 +4301,7 @@ maybe_push_decl (decl)
       || (TREE_CODE (decl) != PARM_DECL
 	  && DECL_CONTEXT (decl) != NULL_TREE
 	  /* Definitions of namespace members outside their namespace are
-	     possible. */
+	     possible.  */
 	  && TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
       || (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
       || TREE_CODE (type) == UNKNOWN_TYPE
@@ -4431,11 +4431,11 @@ push_using_directive (used)
   tree ud = current_binding_level->using_directives;
   tree iter, ancestor;
 
-  /* Check if we already have this. */
+  /* Check if we already have this.  */
   if (purpose_member (used, ud) != NULL_TREE)
     return NULL_TREE;
 
-  /* Recursively add all namespaces used. */
+  /* Recursively add all namespaces used.  */
   for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
     push_using_directive (TREE_PURPOSE (iter));
 
@@ -4643,7 +4643,7 @@ redeclaration_error_message (newdecl, olddecl)
 	return 0;
 
       /* If both functions come from different namespaces, this is not
-	 a redeclaration - this is a conflict with a used function. */
+	 a redeclaration - this is a conflict with a used function.  */
       if (DECL_NAMESPACE_SCOPE_P (olddecl)
 	  && DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
 	return "`%D' conflicts with used function";
@@ -5273,7 +5273,7 @@ lookup_tag (form, name, binding_level, thislevel_only)
 	      return TREE_VALUE (tail);
 	  }
       else if (level->namespace_p)
-	/* Do namespace lookup. */
+	/* Do namespace lookup.  */
 	for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
 	  {
 	    tree old = binding_for_name (name, tail);
@@ -5402,7 +5402,7 @@ lookup_namespace_name (namespace, name)
   my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
 
   if (TREE_CODE (name) == NAMESPACE_DECL)
-    /* This happens for A::B<int> when B is a namespace. */
+    /* This happens for A::B<int> when B is a namespace.  */
     return name;
   else if (TREE_CODE (name) == TEMPLATE_DECL)
     {
@@ -5750,7 +5750,7 @@ make_unbound_class_template (context, name, complain)
   return t;
 }
 
-/* Select the right _DECL from multiple choices. */
+/* Select the right _DECL from multiple choices.  */
 
 static tree
 select_decl (binding, flags)
@@ -5762,7 +5762,7 @@ select_decl (binding, flags)
 
   if (LOOKUP_NAMESPACES_ONLY (flags))
     {
-      /* We are not interested in types. */
+      /* We are not interested in types.  */
       if (val && TREE_CODE (val) == NAMESPACE_DECL)
         return val;
       return NULL_TREE;
@@ -5774,7 +5774,7 @@ select_decl (binding, flags)
       && (!val || ((flags & LOOKUP_PREFER_TYPES)
                    && TREE_CODE (val) != TYPE_DECL)))
     val = TYPE_STUB_DECL (BINDING_TYPE (binding));
-  /* Don't return non-types if we really prefer types. */
+  /* Don't return non-types if we really prefer types.  */
   else if (val && LOOKUP_TYPES_ONLY (flags)  && TREE_CODE (val) != TYPE_DECL
 	   && (TREE_CODE (val) != TEMPLATE_DECL
 	       || !DECL_CLASS_TEMPLATE_P (val)))
@@ -5820,28 +5820,28 @@ unqualified_namespace_lookup (name, flags, spacesp)
         }
       else
         {
-          /* Initialize binding for this context. */
+          /* Initialize binding for this context.  */
           BINDING_VALUE (b) = BINDING_VALUE (val);
           BINDING_TYPE (b) = BINDING_TYPE (val);
         }
 
-      /* Add all _DECLs seen through local using-directives. */
+      /* Add all _DECLs seen through local using-directives.  */
       for (level = current_binding_level;
 	   !level->namespace_p;
 	   level = level->level_chain)
 	if (!lookup_using_namespace (name, b, level->using_directives,
                                      scope, flags, spacesp))
-	  /* Give up because of error. */
+	  /* Give up because of error.  */
 	  return error_mark_node;
 
-      /* Add all _DECLs seen through global using-directives. */
-      /* XXX local and global using lists should work equally. */
+      /* Add all _DECLs seen through global using-directives.  */
+      /* XXX local and global using lists should work equally.  */
       siter = initial;
       while (1)
 	{
 	  if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
 				       scope, flags, spacesp))
-	    /* Give up because of error. */
+	    /* Give up because of error.  */
 	    return error_mark_node;
 	  if (siter == scope) break;
 	  siter = CP_DECL_CONTEXT (siter);
@@ -6002,7 +6002,7 @@ lookup_name_real (name, prefer_type, nonclass, namespaces_only)
   int flags;
   int val_is_implicit_typename = 0;
 
-  /* Hack: copy flag set by parser, if set. */
+  /* Hack: copy flag set by parser, if set.  */
   if (only_namespace_names)
     namespaces_only = 1;
 
@@ -6015,7 +6015,7 @@ lookup_name_real (name, prefer_type, nonclass, namespaces_only)
       prefer_type = looking_for_typename;
 
       flags = lookup_flags (prefer_type, namespaces_only);
-      /* If the next thing is '<', class templates are types. */
+      /* If the next thing is '<', class templates are types.  */
       if (looking_for_template)
         flags |= LOOKUP_TEMPLATES_EXPECTED;
 
@@ -6086,7 +6086,7 @@ lookup_name_real (name, prefer_type, nonclass, namespaces_only)
   else
     {
       flags = lookup_flags (prefer_type, namespaces_only);
-      /* If we're not parsing, we need to complain. */
+      /* If we're not parsing, we need to complain.  */
       flags |= LOOKUP_COMPLAIN;
     }
 
@@ -6310,7 +6310,7 @@ record_builtin_type (rid_index, name, type)
       tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
       set_identifier_type_value (tname, NULL_TREE);
       if ((int) rid_index < (int) RID_MAX)
-	/* Built-in types live in the global namespace. */
+	/* Built-in types live in the global namespace.  */
 	SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
     }
   if (rname != NULL_TREE)
@@ -6342,12 +6342,12 @@ record_builtin_java_type (name, size)
   if (size > 0)
     type = make_signed_type (size);
   else if (size > -32)
-    { /* "__java_char" or ""__java_boolean". */
+    { /* "__java_char" or ""__java_boolean".  */
       type = make_unsigned_type (-size);
       /*if (size == -1)	TREE_SET_CODE (type, BOOLEAN_TYPE);*/
     }
   else
-    { /* "__java_float" or ""__java_double". */
+    { /* "__java_float" or ""__java_double".  */
       type = make_node (REAL_TYPE);
       TYPE_PRECISION (type) = - size;
       layout_type (type);
@@ -6357,14 +6357,14 @@ record_builtin_java_type (name, size)
 
   /* Suppress generate debug symbol entries for these types,
      since for normal C++ they are just clutter.
-     However, push_lang_context undoes this if extern "Java" is seen. */
+     However, push_lang_context undoes this if extern "Java" is seen.  */
   DECL_IGNORED_P (decl) = 1;
 
   TYPE_FOR_JAVA (type) = 1;
   return type;
 }
 
-/* Push a type into the namespace so that the back-ends ignore it. */
+/* Push a type into the namespace so that the back-ends ignore it.  */
 
 static void
 record_unknown_type (type, name)
@@ -6452,7 +6452,7 @@ cxx_init_decl_processing ()
   /* Create the global variables.  */
   push_to_top_level ();
 
-  /* Enter the global namespace. */
+  /* Enter the global namespace.  */
   my_friendly_assert (global_namespace == NULL_TREE, 375);
   push_namespace (get_identifier ("::"));
   global_namespace = current_namespace;
@@ -6637,7 +6637,7 @@ cxx_init_decl_processing ()
 
 /* Generate an initializer for a function naming variable from
    NAME. NAME may be NULL, in which case we generate a special
-   ERROR_MARK node which should be replaced later. */
+   ERROR_MARK node which should be replaced later.  */
 
 tree
 cp_fname_init (name)
@@ -6662,7 +6662,7 @@ cp_fname_init (name)
     TREE_TYPE (init) = type;
   else
     /* We don't know the value until instantiation time. Make
-       something which will be digested now, but replaced later. */
+       something which will be digested now, but replaced later.  */
     init = build (ERROR_MARK, type);
   
   return init;
@@ -6684,7 +6684,7 @@ cp_make_fname_decl (id, type_dep)
   tree init = cp_fname_init (name);
   tree decl = build_decl (VAR_DECL, id, TREE_TYPE (init));
 
-  /* As we don't push the decl here, we must set the context. */
+  /* As we don't push the decl here, we must set the context.  */
   DECL_CONTEXT (decl) = current_function_decl;
   DECL_PRETTY_FUNCTION_P (decl) = type_dep;
       
@@ -7231,11 +7231,11 @@ start_decl (declarator, declspecs, initialized, attributes, prefix_attributes)
       && context != current_namespace && TREE_CODE (decl) == VAR_DECL)
     {
       /* When parsing the initializer, lookup should use the object's
-	 namespace. */
+	 namespace.  */
       push_decl_namespace (context);
     }
 
-  /* We are only interested in class contexts, later. */
+  /* We are only interested in class contexts, later.  */
   if (context && TREE_CODE (context) == NAMESPACE_DECL)
     context = NULL_TREE;
 
@@ -8141,7 +8141,7 @@ cp_finish_decl (decl, init, asmspec_tree, flags)
       && DECL_CONTEXT (decl) != current_namespace
       && init)
     {
-      /* Leave the namespace of the object. */
+      /* Leave the namespace of the object.  */
       pop_decl_namespace ();
     }
 
@@ -8874,7 +8874,7 @@ grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
     type = build_exception_variant (type, raises);
 
   decl = build_lang_decl (FUNCTION_DECL, declarator, type);
-  /* Propagate volatile out from type to decl. */
+  /* Propagate volatile out from type to decl.  */
   if (TYPE_VOLATILE (type))
     TREE_THIS_VOLATILE (decl) = 1;
 
@@ -9025,7 +9025,7 @@ grokfndecl (ctype, type, declarator, orig_declarator, virtualp, flags, quals,
               /* Due to bison parser ickiness, we will have already looked
                  up an operator_name or PFUNCNAME within the current class
                  (see template_id in parse.y). If the current class contains
-                 such a name, we'll get a COMPONENT_REF here. Undo that. */
+                 such a name, we'll get a COMPONENT_REF here. Undo that.  */
 
               my_friendly_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
                                   == current_class_type, 20001120);
@@ -9400,7 +9400,7 @@ compute_array_index_type (name, size)
 					  size, integer_one_node));
     }
 
-  /* The size might be the result of a cast. */
+  /* The size might be the result of a cast.  */
   STRIP_TYPE_NOPS (size);
 
   /* It might be a const variable or enumeration constant.  */
@@ -9805,7 +9805,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
 	    break;
 
 	  case ADDR_EXPR:	/* C++ reference declaration */
-	    /* Fall through. */
+	    /* Fall through.  */
 	  case ARRAY_REF:
 	  case INDIRECT_REF:
 	    ctype = NULL_TREE;
@@ -9893,7 +9893,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
 		    dname = DECL_NAME (get_first_fn (dname));
 		  }
 	      }
-	  /* Fall through. */
+	  /* Fall through.  */
 
 	  case IDENTIFIER_NODE:
 	    if (TREE_CODE (decl) == IDENTIFIER_NODE)
@@ -10692,7 +10692,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
 
 	    type = create_array_type_for_decl (dname, type, size);
 
-	    /* VLAs never work as fields. */
+	    /* VLAs never work as fields.  */
 	    if (decl_context == FIELD && !processing_template_decl
 		&& TREE_CODE (type) == ARRAY_TYPE
 		&& TYPE_DOMAIN (type) != NULL_TREE
@@ -10700,7 +10700,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
 	      {
 		error ("size of member `%D' is not constant", dname);
 		/* Proceed with arbitrary constant size, so that offset
-		   computations don't get confused. */
+		   computations don't get confused.  */
 		type = create_array_type_for_decl (dname, TREE_TYPE (type),
 						   integer_one_node);
 	      }
@@ -11009,7 +11009,7 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
 	      /* This needs to be here, in case we are called
 		 multiple times.  */ ;
 	    else if (TREE_COMPLEXITY (declarator) == -1)
-	      /* Namespace member. */
+	      /* Namespace member.  */
 	      pop_decl_namespace ();
 	    else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
 	      /* Don't fall out into global scope. Hides real bug? --eichin */ ;
@@ -12168,7 +12168,7 @@ grokparms (first_parm)
 	      TREE_TYPE (decl) = type;
 	    }
 	  else if (abstract_virtuals_error (decl, type))
-	    any_error = 1;  /* Seems like a good idea. */
+	    any_error = 1;  /* Seems like a good idea.  */
 	  else if (POINTER_TYPE_P (type))
 	    {
 	      /* [dcl.fct]/6, parameter types cannot contain pointers
@@ -12531,7 +12531,7 @@ grok_op_properties (decl, friendp)
 	}
 
       if (operator_code == CALL_EXPR)
-	return;			/* No restrictions on args. */
+	return;			/* No restrictions on args.  */
 
       if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
 	{
@@ -12795,7 +12795,7 @@ xref_tag (enum tag_types tag_code, tree name, tree attributes,
 		    TYPE_IDENTIFIER (t));
 
       /* We need to remove the class scope binding for the
-         TYPENAME_TYPE as otherwise poplevel_class gets confused. */
+         TYPENAME_TYPE as otherwise poplevel_class gets confused.  */
       for (shadowed = b->class_shadowed;
 	   shadowed;
 	   shadowed = TREE_CHAIN (shadowed))
@@ -13356,7 +13356,7 @@ build_enumerator (name, value, enumtype)
 
 	  if (TYPE_VALUES (enumtype))
 	    {
-	      /* The next value is the previous value ... */
+	      /* The next value is the previous value ...  */
 	      prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
 	      /* ... plus one.  */
 	      value = cp_build_binary_op (PLUS_EXPR,
@@ -13406,7 +13406,7 @@ build_enumerator (name, value, enumtype)
       initializing value.
 
     In finish_enum we will reset the type.  Of course, if we're
-    processing a template, there may be no value.   */
+    processing a template, there may be no value.  */
   type = value ? TREE_TYPE (value) : NULL_TREE;
 
   if (context && context == current_class_type)
@@ -13715,7 +13715,7 @@ start_function (declspecs, declarator, attrs, flags)
 	decl1 = pushdecl (decl1);
       else
 	{
-	  /* We need to set the DECL_CONTEXT. */
+	  /* We need to set the DECL_CONTEXT.  */
 	  if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
 	    DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
 	  /* And make sure we have enough default args.  */

gcc/cp/decl2.c

@@ -117,7 +117,7 @@ int at_eof;
 tree static_ctors;
 tree static_dtors;
 
-/* The :: namespace. */
+/* The :: namespace.  */
 
 tree global_namespace;
 
@@ -580,7 +580,7 @@ check_member_template (tmpl)
       if (current_function_decl)
 	/* 14.5.2.2 [temp.mem]
 	   
-	   A local class shall not have member templates. */
+	   A local class shall not have member templates.  */
 	error ("invalid declaration of member template `%#D' in local class",
 		  decl);
       
@@ -603,7 +603,7 @@ check_member_template (tmpl)
     error ("template declaration of `%#D'", decl);
 }
 
-/* Return true iff TYPE is a valid Java parameter or return type. */
+/* Return true iff TYPE is a valid Java parameter or return type.  */
 
 static int
 acceptable_java_type (type)
@@ -1370,7 +1370,7 @@ finish_anon_union (anon_union_decl)
   int static_p = TREE_STATIC (anon_union_decl);
   int external_p = DECL_EXTERNAL (anon_union_decl);
 
-  /* The VAR_DECL's context is the same as the TYPE's context. */
+  /* The VAR_DECL's context is the same as the TYPE's context.  */
   DECL_CONTEXT (anon_union_decl) = DECL_CONTEXT (TYPE_NAME (type));
   
   if (TYPE_FIELDS (type) == NULL_TREE)
@@ -1611,7 +1611,7 @@ maybe_make_one_only (decl)
      one.  However, that's not actually the case in SVR4; a strong definition
      after a weak one is an error.  Also, not making explicit
      instantiations one_only means that we can end up with two copies of
-     some template instantiations. */
+     some template instantiations.  */
   if (! flag_weak)
     return;
 
@@ -1981,7 +1981,7 @@ import_export_tinfo (decl, type, is_in_library)
       DECL_COMDAT (decl) = 1;
     }
 
-  /* Now override some cases. */
+  /* Now override some cases.  */
   if (flag_weak)
     DECL_COMDAT (decl) = 1;
   else if (is_in_library)
@@ -2031,7 +2031,7 @@ get_guard (decl)
       guard_type = long_long_integer_type_node;
       guard = build_decl (VAR_DECL, sname, guard_type);
       
-      /* The guard should have the same linkage as what it guards. */
+      /* The guard should have the same linkage as what it guards.  */
       TREE_PUBLIC (guard) = TREE_PUBLIC (decl);
       TREE_STATIC (guard) = TREE_STATIC (decl);
       DECL_COMMON (guard) = DECL_COMMON (decl);
@@ -2275,7 +2275,7 @@ start_static_storage_duration_function ()
       VARRAY_TREE_INIT (ssdf_decls, 32, "ssdf_decls");
 
       /* Take this opportunity to initialize the map from priority
-	 numbers to information about that priority level. */
+	 numbers to information about that priority level.  */
       priority_info_map = splay_tree_new (splay_tree_compare_ints,
 					  /*delete_key_fn=*/0,
 					  /*delete_value_fn=*/
@@ -2868,7 +2868,7 @@ finish_file ()
 	 This is done in a separate for cycle, because if some deferred
 	 function is contained in another deferred function later in
 	 deferred_fns varray, rest_of_compilation would skip this
-	 function and we really cannot expand the same function twice. */
+	 function and we really cannot expand the same function twice.  */
       for (i = 0; i < deferred_fns_used; ++i)
 	{
 	  tree decl = VARRAY_TREE (deferred_fns, i);
@@ -2972,7 +2972,7 @@ finish_file ()
   finish_repo ();
 
   /* The entire file is now complete.  If requested, dump everything
-     to a file.   */
+     to a file.  */
   {
     int flags;
     FILE *stream = dump_begin (TDI_all, &flags);
@@ -3317,7 +3317,7 @@ build_expr_from_tree (t)
               && (!current_class_type
                   || !lookup_member (current_class_type, id, 0, 0)))
             {
-              /* Do Koenig lookup if there are no class members. */
+              /* Do Koenig lookup if there are no class members.  */
               name = do_identifier (id, 0, args);
             }
           else if (TREE_CODE (name) == TEMPLATE_ID_EXPR
@@ -3588,7 +3588,7 @@ finish_decl_parsing (decl)
     }
 }
 
-/* Return 1 if root encloses child. */
+/* Return 1 if root encloses child.  */
 
 static int
 is_namespace_ancestor (root, child)
@@ -3605,7 +3605,7 @@ is_namespace_ancestor (root, child)
   
 
 /* Return the namespace that is the common ancestor 
-   of two given namespaces. */
+   of two given namespaces.  */
 
 tree
 namespace_ancestor (ns1, ns2)
@@ -3626,38 +3626,38 @@ add_using_namespace (user, used, indirect)
      int indirect;
 {
   tree t;
-  /* Using oneself is a no-op. */
+  /* Using oneself is a no-op.  */
   if (user == used)
     return;
   my_friendly_assert (TREE_CODE (user) == NAMESPACE_DECL, 380);
   my_friendly_assert (TREE_CODE (used) == NAMESPACE_DECL, 380);
-  /* Check if we already have this. */
+  /* Check if we already have this.  */
   t = purpose_member (used, DECL_NAMESPACE_USING (user));
   if (t != NULL_TREE)
     {
       if (!indirect)
-	/* Promote to direct usage. */
+	/* Promote to direct usage.  */
 	TREE_INDIRECT_USING (t) = 0;
       return;
     }
 
-  /* Add used to the user's using list. */
+  /* Add used to the user's using list.  */
   DECL_NAMESPACE_USING (user) 
     = tree_cons (used, namespace_ancestor (user, used), 
 		 DECL_NAMESPACE_USING (user));
 
   TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
 
-  /* Add user to the used's users list. */
+  /* Add user to the used's users list.  */
   DECL_NAMESPACE_USERS (used)
     = tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
 
-  /* Recursively add all namespaces used. */
+  /* Recursively add all namespaces used.  */
   for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
     /* indirect usage */
     add_using_namespace (user, TREE_PURPOSE (t), 1);
 
-  /* Tell everyone using us about the new used namespaces. */
+  /* Tell everyone using us about the new used namespaces.  */
   for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
     add_using_namespace (TREE_PURPOSE (t), used, 1);
 }
@@ -3717,14 +3717,14 @@ ambiguous_decl (name, old, new, flags)
 {
   tree val, type;
   my_friendly_assert (old != NULL_TREE, 393);
-  /* Copy the value. */
+  /* Copy the value.  */
   val = BINDING_VALUE (new);
   if (val)
     switch (TREE_CODE (val))
       {
       case TEMPLATE_DECL:
         /* If we expect types or namespaces, and not templates,
-           or this is not a template class. */
+           or this is not a template class.  */
         if (LOOKUP_QUALIFIERS_ONLY (flags)
             && !DECL_CLASS_TEMPLATE_P (val))
           val = NULL_TREE;
@@ -3759,7 +3759,7 @@ ambiguous_decl (name, old, new, flags)
 	}
       else
 	{
-	  /* Some declarations are functions, some are not. */
+	  /* Some declarations are functions, some are not.  */
           if (flags & LOOKUP_COMPLAIN)
             {
 	      /* If we've already given this error for this lookup,
@@ -3776,7 +3776,7 @@ ambiguous_decl (name, old, new, flags)
 	  BINDING_VALUE (old) = error_mark_node;
 	}
     }
-  /* ... and copy the type. */
+  /* ... and copy the type.  */
   type = BINDING_TYPE (new);
   if (LOOKUP_NAMESPACES_ONLY (flags))
     type = NULL_TREE;
@@ -3799,7 +3799,7 @@ ambiguous_decl (name, old, new, flags)
    We are currently looking for names in namespace SCOPE, so we
    look through USINGS for using-directives of namespaces
    which have SCOPE as a common ancestor with the current scope.
-   Returns zero on errors. */
+   Returns zero on errors.  */
 
 int
 lookup_using_namespace (name, val, usings, scope, flags, spacesp)
@@ -3810,7 +3810,7 @@ lookup_using_namespace (name, val, usings, scope, flags, spacesp)
   tree iter;
   tree val1;
   /* Iterate over all used namespaces in current, searching for using
-     directives of scope. */
+     directives of scope.  */
   for (iter = usings; iter; iter = TREE_CHAIN (iter))
     if (TREE_VALUE (iter) == scope)
       {
@@ -3818,7 +3818,7 @@ lookup_using_namespace (name, val, usings, scope, flags, spacesp)
 	  *spacesp = tree_cons (TREE_PURPOSE (iter), NULL_TREE,
 				*spacesp);
 	val1 = binding_for_name (name, TREE_PURPOSE (iter));
-	/* Resolve ambiguities. */
+	/* Resolve ambiguities.  */
 	val = ambiguous_decl (name, val, val1, flags);
       }
   return BINDING_VALUE (val) != error_mark_node;
@@ -3827,7 +3827,7 @@ lookup_using_namespace (name, val, usings, scope, flags, spacesp)
 /* [namespace.qual]
    Accepts the NAME to lookup and its qualifying SCOPE.
    Returns the name/type pair found into the CPLUS_BINDING RESULT,
-   or 0 on error. */
+   or 0 on error.  */
 
 int
 qualified_lookup_using_namespace (name, scope, result, flags)
@@ -3836,9 +3836,9 @@ qualified_lookup_using_namespace (name, scope, result, flags)
      tree result;
      int flags;
 {
-  /* Maintain a list of namespaces visited... */
+  /* Maintain a list of namespaces visited...  */
   tree seen = NULL_TREE;
-  /* ... and a list of namespace yet to see. */
+  /* ... and a list of namespace yet to see.  */
   tree todo = NULL_TREE;
   tree usings;
   /* Look through namespace aliases.  */
@@ -3849,10 +3849,10 @@ qualified_lookup_using_namespace (name, scope, result, flags)
       result = ambiguous_decl (name, result,
                                binding_for_name (name, scope), flags);
       if (!BINDING_VALUE (result) && !BINDING_TYPE (result))
-	/* Consider using directives. */
+	/* Consider using directives.  */
 	for (usings = DECL_NAMESPACE_USING (scope); usings;
 	     usings = TREE_CHAIN (usings))
-	  /* If this was a real directive, and we have not seen it. */
+	  /* If this was a real directive, and we have not seen it.  */
 	  if (!TREE_INDIRECT_USING (usings)
 	      && !purpose_member (TREE_PURPOSE (usings), seen))
 	    todo = tree_cons (TREE_PURPOSE (usings), NULL_TREE, todo);
@@ -3862,7 +3862,7 @@ qualified_lookup_using_namespace (name, scope, result, flags)
 	  todo = TREE_CHAIN (todo);
 	}
       else
-	scope = NULL_TREE; /* If there never was a todo list. */
+	scope = NULL_TREE; /* If there never was a todo list.  */
     }
   return result != error_mark_node;
 }
@@ -3870,7 +3870,7 @@ qualified_lookup_using_namespace (name, scope, result, flags)
 /* [namespace.memdef]/2 */
 
 /* Set the context of a declaration to scope. Complain if we are not
-   outside scope. */
+   outside scope.  */
 
 void
 set_decl_namespace (decl, scope, friendp)
@@ -3880,7 +3880,7 @@ set_decl_namespace (decl, scope, friendp)
 {
   tree old;
   
-  /* Get rid of namespace aliases. */
+  /* Get rid of namespace aliases.  */
   scope = ORIGINAL_NAMESPACE (scope);
   
   /* It is ok for friends to be qualified in parallel space.  */
@@ -3890,10 +3890,10 @@ set_decl_namespace (decl, scope, friendp)
   DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
   if (scope != current_namespace)
     {
-      /* See whether this has been declared in the namespace. */
+      /* See whether this has been declared in the namespace.  */
       old = namespace_binding (DECL_NAME (decl), scope);
       if (!old)
-	/* No old declaration at all. */
+	/* No old declaration at all.  */
 	goto complain;
       /* A template can be explicitly specialized in any namespace.  */
       if (processing_explicit_instantiation)
@@ -3903,7 +3903,7 @@ set_decl_namespace (decl, scope, friendp)
 	   since it can't check for the correct constness at this
 	   point. pushdecl will find those errors later.  */
 	return;
-      /* Since decl is a function, old should contain a function decl. */
+      /* Since decl is a function, old should contain a function decl.  */
       if (!is_overloaded_fn (old))
 	goto complain;
       if (processing_template_decl || processing_specialization)
@@ -3923,7 +3923,7 @@ set_decl_namespace (decl, scope, friendp)
 	    decl, scope);
 } 
 
-/* Compute the namespace where a declaration is defined. */
+/* Compute the namespace where a declaration is defined.  */
 
 static tree
 decl_namespace (decl)
@@ -3944,13 +3944,13 @@ decl_namespace (decl)
   return global_namespace;
 }
 
-/* Return the namespace where the current declaration is declared. */
+/* Return the namespace where the current declaration is declared.  */
 
 tree
 current_decl_namespace ()
 {
   tree result;
-  /* If we have been pushed into a different namespace, use it. */
+  /* If we have been pushed into a different namespace, use it.  */
   if (decl_namespace_list)
     return TREE_PURPOSE (decl_namespace_list);
 
@@ -3963,7 +3963,7 @@ current_decl_namespace ()
   return result;
 }
 
-/* Temporarily set the namespace for the current declaration. */
+/* Temporarily set the namespace for the current declaration.  */
 
 void
 push_decl_namespace (decl)
@@ -3981,7 +3981,7 @@ pop_decl_namespace ()
   decl_namespace_list = TREE_CHAIN (decl_namespace_list);
 }
 
-/* Enter a class or namespace scope. */
+/* Enter a class or namespace scope.  */
 
 void
 push_scope (t)
@@ -3993,7 +3993,7 @@ push_scope (t)
     pushclass (t, 2);
 }
 
-/* Leave scope pushed by push_scope. */
+/* Leave scope pushed by push_scope.  */
 
 void
 pop_scope (t)
@@ -4039,7 +4039,7 @@ add_function (k, fn)
      total number of functions being compared, which should usually be the
      case.  */
 
-  /* We must find only functions, or exactly one non-function. */
+  /* We must find only functions, or exactly one non-function.  */
   if (!k->functions) 
     k->functions = fn;
   else if (is_overloaded_fn (k->functions) && is_overloaded_fn (fn))
@@ -4153,19 +4153,19 @@ arg_assoc_class (k, type)
   if (arg_assoc_namespace (k, context))
     return 1;
   
-  /* Process baseclasses. */
+  /* Process baseclasses.  */
   for (i = 0; i < CLASSTYPE_N_BASECLASSES (type); i++)
     if (arg_assoc_class (k, TYPE_BINFO_BASETYPE (type, i)))
       return 1;
   
-  /* Process friends. */
+  /* Process friends.  */
   for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list; 
        list = TREE_CHAIN (list))
     if (k->name == TREE_PURPOSE (list))
       for (friends = TREE_VALUE (list); friends; 
 	   friends = TREE_CHAIN (friends))
 	/* Only interested in global functions with potentially hidden
-           (i.e. unqualified) declarations. */
+           (i.e. unqualified) declarations.  */
 	if (TREE_PURPOSE (friends) == error_mark_node && TREE_VALUE (friends)
 	    && decl_namespace (TREE_VALUE (friends)) == context)
 	  if (add_function (k, TREE_VALUE (friends)))
@@ -4212,7 +4212,7 @@ arg_assoc_type (k, type)
     case ENUMERAL_TYPE:
       return arg_assoc_namespace (k, decl_namespace (TYPE_MAIN_DECL (type)));
     case OFFSET_TYPE:
-      /* Pointer to member: associate class type and value type. */
+      /* Pointer to member: associate class type and value type.  */
       if (arg_assoc_type (k, TYPE_OFFSET_BASETYPE (type)))
 	return 1;
       return arg_assoc_type (k, TREE_TYPE (type));
@@ -4220,10 +4220,10 @@ arg_assoc_type (k, type)
       /* The basetype is referenced in the first arg type, so just
 	 fall through.  */
     case FUNCTION_TYPE:
-      /* Associate the parameter types. */
+      /* Associate the parameter types.  */
       if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
 	return 1;
-      /* Associate the return type. */
+      /* Associate the return type.  */
       return arg_assoc_type (k, TREE_TYPE (type));
     case TEMPLATE_TYPE_PARM:
     case BOUND_TEMPLATE_TEMPLATE_PARM:
@@ -4332,7 +4332,7 @@ arg_assoc (k, n)
 }
 
 /* Performs Koenig lookup depending on arguments, where fns
-   are the functions found in normal lookup. */
+   are the functions found in normal lookup.  */
 
 tree
 lookup_arg_dependent (name, fns, args)
@@ -4360,7 +4360,7 @@ lookup_arg_dependent (name, fns, args)
   return k.functions;
 }
 
-/* Process a namespace-alias declaration. */
+/* Process a namespace-alias declaration.  */
 
 void
 do_namespace_alias (alias, namespace)
@@ -4368,21 +4368,21 @@ do_namespace_alias (alias, namespace)
 {
   if (TREE_CODE (namespace) != NAMESPACE_DECL)
     {
-      /* The parser did not find it, so it's not there. */
+      /* The parser did not find it, so it's not there.  */
       error ("unknown namespace `%D'", namespace);
       return;
     }
 
   namespace = ORIGINAL_NAMESPACE (namespace);
 
-  /* Build the alias. */
+  /* Build the alias.  */
   alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);     
   DECL_NAMESPACE_ALIAS (alias) = namespace;
   pushdecl (alias);
 }
 
 /* Check a non-member using-declaration. Return the name and scope
-   being used, and the USING_DECL, or NULL_TREE on failure. */
+   being used, and the USING_DECL, or NULL_TREE on failure.  */
 
 static tree
 validate_nonmember_using_decl (decl, scope, name)
@@ -4435,11 +4435,11 @@ validate_nonmember_using_decl (decl, scope, name)
     abort ();
   if (DECL_P (*name))
     *name = DECL_NAME (*name);
-  /* Make a USING_DECL. */
+  /* Make a USING_DECL.  */
   return push_using_decl (*scope, *name);
 }
 
-/* Process local and global using-declarations. */
+/* Process local and global using-declarations.  */
 
 static void
 do_nonmember_using_decl (scope, name, oldval, oldtype, newval, newtype)
@@ -4461,7 +4461,7 @@ do_nonmember_using_decl (scope, name, oldval, oldtype, newval, newtype)
       return;
     }
 
-  /* Check for using functions. */
+  /* Check for using functions.  */
   if (BINDING_VALUE (decls) && is_overloaded_fn (BINDING_VALUE (decls)))
     {
       tree tmp, tmp1;
@@ -4541,7 +4541,7 @@ do_nonmember_using_decl (scope, name, oldval, oldtype, newval, newtype)
     }
 }
 
-/* Process a using-declaration not appearing in class or local scope. */
+/* Process a using-declaration not appearing in class or local scope.  */
 
 void
 do_toplevel_using_decl (decl)
@@ -4561,7 +4561,7 @@ do_toplevel_using_decl (decl)
 
   do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
 
-  /* Copy declarations found. */
+  /* Copy declarations found.  */
   if (newval)
     BINDING_VALUE (binding) = newval;
   if (newtype)
@@ -4658,7 +4658,7 @@ do_class_using_decl (decl)
   return value;
 }
 
-/* Process a using-directive. */
+/* Process a using-directive.  */
 
 void
 do_using_directive (namespace)
@@ -4672,7 +4672,7 @@ do_using_directive (namespace)
       namespace = TREE_OPERAND (namespace, 1);
   if (TREE_CODE (namespace) == IDENTIFIER_NODE)
     {
-      /* Lookup in lexer did not find a namespace. */
+      /* Lookup in lexer did not find a namespace.  */
       if (!processing_template_decl)
 	error ("namespace `%T' undeclared", namespace);
       return;