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

15 files changed, 82 insertions, 65 deletions

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 8776631..768fe65 100644
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,20 @@
+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
diff --git a/gcc/cp/call.c b/gcc/cp/call.c
index e8a54dc..2ae1319 100644
--- a/gcc/cp/call.c
+++ b/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);
diff --git a/gcc/cp/class.c b/gcc/cp/class.c
index 978e844..a699ed0 100644
--- a/gcc/cp/class.c
+++ b/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.  */
 
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 1620015..a8955f8 100644
--- a/gcc/cp/cp-tree.h
+++ b/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.  */
 
diff --git a/gcc/cp/cvt.c b/gcc/cp/cvt.c
index 24a3416..008ff4b 100644
--- a/gcc/cp/cvt.c
+++ b/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.  */
diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
index 219c659..9b1cdee 100644
--- a/gcc/cp/decl.c
+++ b/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);
diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c
index 78e84ca..2227164 100644
--- a/gcc/cp/decl2.c
+++ b/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";
diff --git a/gcc/cp/init.c b/gcc/cp/init.c
index e1a19b1..3d4d81b 100644
--- a/gcc/cp/init.c
+++ b/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
diff --git a/gcc/cp/mangle.c b/gcc/cp/mangle.c
index 27f5c7f..48ad68b 100644
--- a/gcc/cp/mangle.c
+++ b/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)
diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
index 1f48466..7d42ea4 100644
--- a/gcc/cp/parser.c
+++ b/gcc/cp/parser.c
@@ -89,7 +89,7 @@ typedef struct cp_token GTY (())
    complete.)  
 
    This somewhat ungainly data structure (as opposed to, say, a
-   variable-length array), is used due to contraints imposed by the
+   variable-length array), is used due to constraints imposed by the
    current garbage-collection methodology.  If it is made more
    flexible, we could perhaps simplify the data structures involved.  */
 
@@ -1291,7 +1291,7 @@ static cp_parser *cp_parser_new
    Those that return `tree' will return the error_mark_node (rather
    than NULL_TREE) if a parse error occurs, unless otherwise noted.
    Sometimes, they will return an ordinary node if error-recovery was
-   attempted, even though a parse error occurrred.  So, to check
+   attempted, even though a parse error occurred.  So, to check
    whether or not a parse error occurred, you should always use
    cp_parser_error_occurred.  If the construct is optional (indicated
    either by an `_opt' in the name of the function that does the
@@ -2169,7 +2169,7 @@ cp_parser_new (void)
   /* Local variable names are not forbidden.  */
   parser->local_variables_forbidden_p = false;
 
-  /* We are not procesing an `extern "C"' declaration.  */
+  /* We are not processing an `extern "C"' declaration.  */
   parser->in_unbraced_linkage_specification_p = false;
 
   /* We are not processing a declarator.  */
@@ -2399,7 +2399,7 @@ cp_parser_primary_expression (cp_parser *parser,
 	     __func__ are the names of variables -- but they are
 	     treated specially.  Therefore, they are handled here,
 	     rather than relying on the generic id-expression logic
-	     below.  Gramatically, these names are id-expressions.  
+	     below.  Grammatically, these names are id-expressions.  
 
 	     Consume the token.  */
 	  token = cp_lexer_consume_token (parser->lexer);
@@ -4115,7 +4115,7 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p)
 		return cp_parser_non_constant_expression ("an increment");
 	      parser->non_constant_expression_p = true;
 	    }
-	  /* Generate a reprsentation for the complete expression.  */
+	  /* Generate a representation for the complete expression.  */
 	  postfix_expression 
 	    = finish_increment_expr (postfix_expression, 
 				     POSTINCREMENT_EXPR);
@@ -4133,7 +4133,7 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p)
 		return cp_parser_non_constant_expression ("a decrement");
 	      parser->non_constant_expression_p = true;
 	    }
-	  /* Generate a reprsentation for the complete expression.  */
+	  /* Generate a representation for the complete expression.  */
 	  postfix_expression 
 	    = finish_increment_expr (postfix_expression, 
 				     POSTDECREMENT_EXPR);
