This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[patch] cp/*.[ch]: Follow spelling conventions.
- From: Kazu Hirata <kazu at codesourcery dot com>
- To: gcc-patches at gcc dot gnu dot org
- Date: Sat, 3 Feb 2007 20:25:03 -0800
- Subject: [patch] cp/*.[ch]: Follow spelling conventions.
Hi,
Committed as obvious.
Kazu Hirata
2007-02-04 Kazu Hirata <kazu@codesourcery.com>
* class.c, cp-gimplify.c, cp-objcp-common.c, cp-tree.h, cvt.c,
decl.c, decl2.c, g++spec.c, init.c, lex.c, method.c,
name-lookup.c, parser.c, pt.c, tree.c, typeck.c, typeck2.c:
Follow spelling conventions.
Index: class.c
===================================================================
--- class.c (revision 121564)
+++ class.c (working copy)
@@ -430,8 +430,8 @@ build_simple_base_path (tree expr, tree
/* Transform `(a, b).x' into `(*(a, &b)).x', `(a ? b : c).x'
into `(*(a ? &b : &c)).x', and so on. A COND_EXPR is only
- an lvalue in the frontend; only _DECLs and _REFs are lvalues
- in the backend. */
+ an lvalue in the front end; only _DECLs and _REFs are lvalues
+ in the back end. */
temp = unary_complex_lvalue (ADDR_EXPR, expr);
if (temp)
expr = build_indirect_ref (temp, NULL);
@@ -1725,7 +1725,7 @@ finish_struct_methods (tree t)
}
/* Make BINFO's vtable have N entries, including RTTI entries,
- vbase and vcall offsets, etc. Set its type and call the backend
+ vbase and vcall offsets, etc. Set its type and call the back end
to lay it out. */
static void
@@ -4586,7 +4586,7 @@ layout_class_type (tree t, tree *virtual
tree padding;
/* We still pass things that aren't non-static data members to
- the back-end, in case it wants to do something with them. */
+ the back end, in case it wants to do something with them. */
if (TREE_CODE (field) != FIELD_DECL)
{
place_field (rli, field);
@@ -4894,7 +4894,7 @@ layout_class_type (tree t, tree *virtual
place_field (rli,
build_decl (FIELD_DECL, NULL_TREE, char_type_node));
- /* Let the back-end lay out the type. */
+ /* Let the back end lay out the type. */
finish_record_layout (rli, /*free_p=*/true);
/* Warn about bases that can't be talked about due to ambiguity. */
Index: cp-gimplify.c
===================================================================
--- cp-gimplify.c (revision 121564)
+++ cp-gimplify.c (working copy)
@@ -472,7 +472,7 @@ cp_gimplify_expr (tree *expr_p, tree *pr
break;
case THROW_EXPR:
- /* FIXME communicate throw type to backend, probably by moving
+ /* FIXME communicate throw type to back end, probably by moving
THROW_EXPR into ../tree.def. */
*expr_p = TREE_OPERAND (*expr_p, 0);
ret = GS_OK;
Index: cp-objcp-common.c
===================================================================
--- cp-objcp-common.c (revision 121564)
+++ cp-objcp-common.c (working copy)
@@ -68,7 +68,7 @@ cxx_warn_unused_global_decl (tree decl)
return true;
}
-/* Langhook for expr_size: Tell the backend that the value of an expression
+/* Langhook for expr_size: Tell the back end that the value of an expression
of non-POD class type does not include any tail padding; a derived class
might have allocated something there. */
@@ -79,7 +79,7 @@ cp_expr_size (tree exp)
if (CLASS_TYPE_P (type))
{
- /* The backend should not be interested in the size of an expression
+ /* The back end should not be interested in the size of an expression
of a type with both of these set; all copies of such types must go
through a constructor or assignment op. */
if (!TYPE_HAS_COMPLEX_INIT_REF (type)
Index: cp-tree.h
===================================================================
--- cp-tree.h (revision 121564)
+++ cp-tree.h (working copy)
@@ -345,7 +345,7 @@ struct tree_overload GTY(())
requested. */
#define BASELINK_OPTYPE(NODE) \
(TREE_CHAIN (BASELINK_CHECK (NODE)))
-/* Non-zero if this baselink was from a qualified lookup. */
+/* Nonzero if this baselink was from a qualified lookup. */
#define BASELINK_QUALIFIED_P(NODE) \
TREE_LANG_FLAG_0 (BASELINK_CHECK (NODE))
@@ -2109,7 +2109,7 @@ extern void decl_shadowed_for_var_insert
/* If non-NULL for a VAR_DECL, FUNCTION_DECL, TYPE_DECL or
TEMPLATE_DECL, the entity is either a template specialization (if
- DECL_USE_TEMPLATE is non-zero) or the abstract instance of the
+ DECL_USE_TEMPLATE is nonzero) or the abstract instance of the
template itself.
In either case, DECL_TEMPLATE_INFO is a TREE_LIST, whose
@@ -2868,7 +2868,7 @@ extern void decl_shadowed_for_var_insert
/* Returns nonzero if NODE is a primary template. */
#define PRIMARY_TEMPLATE_P(NODE) (DECL_PRIMARY_TEMPLATE (NODE) == (NODE))
-/* Non-zero iff NODE is a specialization of a template. The value
+/* Nonzero iff NODE is a specialization of a template. The value
indicates the type of specializations:
1=implicit instantiation
@@ -2892,7 +2892,7 @@ extern void decl_shadowed_for_var_insert
both O<int>::f and O<int>::I will be marked as instantiations.
- If DECL_USE_TEMPLATE is non-zero, then DECL_TEMPLATE_INFO will also
+ If DECL_USE_TEMPLATE is nonzero, then DECL_TEMPLATE_INFO will also
be non-NULL. */
#define DECL_USE_TEMPLATE(NODE) (DECL_LANG_SPECIFIC (NODE)->decl_flags.use_template)
@@ -4573,7 +4573,7 @@ extern void cp_genericize (tree);
/* -- end of C++ */
-/* In order for the format checking to accept the C++ frontend
+/* In order for the format checking to accept the C++ front end
diagnostic framework extensions, you must include this file before
toplev.h, not after. We override the definition of GCC_DIAG_STYLE
in c-common.h. */
Index: cvt.c
===================================================================
--- cvt.c (revision 121564)
+++ cvt.c (working copy)
@@ -994,7 +994,7 @@ convert_to_void (tree expr, const char *
Most of this routine is from build_reinterpret_cast.
- The backend cannot call cp_convert (what was convert) because
+ The back end cannot call cp_convert (what was convert) because
conversions to/from basetypes may involve memory references
(vbases) and adding or subtracting small values (multiple
inheritance), but it calls convert from the constant folding code
Index: decl.c
===================================================================
--- decl.c (revision 121564)
+++ decl.c (working copy)
@@ -713,7 +713,7 @@ poplevel (int keep, int reverse, int fun
/* There may be OVERLOADs (wrapped in TREE_LISTs) on the BLOCK_VARs
list if a `using' declaration put them there. The debugging
- back-ends won't understand OVERLOAD, so we remove them here.
+ back ends won't understand OVERLOAD, so we remove them here.
Because the BLOCK_VARS are (temporarily) shared with
CURRENT_BINDING_LEVEL->NAMES we must do this fixup after we have
popped all the bindings. */
@@ -3044,7 +3044,7 @@ record_builtin_java_type (const char* na
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 (tree type, const char* name)
@@ -3955,7 +3955,7 @@ start_decl (const cp_declarator *declara
if (tem == error_mark_node)
return error_mark_node;
- /* Tell the back-end to use or not use .common as appropriate. If we say
+ /* Tell the back end to use or not use .common as appropriate. If we say
-fconserve-space, we want this to save .data space, at the expense of
wrong semantics. If we say -fno-conserve-space, we want this to
produce errors about redefs; to do this we force variables into the
@@ -5582,7 +5582,7 @@ register_dtor_fn (tree decl)
/* Now, recompute the cleanup. It may contain SAVE_EXPRs that refer
to the original function, rather than the anonymous one. That
- will make the back-end think that nested functions are in use,
+ will make the back end think that nested functions are in use,
which causes confusion. */
push_deferring_access_checks (dk_no_check);
@@ -6440,7 +6440,7 @@ build_ptrmemfunc_type (tree type)
t = make_aggr_type (RECORD_TYPE);
xref_basetypes (t, NULL_TREE);
- /* Let the front-end know this is a pointer to member function... */
+ /* Let the front end know this is a pointer to member function... */
TYPE_PTRMEMFUNC_FLAG (t) = 1;
/* ... and not really an aggregate. */
SET_IS_AGGR_TYPE (t, 0);
@@ -6454,7 +6454,7 @@ build_ptrmemfunc_type (tree type)
finish_builtin_struct (t, "__ptrmemfunc_type", fields, ptr_type_node);
- /* Zap out the name so that the back-end will give us the debugging
+ /* Zap out the name so that the back end will give us the debugging
information for this anonymous RECORD_TYPE. */
TYPE_NAME (t) = NULL_TREE;
@@ -10766,7 +10766,7 @@ start_preparsed_function (tree decl1, tr
DECL_EXTERNAL (decl1) = 0;
DECL_INTERFACE_KNOWN (decl1) = 1;
/* If this function is in an interface implemented in this file,
- make sure that the backend knows to emit this function
+ make sure that the back end knows to emit this function
here. */
if (!DECL_EXTERNAL (decl1))
mark_needed (decl1);
Index: decl2.c
===================================================================
--- decl2.c (revision 121564)
+++ decl2.c (working copy)
@@ -1394,7 +1394,7 @@ import_export_class (tree ctype)
if (MULTIPLE_SYMBOL_SPACES && import_export == -1)
import_export = 0;
- /* Allow backends the chance to overrule the decision. */
+ /* Allow back ends the chance to overrule the decision. */
if (targetm.cxx.import_export_class)
import_export = targetm.cxx.import_export_class (ctype, import_export);
@@ -1446,7 +1446,7 @@ decl_needed_p (tree decl)
emitted; they may be referred to from other object files. */
if (TREE_PUBLIC (decl) && !DECL_COMDAT (decl))
return true;
- /* If this entity was used, let the back-end see it; it will decide
+ /* If this entity was used, let the back end see it; it will decide
whether or not to emit it into the object file. */
if (TREE_USED (decl)
|| (DECL_ASSEMBLER_NAME_SET_P (decl)
@@ -2922,7 +2922,7 @@ generate_ctor_and_dtor_functions_for_pri
}
/* Called via LANGHOOK_CALLGRAPH_ANALYZE_EXPR. It is supposed to mark
- decls referenced from frontend specific constructs; it will be called
+ decls referenced from front-end specific constructs; it will be called
only for language-specific tree nodes.
Here we must deal with member pointers. */
@@ -3135,7 +3135,7 @@ cp_write_global_declarations (void)
through the loop. That's because we need to know which
vtables have been referenced, and TREE_SYMBOL_REFERENCED
isn't computed until a function is finished, and written
- out. That's a deficiency in the back-end. When this is
+ out. That's a deficiency in the back end. When this is
fixed, these initialization functions could all become
inline, with resulting performance improvements. */
tree ssdf_body;
@@ -3210,7 +3210,7 @@ cp_write_global_declarations (void)
if (!DECL_SAVED_TREE (decl))
continue;
- /* We lie to the back-end, pretending that some functions
+ /* We lie to the back end, pretending that some functions
are not defined when they really are. This keeps these
functions from being put out unnecessarily. But, we must
stop lying when the functions are referenced, or if they
Index: g++spec.c
===================================================================
--- g++spec.c (revision 121564)
+++ g++spec.c (working copy)
@@ -1,4 +1,4 @@
-/* Specific flags and argument handling of the C++ front-end.
+/* Specific flags and argument handling of the C++ front end.
Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
Free Software Foundation, Inc.
Index: init.c
===================================================================
--- init.c (revision 121564)
+++ init.c (working copy)
@@ -863,7 +863,7 @@ construct_virtual_base (tree vbase, tree
confuses the sjlj exception-handling code. Therefore, we do not
create a single conditional block, but one for each
initialization. (That way the cleanup regions always begin
- in the outer block.) We trust the back-end to figure out
+ in the outer block.) We trust the back end to figure out
that the FLAG will not change across initializations, and
avoid doing multiple tests. */
flag = TREE_CHAIN (DECL_ARGUMENTS (current_function_decl));
@@ -1522,7 +1522,7 @@ integral_constant_value (tree decl)
}
/* A more relaxed version of integral_constant_value, used by the
- common C/C++ code and by the C++ front-end for optimization
+ common C/C++ code and by the C++ front end for optimization
purposes. */
tree
@@ -2478,7 +2478,7 @@ build_vec_init (tree base, tree maxindex
When copying from array to another, when the array elements have
only trivial copy constructors, we should use __builtin_memcpy
rather than generating a loop. That way, we could take advantage
- of whatever cleverness the back-end has for dealing with copies
+ of whatever cleverness the back end has for dealing with copies
of blocks of memory. */
is_global = begin_init_stmts (&stmt_expr, &compound_stmt);
Index: lex.c
===================================================================
--- lex.c (revision 121564)
+++ lex.c (working copy)
@@ -679,7 +679,7 @@ build_lang_decl (enum tree_code code, tr
}
/* Add DECL_LANG_SPECIFIC info to T. Called from build_lang_decl
- and pushdecl (for functions generated by the backend). */
+ and pushdecl (for functions generated by the back end). */
void
retrofit_lang_decl (tree t)
Index: method.c
===================================================================
--- method.c (revision 121564)
+++ method.c (working copy)
@@ -432,7 +432,7 @@ use_thunk (tree thunk_fndecl, bool emit_
DECL_RESULT (thunk_fndecl)
= build_decl (RESULT_DECL, 0, integer_type_node);
fnname = XSTR (XEXP (DECL_RTL (thunk_fndecl), 0), 0);
- /* The back-end expects DECL_INITIAL to contain a BLOCK, so we
+ /* The back end expects DECL_INITIAL to contain a BLOCK, so we
create one. */
fn_block = make_node (BLOCK);
BLOCK_VARS (fn_block) = a;
Index: name-lookup.c
===================================================================
--- name-lookup.c (revision 121564)
+++ name-lookup.c (working copy)
@@ -771,7 +771,7 @@ pushdecl_maybe_friend (tree x, bool is_f
check_template_shadow (x);
- /* If this is a function conjured up by the backend, massage it
+ /* If this is a function conjured up by the back end, massage it
so it looks friendly. */
if (DECL_NON_THUNK_FUNCTION_P (x) && ! DECL_LANG_SPECIFIC (x))
{
Index: parser.c
===================================================================
--- parser.c (revision 121564)
+++ parser.c (working copy)
@@ -14609,7 +14609,7 @@ cp_parser_function_try_block (cp_parser*
/* Look for the `try' keyword. */
if (!cp_parser_require_keyword (parser, RID_TRY, "`try'"))
return false;
- /* Let the rest of the front-end know where we are. */
+ /* Let the rest of the front end know where we are. */
try_block = begin_function_try_block (&compound_stmt);
/* Parse the function-body. */
ctor_initializer_p
@@ -17418,7 +17418,7 @@ cp_parser_objc_identifier_list (cp_parse
objc-alias-declaration:
@compatibility_alias identifier identifier ;
- This function registers the alias mapping with the Objective-C front-end.
+ This function registers the alias mapping with the Objective-C front end.
It returns nothing. */
static void
@@ -17439,7 +17439,7 @@ cp_parser_objc_alias_declaration (cp_par
@class objc-identifier-list ;
The function registers the forward declarations with the Objective-C
- front-end. It returns nothing. */
+ front end. It returns nothing. */
static void
cp_parser_objc_class_declaration (cp_parser* parser)
Index: pt.c
===================================================================
--- pt.c (revision 121564)
+++ pt.c (working copy)
@@ -1608,7 +1608,7 @@ determine_specialization (tree template_
This extension can only serve to make invalid programs valid,
so it's safe. And, there is strong anecdotal evidence that
the committee intended the partial ordering rules to apply;
- the EDG front-end has that behavior, and John Spicer claims
+ the EDG front end has that behavior, and John Spicer claims
that the committee simply forgot to delete the wording in
[temp.expl.spec]. */
tree tmpl = most_specialized_instantiation (templates);
Index: tree.c
===================================================================
--- tree.c (revision 121564)
+++ tree.c (working copy)
@@ -973,7 +973,7 @@ build_qualified_name (tree type, tree sc
return t;
}
-/* Returns non-zero if X is an expression for a (possibly overloaded)
+/* Returns nonzero if X is an expression for a (possibly overloaded)
function. If "f" is a function or function template, "f", "c->f",
"c.f", "C::f", and "f<int>" will all be considered possibly
overloaded functions. Returns 2 if the function is actually
Index: typeck.c
===================================================================
--- typeck.c (revision 121564)
+++ typeck.c (working copy)
@@ -1836,7 +1836,7 @@ build_class_member_access_expr (tree obj
/* Transform `(a, b).x' into `(*(a, &b)).x', `(a ? b : c).x' into
`(*(a ? &b : &c)).x', and so on. A COND_EXPR is only an lvalue
- in the frontend; only _DECLs and _REFs are lvalues in the backend. */
+ in the front end; only _DECLs and _REFs are lvalues in the back end. */
{
tree temp = unary_complex_lvalue (ADDR_EXPR, object);
if (temp)
@@ -5337,7 +5337,7 @@ build_reinterpret_cast_1 (tree type, tre
"target type",
intype, type);
- /* We need to strip nops here, because the frontend likes to
+ /* We need to strip nops here, because the front end likes to
create (int *)&a for array-to-pointer decay, instead of &a[0]. */
STRIP_NOPS (sexpr);
strict_aliasing_warning (intype, type, sexpr);
Index: typeck2.c
===================================================================
--- typeck2.c (revision 121564)
+++ typeck2.c (working copy)
@@ -838,7 +838,7 @@ process_init_constructor_array (tree typ
if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (type)))
{
/* If this type needs constructors run for default-initialization,
- we can't rely on the backend to do it for us, so build up
+ we can't rely on the back end to do it for us, so build up
TARGET_EXPRs. If the type in question is a class, just build
one up; if it's an array, recurse. */
if (IS_AGGR_TYPE (TREE_TYPE (type)))
@@ -925,7 +925,7 @@ process_init_constructor_record (tree ty
else if (TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (field)))
{
/* If this type needs constructors run for
- default-initialization, we can't rely on the backend to do it
+ default-initialization, we can't rely on the back end to do it
for us, so build up TARGET_EXPRs. If the type in question is
a class, just build one up; if it's an array, recurse. */
if (IS_AGGR_TYPE (TREE_TYPE (field)))