call.c: Fix comment typos.

	* call.c: Fix comment typos.
	* class.c: Likewise.
	* cp-tree.h: Likewise.
	* cvt.c: Likewise.
	* decl2.c: Likewise.
	* decl.c: Likewise.
	* init.c: Likewise.
	* mangle.c: Likewise.
	* parser.c: Likewise.
	* pt.c: Likewise.
	* search.c: Likewise.
	* semantics.c: Likewise.
	* tree.c: Likewise.
	* typeck.c: Likewise

From-SVN: r68956

gcc/cp/ChangeLog

+2003-07-04  Kazu Hirata  <kazu@cs.umass.edu>
+
+	* call.c: Fix comment typos.
+	* class.c: Likewise.
+	* cp-tree.h: Likewise.
+	* cvt.c: Likewise.
+	* decl2.c: Likewise.
+	* decl.c: Likewise.
+	* init.c: Likewise.
+	* mangle.c: Likewise.
+	* parser.c: Likewise.
+	* pt.c: Likewise.
+	* search.c: Likewise.
+	* semantics.c: Likewise.
+	* tree.c: Likewise.
+	* typeck.c: Likewise.
+
 2003-07-04  Zack Weinberg  <zack@codesourcery.com>
 
 	* parser.c (cp_lexer_read_token): No need to handle string

gcc/cp/call.c

@@ -1169,7 +1169,7 @@ reference_binding (tree rto, tree rfrom, tree expr, int flags)
 	 -- is an lvalue (but not an lvalue for a bit-field), and "cv1 T1"
 	    is reference-compatible with "cv2 T2,"
 	 
-	 the reference is bound directly to the initializer exprssion
+	 the reference is bound directly to the initializer expression
 	 lvalue.  */
       conv = build1 (IDENTITY_CONV, from, expr);
       conv = direct_reference_binding (rto, conv);
@@ -1193,7 +1193,7 @@ reference_binding (tree rto, tree rfrom, tree expr, int flags)
     {
       /* [dcl.init.ref]
 
-	 If the initializer exprsesion
+	 If the initializer expression
 
 	 -- has a class type (i.e., T2 is a class type) can be
 	    implicitly converted to an lvalue of type "cv3 T3," where
@@ -2915,7 +2915,7 @@ build_new_function_call (tree fn, tree args)
    the arguments provided.  *SIZE points to the total number of bytes
    required by the allocation, and is updated if that is changed here.
    *COOKIE_SIZE is non-NULL if a cookie should be used.  If this
-   function determins that no cookie should be used, after all,
+   function determines that no cookie should be used, after all,
    *COOKIE_SIZE is set to NULL_TREE. */
 
 tree
@@ -5254,7 +5254,7 @@ maybe_handle_implicit_object (tree *ics)
       tree reference_type;
 
       /* The `this' parameter is a pointer to a class type.  Make the
-	 implict conversion talk about a reference to that same class
+	 implicit conversion talk about a reference to that same class
 	 type.  */
       reference_type = TREE_TYPE (TREE_TYPE (*ics));
       reference_type = build_reference_type (reference_type);

gcc/cp/class.c

@@ -7813,13 +7813,13 @@ add_vcall_offset (tree orig_fn, tree binfo, vtbl_init_data *vid)
 	  vcall_offset = fold (build1 (NOP_EXPR, vtable_entry_type,
 				       vcall_offset));
 	}
-      /* Add the intiailizer to the vtable.  */
+      /* Add the initializer to the vtable.  */
       *vid->last_init = build_tree_list (NULL_TREE, vcall_offset);
       vid->last_init = &TREE_CHAIN (*vid->last_init);
     }
 }
 
-/* Return vtbl initializers for the RTTI entries coresponding to the
+/* Return vtbl initializers for the RTTI entries corresponding to the
    BINFO's vtable.  The RTTI entries should indicate the object given
    by VID->rtti_binfo.  */
 

gcc/cp/cp-tree.h

@@ -1873,7 +1873,7 @@ struct lang_decl GTY(())
   (DECL_LANG_SPECIFIC (NODE)->u.f.operator_code = (CODE))
 
 /* If NODE is an overloaded operator, then this returns the TREE_CODE
-   associcated with the overloaded operator.
+   associated with the overloaded operator.
    DECL_ASSIGNMENT_OPERATOR_P must also be checked to determine
    whether or not NODE is an assignment operator.  If NODE is not an
    overloaded operator, ERROR_MARK is returned.  Since the numerical
@@ -2637,7 +2637,7 @@ struct lang_decl GTY(())
    TREE_LIST, whose TREE_VALUE is a PARM_DECL (if the parameter is a
    non-type parameter), or a TYPE_DECL (if the parameter is a type
    parameter).  The TREE_PURPOSE is the default value, if any.  The
-   TEMPLATE_PARM_INDEX for the parameter is avilable as the
+   TEMPLATE_PARM_INDEX for the parameter is available as the
    DECL_INITIAL (for a PARM_DECL) or as the TREE_TYPE (for a
    TYPE_DECL).  */
 #define DECL_TEMPLATE_PARMS(NODE)       DECL_ARGUMENTS (NODE)