@@ -4283,7 +4283,7 @@ cp_parser_pseudo_destructor_name (cp_parser* parser,
    ADDRESS_P is true iff the unary-expression is appearing as the
    operand of the `&' operator.
 
-   Returns a representation of the expresion.  */
+   Returns a representation of the expression.  */
 
 static tree
 cp_parser_unary_expression (cp_parser *parser, bool address_p)
@@ -4723,7 +4723,7 @@ cp_parser_direct_new_declarator (cp_parser* parser)
    new-initializer:
      ( expression-list [opt] )
 
-   Returns a reprsentation of the expression-list.  If there is no
+   Returns a representation of the expression-list.  If there is no
    expression-list, VOID_ZERO_NODE is returned.  */
 
 static tree
@@ -5134,7 +5134,7 @@ cp_parser_logical_and_expression (cp_parser* parser)
 /* Parse a logical-or-expression.
 
    logical-or-expression:
-     logical-and-expresion
+     logical-and-expression
      logical-or-expression || logical-and-expression
 
    Returns a representation of the expression.  */
@@ -5273,7 +5273,7 @@ cp_parser_assignment_expression (cp_parser* parser)
 		    return cp_parser_non_constant_expression ("an assignment");
 		  parser->non_constant_expression_p = true;
 		}
-	      /* Build the asignment expression.  */
+	      /* Build the assignment expression.  */
 	      expr = build_x_modify_expr (expr, 
 					  assignment_operator, 
 					  rhs);
@@ -6055,7 +6055,7 @@ static void
 cp_parser_for_init_statement (cp_parser* parser)
 {
   /* If the next token is a `;', then we have an empty
-     expression-statement.  Gramatically, this is also a
+     expression-statement.  Grammatically, this is also a
      simple-declaration, but an invalid one, because it does not
      declare anything.  Therefore, if we did not handle this case
      specially, we would issue an error message about an invalid
@@ -6268,7 +6268,7 @@ cp_parser_declaration_seq_opt (cp_parser* parser)
 	}
 
       /* The C lexer modifies PENDING_LANG_CHANGE when it wants the
-	 parser to enter or exit implict `extern "C"' blocks.  */
+	 parser to enter or exit implicit `extern "C"' blocks.  */
       while (pending_lang_change > 0)
 	{
 	  push_lang_context (lang_name_c);
@@ -6390,7 +6390,7 @@ cp_parser_declaration (cp_parser* parser)
      __extension__ block-declaration 
      label-declaration
 
-   If STATEMENT_P is TRUE, then this block-declaration is ocurring as
+   If STATEMENT_P is TRUE, then this block-declaration is occurring as
    part of a declaration-statement.  */
 
 static void
@@ -6464,7 +6464,7 @@ cp_parser_block_declaration (cp_parser *parser,
      init-declarator
      init-declarator-list , init-declarator 
 
-   If FUNCTION_DEFINTION_ALLOWED_P is TRUE, then we also recognize a
+   If FUNCTION_DEFINITION_ALLOWED_P is TRUE, then we also recognize a
    function-definition as a simple-declaration.   */
 
 static void
@@ -6624,7 +6624,7 @@ cp_parser_simple_declaration (cp_parser* parser,
    Returns a TREE_LIST, giving the decl-specifiers in the order they
    appear in the source code.  The TREE_VALUE of each node is the
    decl-specifier.  For a keyword (such as `auto' or `friend'), the
-   TREE_VALUE is simply the correspoding TREE_IDENTIFIER.  For the
+   TREE_VALUE is simply the corresponding TREE_IDENTIFIER.  For the
    representation of a type-specifier, see cp_parser_type_specifier.  
 
    If there are attributes, they will be stored in *ATTRIBUTES,
@@ -7168,7 +7168,7 @@ cp_parser_mem_initializer_list (cp_parser* parser)
    GNU extension:
   
    mem-initializer:
-     ( expresion-list [opt] )
+     ( expression-list [opt] )
 
    Returns a TREE_LIST.  The TREE_PURPOSE is the TYPE (for a base
    class) or FIELD_DECL (for a non-static data member) to initialize;
