* error.c: Fix comment formatting.
* except.c: Likewise.
* expr.c: Likewise.
* friend.c: Likewise.
* g++spec.c: Likewise.
* init.c: Likewise.
* lex.c: Likewise.
* mangle.c: Likewise.
* method.c: Likewise.
* optimize.c: Likewise.
* pt.c: Likewise.
* rtti.c: Likewise.
* search.c: Likewise.
* semantics.c: Likewise.
* spew.c: Likewise.
* tree.c: Likewise.
* typeck.c: Likewise.
* typeck2.c: Likewise.
From-SVN: r57138
+2002-09-14 Kazu Hirata <kazu@cs.umass.edu>
+
+ * error.c: Fix comment formatting.
+ * except.c: Likewise.
+ * expr.c: Likewise.
+ * friend.c: Likewise.
+ * g++spec.c: Likewise.
+ * init.c: Likewise.
+ * lex.c: Likewise.
+ * mangle.c: Likewise.
+ * method.c: Likewise.
+ * optimize.c: Likewise.
+ * pt.c: Likewise.
+ * rtti.c: Likewise.
+ * search.c: Likewise.
+ * semantics.c: Likewise.
+ * spew.c: Likewise.
+ * tree.c: Likewise.
+ * typeck.c: Likewise.
+ * typeck2.c: Likewise.
+
2002-09-13 Nathan Sidwell <nathan@codesourcery.com>
* pt.c (unify, ARRAY_TYPE): Element type can be more qualified.
break;
case TEMPLATE_TEMPLATE_PARM:
- /* For parameters inside template signature. */
+ /* For parameters inside template signature. */
if (TYPE_IDENTIFIER (t))
print_tree_identifier (scratch_buffer, TYPE_IDENTIFIER (t));
else
default:
sorry_for_unsupported_tree (t);
- /* Fall through to error. */
+ /* Fall through to error. */
case ERROR_MARK:
print_identifier (scratch_buffer, "<type error>");
{
if ((flags & TFF_DECL_SPECIFIERS)
&& TREE_CODE (TREE_TYPE (t)) == TEMPLATE_TYPE_PARM)
- /* Say `class T' not just `T'. */
+ /* Say `class T' not just `T'. */
output_add_string (scratch_buffer, "class ");
dump_type (TREE_TYPE (t), flags);
nreverse(orig_parms);
if (DECL_TEMPLATE_TEMPLATE_PARM_P (t))
- /* Say `template<arg> class TT' not just `template<arg> TT'. */
+ /* Say `template<arg> class TT' not just `template<arg> TT'. */
output_add_string (scratch_buffer, "class ");
}
/* Pretty print a function decl. There are several ways we want to print a
function declaration. The TFF_ bits in FLAGS tells us how to behave.
As error can only apply the '#' flag once to give 0 and 1 for V, there
- is %D which doesn't print the throw specs, and %F which does. */
+ is %D which doesn't print the throw specs, and %F which does. */
static void
dump_function_decl (t, flags)
/* Print a parameter list. If this is for a member function, the
member object ptr (and any other hidden args) should have
- already been removed. */
+ already been removed. */
static void
dump_parameters (parmtypes, flags)
print_right_paren (scratch_buffer);
}
-/* Print an exception specification. T is the exception specification. */
+/* Print an exception specification. T is the exception specification. */
static void
dump_exception_spec (t, flags)
}
}
-/* Print out an expression E under control of FLAGS. */
+/* Print out an expression E under control of FLAGS. */
static void
dump_expr (t, flags)
}
/* Build the address of a typeinfo decl for use in the runtime
- matching field of the exception model. */
+ matching field of the exception model. */
static tree
build_eh_type_type (type)
target, tmode, modifier);
case OFFSET_REF:
- /* Offset refs should not make it through to here. */
+ /* Offset refs should not make it through to here. */
abort ();
return const0_rtx;
else
context = NULL_TREE;
- /* A namespace is not friend to anybody. */
+ /* A namespace is not friend to anybody. */
if (context && TREE_CODE (context) == NAMESPACE_DECL)
context = NULL_TREE;
A friend of a class or class template can be a function or
class template, a specialization of a function template or
class template, or an ordinary (nontemplate) function or
- class. */
+ class. */
if (!is_template_friend)
;/* ok */
else if (TREE_CODE (friend_type) == TYPENAME_TYPE)
/* This must be a local class, so pushdecl will be ok, and
insert an unqualified friend into the local scope
(rather than the containing namespace scope, which the
- next choice will do). */
+ next choice will do). */
decl = pushdecl (decl);
else
{
/* We can't use pushdecl, as we might be in a template
class specialization, and pushdecl will insert an
unqualified friend decl into the template parameter
- scope, rather than the namespace containing it. */
+ scope, rather than the namespace containing it. */
tree ns = decl_namespace_context (decl);
push_nested_namespace (ns);
*in_added_libraries = added_libraries;
}
-/* Called before linking. Returns 0 on success and -1 on failure. */
-int lang_specific_pre_link () /* Not used for C++. */
+/* Called before linking. Returns 0 on success and -1 on failure. */
+int lang_specific_pre_link () /* Not used for C++. */
{
return 0;
}
-/* Number of extra output files that lang_specific_pre_link may generate. */
-int lang_specific_extra_outfiles = 0; /* Not used for C++. */
+/* Number of extra output files that lang_specific_pre_link may generate. */
+int lang_specific_extra_outfiles = 0; /* Not used for C++. */
init = integer_zero_node;
if (TREE_CODE (type) == ENUMERAL_TYPE)
- /* We must make enumeral types the right type. */
+ /* We must make enumeral types the right type. */
init = fold (build1 (NOP_EXPR, type, init));
}
return rval;
}
-/* Given a Java class, return a decl for the corresponding java.lang.Class. */
+/* Given a Java class, return a decl for the corresponding java.lang.Class. */
tree
build_java_class_ref (type)
{
/* We will use ADDR multiple times so we must save it. */
addr = save_expr (addr);
- /* Delete the object. */
+ /* Delete the object. */
do_delete = build_builtin_delete_call (addr);
/* Otherwise, treat this like a complete object destructor
call. */
pop_lang_context ();
}
-/* Return true if d is in a global scope. */
+/* Return true if d is in a global scope. */
static int
is_global (d)
static inline const char *finish_mangling PARAMS ((void));
static tree mangle_special_for_type PARAMS ((tree, const char *));
-/* Foreign language functions. */
+/* Foreign language functions. */
static void write_java_integer_type_codes PARAMS ((tree));
#define write_char(CHAR) \
obstack_1grow (&G.name_obstack, (CHAR))
-/* Append a sized buffer to the end of the mangled representation. */
+/* Append a sized buffer to the end of the mangled representation. */
#define write_chars(CHAR, LEN) \
obstack_grow (&G.name_obstack, (CHAR), (LEN))
}
/* Now check the list of available substitutions for this mangling
- operation. */
+ operation. */
for (i = 0; i < size; ++i)
{
tree candidate = VARRAY_TREE (G.substitutions, i);
/* Write out an integral CST in decimal. Most numbers are small, and
representable in a HOST_WIDE_INT. Occasionally we'll have numbers
- bigger than that, which we must deal with. */
+ bigger than that, which we must deal with. */
static inline void
write_integer_cst (cst)
if (TREE_INT_CST_HIGH (cst) + (sign < 0))
{
/* A bignum. We do this in chunks, each of which fits in a
- HOST_WIDE_INT. */
+ HOST_WIDE_INT. */
char buffer[sizeof (HOST_WIDE_INT) * 8 * 2];
unsigned HOST_WIDE_INT chunk;
unsigned chunk_digits;
int done;
/* HOST_WIDE_INT must be at least 32 bits, so 10^9 is
- representable. */
+ representable. */
chunk = 1000000000;
chunk_digits = 9;
if (sizeof (HOST_WIDE_INT) >= 8)
{
- /* It is at least 64 bits, so 10^18 is representable. */
+ /* It is at least 64 bits, so 10^18 is representable. */
chunk_digits = 18;
chunk *= chunk;
}
write_discriminator (discriminator)
int discriminator;
{
- /* If discriminator is zero, don't write anything. Otherwise... */
+ /* If discriminator is zero, don't write anything. Otherwise... */
if (discriminator > 0)
{
write_char ('_');
code = TREE_CODE (expr);
}
- /* Handle template parameters. */
+ /* Handle template parameters. */
if (code == TEMPLATE_TYPE_PARM
|| code == TEMPLATE_TEMPLATE_PARM
|| code == BOUND_TEMPLATE_TEMPLATE_PARM
during the generation of the implicit body points at the place
where the attempt to generate the function occurs, giving the
user a hint as to why we are attempting to generate the
- function. */
+ function. */
DECL_SOURCE_LINE (fndecl) = lineno;
DECL_SOURCE_FILE (fndecl) = input_filename;
static void update_cloned_parm PARAMS ((tree, tree));
static void dump_function PARAMS ((enum tree_dump_index, tree));
-/* Optimize the body of FN. */
+/* Optimize the body of FN. */
void
optimize_function (fn)
{
DECL_ABSTRACT_ORIGIN (cloned_parm) = parm;
- /* We may have taken its address. */
+ /* We may have taken its address. */
TREE_ADDRESSABLE (cloned_parm) = TREE_ADDRESSABLE (parm);
- /* The definition might have different constness. */
+ /* The definition might have different constness. */
TREE_READONLY (cloned_parm) = TREE_READONLY (parm);
TREE_USED (cloned_parm) = TREE_USED (parm);
- /* The name may have changed from the declaration. */
+ /* The name may have changed from the declaration. */
DECL_NAME (cloned_parm) = DECL_NAME (parm);
DECL_SOURCE_LOCATION (cloned_parm) = DECL_SOURCE_LOCATION (parm);
}
DECL_NOT_REALLY_EXTERN (clone) = DECL_NOT_REALLY_EXTERN (fn);
TREE_PUBLIC (clone) = TREE_PUBLIC (fn);
- /* Adjust the parameter names and locations. */
+ /* Adjust the parameter names and locations. */
parm = DECL_ARGUMENTS (fn);
clone_parm = DECL_ARGUMENTS (clone);
/* Update the `this' parameter, which is always first. */
{
/* Update this parameter. */
update_cloned_parm (parm, clone_parm);
- /* We should only give unused information for one clone. */
+ /* We should only give unused information for one clone. */
if (!first)
TREE_USED (clone_parm) = 1;
}
return 1;
}
-/* Dump FUNCTION_DECL FN as tree dump PHASE. */
+/* Dump FUNCTION_DECL FN as tree dump PHASE. */
static void
dump_function (phase, fn)
++inline_parm_levels_used;
}
-/* Undo the effects of begin_member_template_processing. */
+/* Undo the effects of begin_member_template_processing. */
void
maybe_end_member_template_processing ()
error ("enclosing class templates are not explicitly specialized");
}
-/* We've just seen template <>. */
+/* We've just seen template <>. */
void
begin_specialization ()
}
/* Any template <>'s that we have seen thus far are not referring to a
- function specialization. */
+ function specialization. */
void
reset_specialization ()
if (fns == error_mark_node)
return error_mark_node;
- /* Check for baselinks. */
+ /* Check for baselinks. */
if (BASELINK_P (fns))
fns = BASELINK_FUNCTIONS (fns);
return error_mark_node;
}
- /* We have one, and exactly one, match. */
+ /* We have one, and exactly one, match. */
if (candidates)
{
/* It was a specialization of an ordinary member function in a
&& DECL_TEMPLATE_SPECIALIZATION (decl))
{
/* A specialization of a member template of a template
- class. */
+ class. */
SET_DECL_TEMPLATE_SPECIALIZATION (tmpl);
DECL_TEMPLATE_INFO (tmpl) = DECL_TEMPLATE_INFO (decl);
DECL_TEMPLATE_INFO (decl) = NULL_TREE;
case ENUMERAL_TYPE:
/* For a non-type template-parameter of integral or enumeration
type, integral promotions (_conv.prom_) and integral
- conversions (_conv.integral_) are applied. */
+ conversions (_conv.integral_) are applied. */
if (!INTEGRAL_TYPE_P (expr_type))
return error_mark_node;
/* Inside pushdecl_namespace_level, we will push into the
current namespace. However, the friend function should go
- into the namespace of the template. */
+ into the namespace of the template. */
ns = decl_namespace_context (new_friend);
push_nested_namespace (ns);
old_decl = pushdecl_namespace_level (new_friend);
/* The template parameters for this new template are all the
template parameters for the old template, except the
- outermost level of parameters. */
+ outermost level of parameters. */
DECL_TEMPLATE_PARMS (r)
= tsubst_template_parms (DECL_TEMPLATE_PARMS (t), args,
complain);
if (fntype == error_mark_node)
return error_mark_node;
- /* Substitue the exception specification. */
+ /* Substitue the exception specification. */
raises = TYPE_RAISES_EXCEPTIONS (t);
if (raises)
{
if (decl != error_mark_node)
{
if (TREE_CODE (decl) != TYPE_DECL)
- /* Make sure the type is instantiated now. */
+ /* Make sure the type is instantiated now. */
complete_type (TREE_TYPE (decl));
if (init)
DECL_INITIAL (decl) = error_mark_node;
tree spec = instantiate_template (DECL_CLONED_FUNCTION (tmpl), targ_ptr);
tree clone;
- /* Look for the clone. */
+ /* Look for the clone. */
for (clone = TREE_CHAIN (spec);
clone && DECL_CLONED_FUNCTION_P (clone);
clone = TREE_CHAIN (clone))
{
/* Avoid getting confused about cv-quals; don't recurse here.
Pointers to members should really be just OFFSET_TYPE, not
- this two-level nonsense... */
+ this two-level nonsense... */
parm = TREE_TYPE (parm);
arg = TREE_TYPE (arg);
/* Don't simply tsubst the function type, as that will give
duplicate warnings about poor parameter qualifications.
The function arguments are the same as the decl_arguments
- without the top level cv qualifiers. */
+ without the top level cv qualifiers. */
type = TREE_TYPE (type);
}
tsubst (type, args, tf_error | tf_warning, d);
/* Accessors for the type_info objects. We need to remember several things
about each of the type_info types. The global tree nodes such as
bltn_desc_type_node are TREE_LISTs, and these macros are used to access
- the required information. */
-/* The RECORD_TYPE of a type_info derived class. */
+ the required information. */
+/* The RECORD_TYPE of a type_info derived class. */
#define TINFO_PSEUDO_TYPE(NODE) TREE_TYPE (NODE)
/* The VAR_DECL of the vtable for the type_info derived class.
- This is only filled in at the end of the translation. */
+ This is only filled in at the end of the translation. */
#define TINFO_VTABLE_DECL(NODE) TREE_VALUE (NODE)
-/* The IDENTIFIER_NODE naming the real class. */
+/* The IDENTIFIER_NODE naming the real class. */
#define TINFO_REAL_NAME(NODE) TREE_PURPOSE (NODE)
static tree build_headof PARAMS((tree));
return NULL_TREE;
};
-/* Clear the base's dfs marks, after searching for duplicate bases. */
+/* Clear the base's dfs marks, after searching for duplicate bases. */
static tree
dfs_class_hint_unmark (binfo, data)
/* Prepend the number of bases. */
base_inits = tree_cons (NULL_TREE,
build_int_2 (nbases, 0), base_inits);
- /* Prepend the hint flags. */
+ /* Prepend the hint flags. */
base_inits = tree_cons (NULL_TREE,
build_int_2 (hint, 0), base_inits);
VA_FIXEDARG (ap, const char *, real_name);
VA_FIXEDARG (ap, int, ident);
- /* Generate the pseudo type name. */
+ /* Generate the pseudo type name. */
pseudo_name = (char *)alloca (strlen (real_name) + 30);
strcpy (pseudo_name, real_name);
strcat (pseudo_name, "_pseudo");
if (ident)
sprintf (pseudo_name + strlen (pseudo_name), "%d", ident);
- /* First field is the pseudo type_info base class. */
+ /* First field is the pseudo type_info base class. */
fields[0] = build_decl (FIELD_DECL, NULL_TREE, ti_desc_type_node);
/* Now add the derived fields. */
for (ix = 0; (field_decl = va_arg (ap, tree));)
fields[++ix] = field_decl;
- /* Create the pseudo type. */
+ /* Create the pseudo type. */
pseudo_type = make_aggr_type (RECORD_TYPE);
finish_builtin_type (pseudo_type, pseudo_name, fields, ix, ptr_type_node);
TYPE_HAS_CONSTRUCTOR (pseudo_type) = 1;
&& TREE_PUBLIC (base_binfo)
&& !TREE_VIA_VIRTUAL (base_binfo)
&& integer_zerop (BINFO_OFFSET (base_binfo)))
- /* single non-virtual public. */
+ /* single non-virtual public. */
return si_class_desc_type_node;
else
{
("__fundamental_type_info", 0,
NULL);
- /* Array, function and enum type_info. No additional fields. */
+ /* Array, function and enum type_info. No additional fields. */
ary_desc_type_node = create_pseudo_type_info
("__array_type_info", 0,
NULL);
NULL);
/* Base class internal helper. Pointer to base type, offset to base,
- flags. */
+ flags. */
{
tree fields[2];
TYPE_HAS_CONSTRUCTOR (base_desc_type_node) = 1;
}
- /* General hierarchy is created as necessary in this vector. */
+ /* General hierarchy is created as necessary in this vector. */
vmi_class_desc_type_node = make_tree_vec (10);
/* Pointer type_info. Adds two fields, qualification mask
and pointer to the pointed to type. This is really a descendant of
- __pbase_type_info. */
+ __pbase_type_info. */
ptr_desc_type_node = create_pseudo_type_info
("__pointer_type_info", 0,
build_decl (FIELD_DECL, NULL_TREE, integer_type_node),
DECL_INITIAL (decl) = var_init;
cp_finish_decl (decl, var_init, NULL_TREE, 0);
- /* cp_finish_decl will have dealt with linkage. */
+ /* cp_finish_decl will have dealt with linkage. */
/* Say we've dealt with it. */
TREE_TYPE (DECL_NAME (decl)) = NULL_TREE;
if (same_type_p (BINFO_TYPE (binfo), base))
{
/* We have found a base. Check against what we have found
- already. */
+ already. */
found = bk_same_type;
if (is_virtual)
found = bk_via_virtual;
base_access access;
base_kind *kind_ptr;
{
- tree binfo = NULL; /* The binfo we've found so far. */
+ tree binfo = NULL; /* The binfo we've found so far. */
tree t_binfo = NULL;
base_kind bk;
}
/* Look in TYPE for virtual functions overridden by FNDECL. Check both
- TYPE itself and its bases. */
+ TYPE itself and its bases. */
static int
look_for_overrides_r (type, fndecl)
}
/* If no secondary base classes matched, return the primary base, if
- there is one. */
+ there is one. */
if (CLASSTYPE_HAS_PRIMARY_BASE_P (BINFO_TYPE (main_binfo)))
return get_primary_binfo (main_binfo);
do_poplevel ();
}
-/* Generate the RTL for T, which is a TRY_BLOCK. */
+/* Generate the RTL for T, which is a TRY_BLOCK. */
static void
genrtl_try_block (t)
}
}
-/* Generate the RTL for T, which is an EH_SPEC_BLOCK. */
+/* Generate the RTL for T, which is an EH_SPEC_BLOCK. */
static void
genrtl_eh_spec_block (t)
check_handlers (TRY_HANDLERS (try_block));
}
-/* Generate the RTL for T, which is a HANDLER. */
+/* Generate the RTL for T, which is a HANDLER. */
static void
genrtl_handler (t)
add_stmt (r);
}
-/* Generate the RTL for a RETURN_INIT. */
+/* Generate the RTL for a RETURN_INIT. */
static void
genrtl_named_return_value ()
while (current_namespace != global_namespace)
pop_namespace ();
- /* Do file scope __FUNCTION__ et al. */
+ /* Do file scope __FUNCTION__ et al. */
finish_fname_decls ();
finish_file ();
if (t == error_mark_node)
return error_mark_node;
- /* Check the bases are accessible. */
+ /* Check the bases are accessible. */
decl_type_access_control (TYPE_NAME (t));
reset_type_access_control ();
struct token_chunk *last_chunk; /* End of the token list. */
short last_pos; /* Number of tokens used in the last chunk of
- TOKENS. */
+ TOKENS. */
short cur_pos; /* Current token in 'cur_chunk', when rescanning. */
struct token_chunk *cur_chunk; /* Current chunk, when rescanning. */
static GTY(()) tree defarg_fns;
/* current default parameter */
static GTY(()) tree defarg_parm;
-/* list of unprocessed fns met during current fn. */
+/* list of unprocessed fns met during current fn. */
static GTY(()) tree defarg_depfns;
/* list of fns with circular defargs */
static GTY(()) tree defarg_fnsdone;
void
see_typename ()
{
- /* Only types expected, not even namespaces. */
+ /* Only types expected, not even namespaces. */
looking_for_typename = 2;
if (yychar < 0)
if ((yychar = yylex ()) < 0) yychar = 0;
case PTYPENAME:
case PTYPENAME_DEFN:
/* If we see a SCOPE next, restore the old value.
- Otherwise, we got what we want. */
+ Otherwise, we got what we want. */
looking_for_typename = old_looking_for_typename;
looking_for_template = 0;
break;
case NSNAME:
case PTYPENAME:
/* If this got special lookup, remember it. In these
- cases, we know it can't be a declarator-id. */
+ cases, we know it can't be a declarator-id. */
if (got_scope || got_object)
*idp = trrr;
/* FALLTHROUGH */
/* No need to say what else is dependent, as they will be
picked up in another pass. */
- /* Immediately repeat, but marked so that we break the loop. */
+ /* Immediately repeat, but marked so that we break the loop. */
defarg_fns = current;
TREE_PURPOSE (current) = error_mark_node;
}
}
/* After parsing all the default arguments, we must clear any that remain,
- which will be part of a circular dependency. */
+ which will be part of a circular dependency. */
void
done_pending_defargs ()
{
/* If expression doesn't change the type, we consider it as an
lvalue even when cast_as_lvalue extension isn't selected.
That's because parts of the compiler are alleged to be sloppy
- about sticking in NOP_EXPR node for no good reason. */
+ about sticking in NOP_EXPR node for no good reason. */
if (allow_cast_as_lvalue ||
same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (ref)),
TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (ref, 0)))))
tree from;
{
my_friendly_assert (is_overloaded_fn (from), 9);
- /* A baselink is also considered an overloaded function. */
+ /* A baselink is also considered an overloaded function. */
if (BASELINK_P (from))
from = BASELINK_FUNCTIONS (from);
return OVL_CURRENT (from);
&& TYPE_PTRMEMFUNC_P (TREE_TYPE (TREE_OPERAND (t, 1))));
}
-/* Return a new OVL node, concatenating it with the old one. */
+/* Return a new OVL node, concatenating it with the old one. */
tree
ovl_cons (decl, chain)
if (current_class_ref && context == current_class_type
/* Kludge: Make sure that current_class_type is actually
correct. It might not be if we're in the middle of
- tsubst_default_argument. */
+ tsubst_default_argument. */
&& same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (current_class_ref)),
current_class_type))
decl = current_class_ref;
/* Static objects in functions are initialized the
first time control passes through that
function. This is not precise enough to pin down an
- init_priority value, so don't allow it. */
+ init_priority value, so don't allow it. */
|| current_function_decl)
{
error ("can only use `%s' attribute on file-scope definitions of objects of class type",
return t1;
/* Deal with pointer-to-member functions in the same way as we deal
- with pointers to functions. */
+ with pointers to functions. */
if (TYPE_PTRMEMFUNC_P (t1))
t1 = TYPE_PTRMEMFUNC_FN_TYPE (t1);
if (TYPE_PTRMEMFUNC_P (t2))
if (t1 == t2)
return 1;
- if (t1 == NULL_TREE) /* T1 is ... */
+ if (t1 == NULL_TREE) /* T1 is ... */
return t2 == NULL_TREE || !exact;
if (!TREE_VALUE (t1)) /* t1 is EMPTY */
return t2 != NULL_TREE && !TREE_VALUE (t2);
- if (t2 == NULL_TREE) /* T2 is ... */
+ if (t2 == NULL_TREE) /* T2 is ... */
return 0;
if (TREE_VALUE (t1) && !TREE_VALUE (t2)) /* T2 is EMPTY, T1 is not */
return !exact;
With the final ISO C++ rules, such an optimization is
incorrect: A pointer to a derived member can be static_cast
to pointer-to-base-member, as long as the dynamic object
- later has the right member. */
+ later has the right member. */
tree
get_member_function_from_ptrfunc (instance_ptrptr, function)
{
/* Extracting the function address from a pmf is only
allowed with -Wno-pmf-conversions. It only works for
- pmf constants. */
+ pmf constants. */
e1 = build_addr_func (PTRMEM_CST_MEMBER (function));
e1 = convert (fntype, e1);
return e1;
}
/* Convert down to the right base before using the instance. First
- use the type... */
+ use the type... */
basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (fntype));
basetype = lookup_base (TREE_TYPE (TREE_TYPE (instance_ptr)),
basetype, ba_check, NULL);
&& (TREE_CODE (TREE_OPERAND (TREE_OPERAND (arg, 0), 0))
== INTEGER_CST))
{
- /* offsetof idiom, fold it. */
+ /* offsetof idiom, fold it. */
tree field = TREE_OPERAND (arg, 1);
tree rval = build_unary_op (ADDR_EXPR, TREE_OPERAND (arg, 0), 0);
tree binfo = lookup_base (TREE_TYPE (TREE_TYPE (rval)),
if (! TREE_SIDE_EFFECTS (TREE_VALUE (list)))
{
- /* FIXME: This test should be in the implicit cast to void of the LHS. */
+ /* FIXME: This test should be in the implicit cast to void of the LHS. */
/* the left-hand operand of a comma expression is like an expression
statement: we should warn if it doesn't have any side-effects,
unless it was explicitly cast to (void). */
? can_convert_arg (type, intype, expr)
: can_convert_arg (strip_all_pointer_quals (type),
strip_all_pointer_quals (intype), expr))
- /* This is a standard conversion. */
+ /* This is a standard conversion. */
ok = 1;
else if (TYPE_PTROB_P (type) && TYPE_PTROB_P (intype))
{
/* They're pointers to objects. They must be aggregates that
- are related non-virtually. */
+ are related non-virtually. */
base_kind kind;
if (IS_AGGR_TYPE (TREE_TYPE (type)) && IS_AGGR_TYPE (TREE_TYPE (intype))
{
/* They're pointers to members. The pointed to objects must be
the same (ignoring CV qualifiers), and the containing classes
- must be related non-virtually. */
+ must be related non-virtually. */
base_kind kind;
if (same_type_p
if (virt_binfo)
{
- /* This is a reinterpret cast, we choose to do nothing. */
+ /* This is a reinterpret cast, we choose to do nothing. */
warning ("pointer to member cast via virtual base `%T' of `%T'",
BINFO_TYPE (virt_binfo),
BINFO_TYPE (BINFO_INHERITANCE_CHAIN (virt_binfo)));
virt_binfo = binfo_from_vbase (binfo);
if (virt_binfo)
{
- /* This is a reinterpret cast, we choose to do nothing. */
+ /* This is a reinterpret cast, we choose to do nothing. */
if (force)
warning ("pointer to member cast via virtual base `%T' of `%T'",
BINFO_TYPE (virt_binfo),
{
if (in_function_try_handler)
/* If a return statement appears in a handler of the
- function-try-block of a constructor, the program is ill-formed. */
+ function-try-block of a constructor, the program is ill-formed. */
error ("cannot return from a handler of a function-try-block of a constructor");
else if (retval)
/* You can't return a value from a constructor. */
/* First convert the value to the function's return type, then
to the type of return value's location to handle the
- case that functype is smaller than the valtype. */
+ case that functype is smaller than the valtype. */
retval = convert_for_initialization
(NULL_TREE, functype, retval, LOOKUP_NORMAL|LOOKUP_ONLYCONVERTING,
"return", NULL_TREE, 0);
if (TREE_CODE (init) == ERROR_MARK)
/* __PRETTY_FUNCTION__'s initializer is a bogus expression inside
- a template function. This gets substituted during instantiation. */
+ a template function. This gets substituted during instantiation. */
return init;
/* We must strip the outermost array type when completing the type,
}
/* Combine the two exceptions specifier lists LIST and ADD, and return
- their union. */
+ their union. */
tree
merge_exception_specifiers (list, add)
projects / platform / upstream / gcc.git / commitdiff