@@ -2857,7 +2857,7 @@ struct lang_decl GTY(())
    class, and hence adds the offsets. A result pointer adjusting thunk
    converts from a derived class to a base, and hence subtracts the
    offsets.  If both operations are performed, then the constant
-   adjument is performed first for this pointer adjustment and last
+   adjustment is performed first for this pointer adjustment and last
    for the result pointer adjustment.
 
    The constant adjustment is given by THUNK_FIXED_OFFSET.  If the
@@ -3380,7 +3380,7 @@ enum overload_flags { NO_SPECIAL = 0, DTOR_FLAG, OP_FLAG, TYPENAME_FLAG };
 				   derived from the first.  */
 #define COMPARE_DERIVED       2 /* Like COMPARE_BASE, but in
 				   reverse.  */
-#define COMPARE_REDECLARATION 4 /* The comparsion is being done when
+#define COMPARE_REDECLARATION 4 /* The comparison is being done when
 				   another declaration of an existing
 				   entity is seen.  */
 

gcc/cp/cvt.c

@@ -638,7 +638,7 @@ ocp_convert (tree type, tree expr, int convtype, int flags)
       if (same_type_p (type, TREE_TYPE (e)))
 	/* The call to fold will not always remove the NOP_EXPR as
 	   might be expected, since if one of the types is a typedef;
-	   the comparsion in fold is just equality of pointers, not a
+	   the comparison in fold is just equality of pointers, not a
 	   call to comptypes.  We don't call fold in this case because
 	   that can result in infinite recursion; fold will call
 	   convert, which will call ocp_convert, etc.  */

gcc/cp/decl.c

