call.c: Fix comment formatting.

	* call.c: Fix comment formatting.
	* class.c: Likewise.
	* cxx-pretty-print.c: Likewise.
	* init.c: Likewise.
	* parser.c: Likewise.
	* pt.c: Likewise.
	* semantics.c: Likewise.
	* tree.c: Likewise.
	* typeck.c: Likewise.
	* typeck2.c: Likewise.

From-SVN: r72828

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index ba2ee1a2acf5f8d278252357e37056f45073d1e5..5096f74d4f1a30fd6f1f861e598fb5c02c6c0962 100644 (file)
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,16 @@
+2003-10-22  Kazu Hirata  <kazu@cs.umass.edu>
+
+       * call.c: Fix comment formatting.
+       * class.c: Likewise.
+       * cxx-pretty-print.c: Likewise.
+       * init.c: Likewise.
+       * parser.c: Likewise.
+       * pt.c: Likewise.
+       * semantics.c: Likewise.
+       * tree.c: Likewise.
+       * typeck.c: Likewise.
+       * typeck2.c: Likewise.
+
 2003-10-21  Mark Mitchell  <mark@codesourcery.com>
 
        PR c++/11962

diff --git a/gcc/cp/call.c b/gcc/cp/call.c
index 508f760ad2ae4a61ad77f0e804e0feef75e7f89f..e7bbd22fc452f69c7a8dc1e85e5fa3d882e8a6bf 100644 (file)
--- a/gcc/cp/call.c
+++ b/gcc/cp/call.c
@@ -619,7 +619,7 @@ standard_conversion (tree to, tree from, tree expr)
   else if (fromref || (expr && lvalue_p (expr)))
     conv = build_conv (RVALUE_CONV, from, conv);
 
-   /* Allow conversion between `__complex__' data types  */
+   /* Allow conversion between `__complex__' data types.  */
   if (tcode == COMPLEX_TYPE && fcode == COMPLEX_TYPE)
     {
       /* The standard conversion sequence to convert FROM to TO is

diff --git a/gcc/cp/class.c b/gcc/cp/class.c
index d8b0e29e632c54f496a77697a812f74657924725..da9a1250830e5c855c8443d79ed852dfcf070041 100644 (file)
--- a/gcc/cp/class.c
+++ b/gcc/cp/class.c
@@ -6051,7 +6051,7 @@ instantiate_type (tree lhstype, tree rhs, tsubst_flags_t flags)
 
        if (addr != error_mark_node
            && TREE_SIDE_EFFECTS (TREE_OPERAND (rhs, 0)))
-         /* Do not lose object's side effects. */
+         /* Do not lose object's side effects.  */
          addr = build (COMPOUND_EXPR, TREE_TYPE (addr),
                        TREE_OPERAND (rhs, 0), addr);
        return addr;

diff --git a/gcc/cp/cxx-pretty-print.c b/gcc/cp/cxx-pretty-print.c
index e368e9a33f409746585a07e35be14d62af0edbae..ca8c603c0e3f9818f10049169ef173ed91f43992 100644 (file)
--- a/gcc/cp/cxx-pretty-print.c
+++ b/gcc/cp/cxx-pretty-print.c
@@ -91,7 +91,7 @@ pp_cxx_colon_colon (cxx_pretty_printer *pp)
 }
 
 
-/* Expressions. */
+/* Expressions.  */
 
 static inline bool
 is_destructor_name (tree name)
@@ -1584,7 +1584,7 @@ pp_cxx_canonical_template_parameter (cxx_pretty_printer *pp, tree parm)
 {
   const enum tree_code code = TREE_CODE (parm);
 
-  /* Brings type template parameters to the canonical forms  */
+  /* Brings type template parameters to the canonical forms.  */
   if (code == TEMPLATE_TYPE_PARM || code == TEMPLATE_TEMPLATE_PARM
       || code == BOUND_TEMPLATE_TEMPLATE_PARM)
     parm = TEMPLATE_TYPE_PARM_INDEX (parm);

diff --git a/gcc/cp/init.c b/gcc/cp/init.c
index 68406965496736d167098ca276b9a5494db37afb..735215377a3b6f02d59f6361e065b1ea4f42ff58 100644 (file)
--- a/gcc/cp/init.c
+++ b/gcc/cp/init.c
@@ -2713,7 +2713,7 @@ build_vec_init (tree base, tree maxindex, tree init, int from_array)
 
   stmt_expr = finish_init_stmts (is_global, stmt_expr, compound_stmt);
 
-  /* Now convert make the result have the correct type. */
+  /* Now convert make the result have the correct type.  */
   atype = build_pointer_type (atype);
   stmt_expr = build1 (NOP_EXPR, atype, stmt_expr);
   stmt_expr = build_indirect_ref (stmt_expr, NULL);

diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
index b6416e81834d5d3de679c2a57cb5a07a066e5a32..5a0c96ebf9ebf79f1ba271e061c062237bbccdfe 100644 (file)
--- a/gcc/cp/parser.c
+++ b/gcc/cp/parser.c
@@ -1054,7 +1054,7 @@ typedef enum cp_parser_declarator_kind
   CP_PARSER_DECLARATOR_ABSTRACT,
   /* We want a named declarator.  */
   CP_PARSER_DECLARATOR_NAMED,
-  /* We don't mind, but the name must be an unqualified-id  */
+  /* We don't mind, but the name must be an unqualified-id.  */
   CP_PARSER_DECLARATOR_EITHER
 } cp_parser_declarator_kind;
 
