This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[patch] cp/*.[ch]: Fix comment typos.
- From: Kazu Hirata <kazu at cs dot umass dot edu>
- To: gcc-patches at gcc dot gnu dot org
- Date: Fri, 04 Jul 2003 23:02:12 -0400 (EDT)
- Subject: [patch] cp/*.[ch]: Fix comment typos.
Hi,
Attached is a patch to fix comment typos. Committed as obvious.
Kazu Hirata
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.
Index: call.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cp/call.c,v
retrieving revision 1.399
diff -u -r1.399 call.c
--- call.c 4 Jul 2003 05:05:13 -0000 1.399
+++ call.c 5 Jul 2003 02:50:01 -0000
@@ -1169,7 +1169,7 @@
-- 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 @@
{
/* [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 @@
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 @@
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);
Index: class.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cp/class.c,v
retrieving revision 1.547
diff -u -r1.547 class.c
--- class.c 3 Jul 2003 18:13:43 -0000 1.547
+++ class.c 5 Jul 2003 02:50:05 -0000
@@ -7813,13 +7813,13 @@
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. */
Index: cp-tree.h
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cp/cp-tree.h,v
retrieving revision 1.866
diff -u -r1.866 cp-tree.h
--- cp-tree.h 4 Jul 2003 01:55:50 -0000 1.866
+++ cp-tree.h 5 Jul 2003 02:50:08 -0000
@@ -1873,7 +1873,7 @@
(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 @@
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 @@
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 @@
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. */
Index: cvt.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cp/cvt.c,v
retrieving revision 1.139
diff -u -r1.139 cvt.c
--- cvt.c 4 Jul 2003 05:05:14 -0000 1.139
+++ cvt.c 5 Jul 2003 02:50:08 -0000
@@ -638,7 +638,7 @@
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. */
Index: decl2.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cp/decl2.c,v
retrieving revision 1.640
diff -u -r1.640 decl2.c
--- decl2.c 4 Jul 2003 05:05:14 -0000 1.640
+++ decl2.c 5 Jul 2003 02:50:11 -0000
@@ -1996,7 +1996,7 @@
/* 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";
Index: decl.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cp/decl.c,v
retrieving revision 1.1078
diff -u -r1.1078 decl.c
--- decl.c 3 Jul 2003 16:10:50 -0000 1.1078
+++ decl.c 5 Jul 2003 02:50:17 -0000
@@ -3756,7 +3756,7 @@
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 @@
/* 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 @@
/* 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);
Index: init.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cp/init.c,v
retrieving revision 1.326
diff -u -r1.326 init.c
--- init.c 4 Jul 2003 05:05:14 -0000 1.326
+++ init.c 5 Jul 2003 02:50:19 -0000
@@ -2067,7 +2067,7 @@
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
Index: mangle.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cp/mangle.c,v
retrieving revision 1.80
diff -u -r1.80 mangle.c
--- mangle.c 3 Jul 2003 18:13:44 -0000 1.80
+++ mangle.c 5 Jul 2003 02:50:20 -0000
@@ -319,7 +319,7 @@
/* 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 @@
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)
Index: parser.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cp/parser.c,v
retrieving revision 1.73
diff -u -r1.73 parser.c
--- parser.c 5 Jul 2003 00:23:52 -0000 1.73
+++ parser.c 5 Jul 2003 02:50:26 -0000
@@ -89,7 +89,7 @@
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 @@
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 @@
/* 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 @@
__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 @@
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 @@
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 @@
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 @@
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 @@
/* 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 @@
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 @@
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 @@
}
/* 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 @@
__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 @@
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 @@
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 @@
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 @@
{
/* 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 @@
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_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 @@
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 @@
{
/* 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
/* 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 @@
/* 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 @@
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_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 @@
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. */
Index: pt.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cp/pt.c,v
retrieving revision 1.712
diff -u -r1.712 pt.c
--- pt.c 3 Jul 2003 13:16:01 -0000 1.712
+++ pt.c 5 Jul 2003 02:50:32 -0000
@@ -6277,7 +6277,7 @@
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 @@
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 @@
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 @@
/* 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 @@
(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.
Index: search.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cp/search.c,v
retrieving revision 1.267
diff -u -r1.267 search.c
--- search.c 26 Jun 2003 00:07:49 -0000 1.267
+++ search.c 5 Jul 2003 02:50:33 -0000
@@ -1554,7 +1554,7 @@
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 @@
}
/* 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. */
Index: semantics.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cp/semantics.c,v
retrieving revision 1.318
diff -u -r1.318 semantics.c
--- semantics.c 4 Jul 2003 05:05:15 -0000 1.318
+++ semantics.c 5 Jul 2003 02:50:34 -0000
@@ -2289,7 +2289,7 @@
/* 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);
Index: tree.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cp/tree.c,v
retrieving revision 1.333
diff -u -r1.333 tree.c
--- tree.c 4 Jul 2003 05:05:15 -0000 1.333
+++ tree.c 5 Jul 2003 02:50:35 -0000
@@ -547,7 +547,7 @@
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
Index: typeck.c
===================================================================
RCS file: /cvs/gcc/gcc/gcc/cp/typeck.c,v
retrieving revision 1.471
diff -u -r1.471 typeck.c
--- typeck.c 4 Jul 2003 05:05:15 -0000 1.471
+++ typeck.c 5 Jul 2003 02:50:38 -0000
@@ -729,9 +729,9 @@
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 @@
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 @@
}
/* 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)