@@ -7731,7 +7731,7 @@ cp_parser_type_parameter (cp_parser* parser)
 	  {
 	    /* Consume the `=' token.  */
 	    cp_lexer_consume_token (parser->lexer);
-	    /* Parse the default-argumen.  */
+	    /* Parse the default-argument.  */
 	    default_argument = cp_parser_type_id (parser);
 	  }
 	else
@@ -8360,7 +8360,7 @@ cp_parser_explicit_specialization (cp_parser* parser)
 
    Returns a representation of the type-specifier.  If the
    type-specifier is a keyword (like `int' or `const', or
-   `__complex__') then the correspoding IDENTIFIER_NODE is returned.
+   `__complex__') then the corresponding IDENTIFIER_NODE is returned.
    For a class-specifier, enum-specifier, or elaborated-type-specifier
    a TREE_TYPE is returned; otherwise, a TYPE_DECL is returned.
 
@@ -9288,7 +9288,7 @@ cp_parser_using_directive (cp_parser* parser)
   cp_parser_require_keyword (parser, RID_NAMESPACE, "`namespace'");
   /* Look for the optional `::' operator.  */
   cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false);
-  /* And the optional nested-name-sepcifier.  */
+  /* And the optional nested-name-specifier.  */
   cp_parser_nested_name_specifier_opt (parser,
 				       /*typename_keyword_p=*/false,
 				       /*check_dependency_p=*/true,
@@ -9723,12 +9723,12 @@ cp_parser_init_declarator (cp_parser* parser,
      
    Returns a representation of the declarator.  If the declarator has
    the form `* declarator', then an INDIRECT_REF is returned, whose
-   only operand is the sub-declarator.  Analagously, `& declarator' is
+   only operand is the sub-declarator.  Analogously, `& declarator' is
    represented as an ADDR_EXPR.  For `X::* declarator', a SCOPE_REF is
    used.  The first operand is the TYPE for `X'.  The second operand
    is an INDIRECT_REF whose operand is the sub-declarator.
 
-   Otherwise, the reprsentation is as for a direct-declarator.
+   Otherwise, the representation is as for a direct-declarator.
 
    (It would be better to define a structure type to represent
    declarators, rather than abusing `tree' nodes to represent
@@ -9879,13 +9879,13 @@ cp_parser_direct_declarator (cp_parser* parser,
 	{
 	  /* This is either a parameter-declaration-clause, or a
   	     parenthesized declarator. When we know we are parsing a
-  	     named declarator, it must be a paranthesized declarator
+  	     named declarator, it must be a parenthesized declarator
   	     if FIRST is true. For instance, `(int)' is a
   	     parameter-declaration-clause, with an omitted
   	     direct-abstract-declarator. But `((*))', is a
   	     parenthesized abstract declarator. Finally, when T is a
   	     template parameter `(T)' is a
-  	     paremeter-declaration-clause, and not a parenthesized
+  	     parameter-declaration-clause, and not a parenthesized
   	     named declarator.
 	     
 	     We first try and parse a parameter-declaration-clause,
@@ -9912,7 +9912,7 @@ cp_parser_direct_declarator (cp_parser* parser,
 	     The former is a function-declaration; the latter is a
 	     variable initialization.  
 
-	     Thus again, we try a parameter-declation-clause, and if
+	     Thus again, we try a parameter-declaration-clause, and if
 	     that fails, we back out and return.  */
 
 	  if (!first || dcl_kind != CP_PARSER_DECLARATOR_NAMED)
@@ -9935,7 +9935,7 @@ cp_parser_direct_declarator (cp_parser* parser,
 	      params = cp_parser_parameter_declaration_clause (parser);
 
 	      /* If all went well, parse the cv-qualifier-seq and the
-	     	 exception-specfication.  */
+	     	 exception-specification.  */
 	      if (cp_parser_parse_definitely (parser))
 		{
 		  tree cv_qualifiers;
@@ -10580,7 +10580,7 @@ cp_parser_parameter_declaration_list (cp_parser* parser)
       parameter 
 	= cp_parser_parameter_declaration (parser, /*template_parm_p=*/false);
 
-      /* If a parse error ocurred parsing the parameter declaration,
+      /* If a parse error occurred parsing the parameter declaration,
 	 then the entire parameter-declaration-list is erroneous.  */
       if (parameter == error_mark_node)
 	{
@@ -10787,7 +10787,7 @@ cp_parser_parameter_declaration (cp_parser *parser,
 		     For example, if the default argument is 
 		     `X<int, double>()', we need to do name lookup to
 		     figure out whether or not `X' is a template; if
-		     so, the `,' does not end the deault argument.
+		     so, the `,' does not end the default argument.
 
 		     That is not yet done.  */
 		  break;
@@ -11120,7 +11120,7 @@ cp_parser_initializer (cp_parser* parser, bool* is_parenthesized_init)
    Returns an expression representing the initializer.  
 
    If the `assignment-expression' production is used the value
-   returned is simply a reprsentation for the expression.  
+   returned is simply a representation for the expression.  
 
    Otherwise, a CONSTRUCTOR is returned.  The CONSTRUCTOR_ELTS will be
    the elements of the initializer-list (or NULL_TREE, if the last
@@ -12027,7 +12027,7 @@ cp_parser_member_declaration (cp_parser* parser)
 	  else if (ANON_AGGR_TYPE_P (type))
 	    {
 	      /* Remove constructors and such from TYPE, now that we
-		 know it is an anoymous aggregate.  */
+		 know it is an anonymous aggregate.  */
 	      fixup_anonymous_aggr (type);
 	      /* And make the corresponding data member.  */
 	      decl = build_decl (FIELD_DECL, NULL_TREE, type);
@@ -12698,7 +12698,7 @@ cp_parser_exception_declaration (cp_parser* parser)
 /* Parse a throw-expression. 
 
    throw-expression:
-     throw assignment-expresion [opt]
+     throw assignment-expression [opt]
 
    Returns a THROW_EXPR representing the throw-expression.  */
 
@@ -13276,7 +13276,7 @@ cp_parser_lookup_name (cp_parser *parser, tree name,
 
   /* If we have resolved the name of a member declaration, check to
      see if the declaration is accessible.  When the name resolves to
-     set of overloaded functions, accesibility is checked when
+     set of overloaded functions, accessibility is checked when
      overload resolution is done.  
 
      During an explicit instantiation, access is not checked at all,
@@ -13499,7 +13499,7 @@ cp_parser_binary_expression (cp_parser* parser,
       if (token->type == CPP_GREATER
 	  && !parser->greater_than_is_operator_p)
 	break;
-      /* If we find one of the tokens we want, build the correspoding
+      /* If we find one of the tokens we want, build the corresponding
 	 tree representation.  */
       for (map_node = token_tree_map; 
 	   map_node->token_type != CPP_EOF;
@@ -14550,7 +14550,7 @@ cp_parser_abort_tentative_parse (cp_parser* parser)
   cp_parser_parse_definitely (parser);
 }
 
-/* Stop parsing tentatively.  If a parse error has ocurred, restore the
+/* Stop parsing tentatively.  If a parse error has occurred, restore the
    token stream.  Otherwise, commit to the tokens we have consumed.
    Returns true if no error occurred; false otherwise.  */
 
@@ -14560,7 +14560,7 @@ cp_parser_parse_definitely (cp_parser* parser)
   bool error_occurred;
   cp_parser_context *context;
 
-  /* Remember whether or not an error ocurred, since we are about to
+  /* Remember whether or not an error occurred, since we are about to
      destroy that information.  */
   error_occurred = cp_parser_error_occurred (parser);
   /* Remove the topmost context from the stack.  */
diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index 11f0bcd..3c4d737 100644
--- a/gcc/cp/pt.c
+++ b/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.
diff --git a/gcc/cp/search.c b/gcc/cp/search.c
index 84df080..1c27d3b 100644
--- a/gcc/cp/search.c
+++ b/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. */
 
diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c
index 3664590..b7b5d85 100644
--- a/gcc/cp/semantics.c
+++ b/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);
diff --git a/gcc/cp/tree.c b/gcc/cp/tree.c
index 9f8a119..975c396 100644
--- a/gcc/cp/tree.c
+++ b/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
diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
index 96b74fa..cd3bc10 100644
--- a/gcc/cp/typeck.c
+++ b/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)