@@ -1260,7 +1260,7 @@ typedef struct cp_parser GTY(())
   unsigned num_template_parameter_lists;
 } cp_parser;
 
-/* The type of a function that parses some kind of expression  */
+/* The type of a function that parses some kind of expression.  */
 typedef tree (*cp_parser_expression_fn) (cp_parser *);
 
 /* Prototypes.  */
@@ -5294,7 +5294,7 @@ cp_parser_expression_statement (cp_parser* parser, bool in_statement_expr_p)
   tree statement = NULL_TREE;
 
   /* If the next token is a ';', then there is no expression
-     statement. */
+     statement.  */
   if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON))
     statement = cp_parser_expression (parser);
   
@@ -7735,7 +7735,7 @@ cp_parser_template_name (cp_parser* parser,
      template-argument
      template-argument-list , template-argument
 
-   Returns a TREE_VEC containing the arguments.   */
+   Returns a TREE_VEC containing the arguments.  */
 
 static tree
 cp_parser_template_argument_list (cp_parser* parser)
@@ -7751,7 +7751,7 @@ cp_parser_template_argument_list (cp_parser* parser)
       tree argument;
 
       if (n_args)
-       /* Consume the comma. */
+       /* Consume the comma.  */
        cp_lexer_consume_token (parser->lexer);
       
       /* Parse the template-argument.  */
@@ -7864,7 +7864,7 @@ cp_parser_template_argument (cp_parser* parser)
 
      -- the address of an object or function with external linkage...
 
-     -- a pointer to member... */
+     -- a pointer to member...  */
   /* Look for a non-type template parameter.  */
   if (cp_lexer_next_token_is (parser->lexer, CPP_NAME))
     {
@@ -7941,7 +7941,7 @@ cp_parser_template_argument (cp_parser* parser)
       cp_parser_error (parser, "invalid non-type template argument");
       return error_mark_node;
     }
-  /* The argument must be a constant-expression. */
+  /* The argument must be a constant-expression.  */
   argument = cp_parser_constant_expression (parser, 
                                            /*allow_non_constant_p=*/false,
                                            /*non_constant_p=*/NULL);
@@ -8306,7 +8306,7 @@ cp_parser_simple_type_specifier (cp_parser* parser, cp_parser_flags flags,
 
        /* Consume the `typeof' token.  */
        cp_lexer_consume_token (parser->lexer);
-       /* Parse the operand to `typeof'  */
+       /* Parse the operand to `typeof'.  */
        operand = cp_parser_sizeof_operand (parser, RID_TYPEOF);
        /* If it is not already a TYPE, take its type.  */
        if (!TYPE_P (operand))
@@ -12045,7 +12045,7 @@ cp_parser_member_declaration (cp_parser* parser)
                                               CPP_SEMICOLON))
            {
              cp_parser_error (parser, "expected `;'");
-             /* Skip tokens until we find a `;'  */
+             /* Skip tokens until we find a `;'.  */
              cp_parser_skip_to_end_of_statement (parser);
 
              break;

diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index 3470193d1898617333e4b221a539e7efd1d8e364..0b2be7a57d66653efc64ed3ceed83b45af9cd4a1 100644 (file)
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -3631,7 +3631,7 @@ coerce_template_parms (tree parms,
       if (i < nargs)
        arg = TREE_VEC_ELT (inner_args, i);
       else if (require_all_arguments)
-       /* There must be a default arg in this case. */
+       /* There must be a default arg in this case.  */
        arg = tsubst_template_arg (TREE_PURPOSE (parm), new_args,
                                   complain, in_decl);
       else
@@ -7045,7 +7045,7 @@ tsubst_baselink (tree baselink, tree object_type,
        class, rather than the instantiated class.  
 
        In addition, lookups that were not ambiguous before may be
-       ambiguous now.  Therefore, we perform the lookup again. */
+       ambiguous now.  Therefore, we perform the lookup again.  */
     qualifying_scope = BINFO_TYPE (BASELINK_ACCESS_BINFO (baselink));
     fns = BASELINK_FUNCTIONS (baselink);
     if (TREE_CODE (fns) == TEMPLATE_ID_EXPR)
@@ -7902,7 +7902,7 @@ tsubst_copy_and_build (tree t,
     {
     case USING_DECL:
       t = DECL_NAME (t);
-      /* Fallthrough. */
+      /* Fallthrough.  */
     case IDENTIFIER_NODE:
       {
        tree decl;
@@ -11383,7 +11383,7 @@ dependent_type_p_r (tree type)
   if (TREE_CODE (type) == BOUND_TEMPLATE_TEMPLATE_PARM)
     return true;
   /* ... or any of the template arguments is a dependent type or
-       an expression that is type-dependent or value-dependent.   */
+       an expression that is type-dependent or value-dependent.  */
   else if (CLASS_TYPE_P (type) && CLASSTYPE_TEMPLATE_INFO (type)
           && (any_dependent_template_arguments_p 
               (INNERMOST_TEMPLATE_ARGS (CLASSTYPE_TI_ARGS (type)))))

diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c
index dc8635ba309fd8799dbb9d095d7b5fd096ff5717..bdbf8ef3a4232c001b5adefab6157bb7f34d96af 100644 (file)
--- a/gcc/cp/semantics.c
+++ b/gcc/cp/semantics.c
@@ -1009,7 +1009,7 @@ begin_compound_stmt (bool has_no_scope)
   return r;
 }
 
-/* Finish a compound-statement, which is given by COMPOUND_STMT. */
+/* Finish a compound-statement, which is given by COMPOUND_STMT.  */
 
 tree
 finish_compound_stmt (tree compound_stmt)

diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c
index b9d37f53a8537638f17aefd5c20b5bd6144fc88f..bfcf741563be7e341ce78ecfe0b187030d973447 100644 (file)
--- a/gcc/cp/tree.c
+++ b/gcc/cp/tree.c
@@ -1353,7 +1353,7 @@ build_min_non_dep (enum tree_code code, tree non_dep, ...)
 
   if (code == COMPOUND_EXPR && TREE_CODE (non_dep) != COMPOUND_EXPR)
     /* This should not be considered a COMPOUND_EXPR, because it
-       resolves to an overload. */
+       resolves to an overload.  */
     COMPOUND_EXPR_OVERLOADED (t) = 1;
   
   va_end (p);

diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
index e469a5ace7e5a7e3e764a312bd6e7862050a8710..26c6f2c33a63c240c410c6bbb20f51670ed693fe 100644 (file)
--- a/gcc/cp/typeck.c
+++ b/gcc/cp/typeck.c
@@ -4302,7 +4302,7 @@ build_x_conditional_expr (tree ifexp, tree op1, tree op2)
 }
 \f
 /* Given a list of expressions, return a compound expression
-   that performs them all and returns the value of the last of them. */
+   that performs them all and returns the value of the last of them.  */
 
 tree build_x_compound_expr_from_list (tree list, const char *msg)
 {
@@ -4348,7 +4348,7 @@ build_x_compound_expr (tree op1, tree op2)
   return result;
 }
 
-/* Build a compound expression. */
+/* Build a compound expression.  */
 
 tree
 build_compound_expr (tree lhs, tree rhs)
@@ -4754,7 +4754,7 @@ build_c_cast (tree type, tree expr)
     {
       tree t = build_min (CAST_EXPR, type,
                          tree_cons (NULL_TREE, value, NULL_TREE));
-      /* We don't know if it will or will not have side effects. */
+      /* We don't know if it will or will not have side effects.  */
       TREE_SIDE_EFFECTS (t) = 1;
       return t;
     }

diff --git a/gcc/cp/typeck2.c b/gcc/cp/typeck2.c
index 28d876d0433079efac6d41dbd1fc728637a686b2..859fc26f63bb985d3f7929cf0d63f3d73e618b95 100644 (file)
--- a/gcc/cp/typeck2.c
+++ b/gcc/cp/typeck2.c
@@ -1025,7 +1025,7 @@ build_x_arrow (tree expr)
       if (processing_template_decl)
        {
          expr = build_min_non_dep (ARROW_EXPR, last_rval, orig_expr);
-         /* It will be dereferenced. */
+         /* It will be dereferenced.  */
          TREE_TYPE (expr) = TREE_TYPE (TREE_TYPE (last_rval));
          return expr;
        }