@@ -3756,7 +3756,7 @@ pushdecl (tree x)
 	  else if (TREE_CODE (t) == PARM_DECL)
 	    {
 	      if (DECL_CONTEXT (t) == NULL_TREE)
-		/* This is probaby caused by too many errors, but calling
+		/* This is probably caused by too many errors, but calling
 		   abort will say that if errors have occurred.  */
 		abort ();
 
@@ -6506,7 +6506,7 @@ builtin_function_1 (const char* name,
 
 /* Entry point for the benefit of c_common_nodes_and_builtins.
 
-   Make a defintion for a builtin function named NAME and whose data type
+   Make a definition for a builtin function named NAME and whose data type
    is TYPE.  TYPE should be a function type with argument types.  This
    function places the anticipated declaration in the global namespace
    and additionally in the std namespace if appropriate.
@@ -7300,7 +7300,7 @@ layout_var_decl (tree decl)
   /* If we haven't already layed out this declaration, do so now.
      Note that we must not call complete type for an external object
      because it's type might involve templates that we are not
-     supposed to isntantiate yet.  (And it's perfectly valid to say
+     supposed to instantiate yet.  (And it's perfectly valid to say
      `extern X x' for some incomplete type `X'.)  */
   if (!DECL_EXTERNAL (decl))
     complete_type (type);

gcc/cp/decl2.c

@@ -1996,7 +1996,7 @@ start_objects (int method_type, int initp)
 
   /* We cannot allow these functions to be elided, even if they do not
      have external linkage.  And, there's no point in deferring
-     copmilation of thes functions; they're all going to have to be
+     compilation of thes functions; they're all going to have to be
      out anyhow.  */
   current_function_cannot_inline
     = "static constructors and destructors cannot be inlined";

gcc/cp/init.c

@@ -2067,7 +2067,7 @@ build_new_1 (tree exp)
   bool placement_allocation_fn_p;
   tree args = NULL_TREE;
   /* True if the storage must be initialized, either by a constructor
-     or due to an explicit new-intiailizer.  */
+     or due to an explicit new-initializer.  */
   bool is_initialized;
   /* The address of the thing allocated, not including any cookie.  In
      particular, if an array cookie is in use, DATA_ADDR is the

gcc/cp/mangle.c

@@ -319,7 +319,7 @@ dump_substitution_candidates ()
 /* Both decls and types can be substitution candidates, but sometimes
    they refer to the same thing.  For instance, a TYPE_DECL and
    RECORD_TYPE for the same class refer to the same thing, and should
-   be treated accordinginly in substitutions.  This function returns a
+   be treated accordingly in substitutions.  This function returns a
    canonicalized tree node representing NODE that is used when adding
    and substitution candidates and finding matches.  */
 
@@ -1428,7 +1428,7 @@ write_type (tree type)
   if (write_CV_qualifiers_for_type (type) > 0)
     /* If TYPE was CV-qualified, we just wrote the qualifiers; now
        mangle the unqualified type.  The recursive call is needed here
-       since both the qualified and uqualified types are substitution
+       since both the qualified and unqualified types are substitution
        candidates.  */
     write_type (TYPE_MAIN_VARIANT (type));
   else if (TREE_CODE (type) == ARRAY_TYPE)

gcc/cp/pt.c

@@ -6277,7 +6277,7 @@ tsubst_decl (tree t, tree args, tree type, tsubst_flags_t complain)
   return r;
 }
 
-/* Substitue into the ARG_TYPES of a function type.  */
+/* Substitute into the ARG_TYPES of a function type.  */
 
 static tree
 tsubst_arg_types (tree arg_types, 
@@ -6357,7 +6357,7 @@ tsubst_function_type (tree t,
   if (return_type == error_mark_node)
     return error_mark_node;
 
-  /* Substitue the argument types.  */
+  /* Substitute the argument types.  */
   arg_types = tsubst_arg_types (TYPE_ARG_TYPES (t), args,
 				complain, in_decl); 
   if (arg_types == error_mark_node)
@@ -6868,7 +6868,7 @@ tsubst (tree t, tree args, tsubst_flags_t complain, tree in_decl)
 	if (fntype == error_mark_node)
 	  return error_mark_node;
 
-	/* Substitue the exception specification.  */
+	/* Substitute the exception specification.  */
 	raises = TYPE_RAISES_EXCEPTIONS (t);
 	if (raises)
 	  {
@@ -8318,7 +8318,7 @@ tsubst_copy_and_build (tree t,
 
 /* Verify that the instantiated ARGS are valid. For type arguments,
    make sure that the type's linkage is ok. For non-type arguments,
-   make sure they are constants if they are integral or enumarations.
+   make sure they are constants if they are integral or enumerations.
    Emit an error under control of COMPLAIN, and return TRUE on error. */
 
 static bool
@@ -10869,7 +10869,7 @@ instantiate_decl (tree d, int defer_ok)
 	     (1) D is a template static data member, for which a
 	         definition is available.
 
-	     (2) An implicit or explicit instantiation has occured.
+	     (2) An implicit or explicit instantiation has occurred.
 
 	     (3) We are not going to emit a definition of the static
 	         data member at this time.

gcc/cp/search.c

@@ -1554,7 +1554,7 @@ adjust_result_of_qualified_name_lookup (tree decl,
    type in the hierarchy, in a breadth-first preorder traversal.
    If it ever returns a non-NULL value, that value is immediately
    returned and the walk is terminated.  At each node, FN is passed a
-   BINFO indicating the path from the curently visited base-class to
+   BINFO indicating the path from the currently visited base-class to
    TYPE.  Before each base-class is walked QFN is called.  If the
    value returned is nonzero, the base-class is walked; otherwise it
    is not.  If QFN is NULL, it is treated as a function which always
@@ -2536,7 +2536,7 @@ copied_binfo (tree binfo, tree here)
 }
 
 /* BINFO is some base binfo of HERE, within some other
-   hierachy. Return the equivalent binfo, but in the hierarchy
+   hierarchy. Return the equivalent binfo, but in the hierarchy
    dominated by HERE.  This is the inverse of copied_binfo.  If BINFO
    is not a base binfo of HERE, returns NULL_TREE. */
 

gcc/cp/semantics.c

@@ -2289,7 +2289,7 @@ expand_body (tree fn)
 
   /* Save the current file name and line number.  When we expand the
      body of the function, we'll set INPUT_LOCATION so that
-     error-mesages come out in the right places.  */
+     error-messages come out in the right places.  */
   saved_loc = input_location;
   saved_function = current_function_decl;
   input_location = DECL_SOURCE_LOCATION (fn);

gcc/cp/tree.c

@@ -547,7 +547,7 @@ build_cplus_array_type (tree elt_type, tree index_type)
    via a typedef or template type argument. [dcl.ref] No such
    dispensation is provided for qualifying a function type.  [dcl.fct]
    DR 295 queries this and the proposed resolution brings it into line
-   with qualifiying a reference.  We implement the DR.  We also behave
+   with qualifying a reference.  We implement the DR.  We also behave
    in a similar manner for restricting non-pointer types.  */
  
 tree

gcc/cp/typeck.c

@@ -729,9 +729,9 @@ common_type (t1, t2)
    derived and !exact).
  
    [except.spec] "If a class X ... objects of class X or any class publicly
-   and unambigously derrived from X. Similarly, if a pointer type Y * ...
+   and unambiguously derived from X. Similarly, if a pointer type Y * ...
    exceptions of type Y * or that are pointers to any type publicly and
-   unambigously derrived from Y. Otherwise a function only allows exceptions
+   unambiguously derived from Y. Otherwise a function only allows exceptions
    that have the same type ..."
    This does not mention cv qualifiers and is different to what throw
    [except.throw] and catch [except.catch] will do. They will ignore the
@@ -3001,7 +3001,7 @@ build_template_expr (enum tree_code code, tree op0, tree op1, tree op2)
 	      type = boolean_type_node;
 	      break;
 	    case COND_EXPR:
-	      /* FIXME: Handle special rules for conditioanl
+	      /* FIXME: Handle special rules for conditional
 		 expressions.  */
 	      break;
 	    case COMPOUND_EXPR:
@@ -6181,7 +6181,7 @@ c_expand_asm_operands (tree string, tree outputs, tree inputs, tree clobbers,
 }
 
 /* If RETVAL is the address of, or a reference to, a local variable or
-   temporary give an appropraite warning.  */
+   temporary give an appropriate warning.  */
 
 static void
 maybe_warn_about_returning_address_of_local (tree retval)