* call.c: Fix comment formatting.
* class.c: Likewise.
* cp-lang.c: Likewise.
* cp-tree.h: Likewise.
* cvt.c: Likewise.
From-SVN: r57083
+2002-09-12 Kazu Hirata <kazu@cs.umass.edu>
+
+ * call.c: Fix comment formatting.
+ * class.c: Likewise.
+ * cp-lang.c: Likewise.
+ * cp-tree.h: Likewise.
+ * cvt.c: Likewise.
+
2002-09-11 Zack Weinberg <zack@codesourcery.com>
* Make-lang.in: Build cp/cxxfilt.o from $(srcdir)/cp/cxxfilt.c,
/* Returns non-zero if PARMLIST consists of only default parms and/or
- ellipsis. */
+ ellipsis. */
int
sufficient_parms_p (parmlist)
return build_over_call (cand, args, LOOKUP_NORMAL);
}
- /* This is not really overloaded. */
+ /* This is not really overloaded. */
fn = OVL_CURRENT (fn);
return build_function_call (fn, args);
type of the other and is an rvalue.
--Both the second and the third operands have type void; the
- result is of type void and is an rvalue. */
+ result is of type void and is an rvalue. */
if ((TREE_CODE (arg2) == THROW_EXPR)
^ (TREE_CODE (arg3) == THROW_EXPR))
result_type = ((TREE_CODE (arg2) == THROW_EXPR)
qualification conversions (_conv.qual_) are performed to bring
them to a common type, whose cv-qualification shall match the
cv-qualification of either the second or the third operand.
- The result is of the common type. */
+ The result is of the common type. */
else if ((null_ptr_cst_p (arg2)
&& (TYPE_PTR_P (arg3_type) || TYPE_PTRMEM_P (arg3_type)
|| TYPE_PTRMEMFUNC_P (arg3_type)))
case VEC_NEW_EXPR:
case VEC_DELETE_EXPR:
case DELETE_EXPR:
- /* Use build_op_new_call and build_op_delete_call instead. */
+ /* Use build_op_new_call and build_op_delete_call instead. */
abort ();
case CALL_EXPR:
if (TREE_CODE (fn) == TEMPLATE_DECL)
{
- /* A member template. */
+ /* A member template. */
templates = tree_cons (NULL_TREE, fn, templates);
candidates
= add_template_candidate (candidates, fn,
tree alloc_fn;
tree call_expr;
- /* Find the allocation function that is being called. */
+ /* Find the allocation function that is being called. */
call_expr = placement;
/* Sometimes we have a COMPOUND_EXPR, rather than a simple
- CALL_EXPR. */
+ CALL_EXPR. */
while (TREE_CODE (call_expr) == COMPOUND_EXPR)
call_expr = TREE_OPERAND (call_expr, 1);
/* Extract the function. */
FN and ARGNUM are used for diagnostics. ARGNUM is zero based, -1
indicates the `this' argument of a method. INNER is non-zero when
being called to continue a conversion chain. It is negative when a
- reference binding will be applied, positive otherwise. */
+ reference binding will be applied, positive otherwise. */
static tree
convert_like_real (convs, expr, fn, argnum, inner)
}
/* Look up the pointer to the runtime java.lang.Class object for `instance'.
- This is the first entry in the vtable. */
+ This is the first entry in the vtable. */
klass_ref = build_vtbl_ref (build_indirect_ref (instance, 0),
integer_zero_node);
- /* Get the java.lang.Class pointer for the interface being called. */
+ /* Get the java.lang.Class pointer for the interface being called. */
iface = DECL_CONTEXT (fn);
iface_ref = lookup_field (iface, get_identifier ("class$"), 0, 0);
if (!iface_ref || TREE_CODE (iface_ref) != VAR_DECL
}
iface_ref = build1 (ADDR_EXPR, build_pointer_type (iface), iface_ref);
- /* Determine the itable index of FN. */
+ /* Determine the itable index of FN. */
i = 1;
for (method = TYPE_METHODS (iface); method; method = TREE_CHAIN (method))
{
if (TREE_CODE (t) == TEMPLATE_DECL)
{
- /* A member template. */
+ /* A member template. */
templates = tree_cons (NULL_TREE, t, templates);
candidates =
add_template_candidate (candidates, t,
&& DECL_TEMPLATE_CONV_FN_P (m));
/* If we need to move things up, see if there's
- space. */
+ space. */
if (!have_template_convs_p)
{
slot = len - 1;
}
if (BASELINK_P (fdecl))
- /* Ignore base type this came from. */
+ /* Ignore base type this came from. */
fdecl = BASELINK_FUNCTIONS (fdecl);
old_value = IDENTIFIER_CLASS_VALUE (name);
}
if (TREE_VIA_VIRTUAL (base_binfo))
- /* A virtual base does not effect nearly emptiness. */
+ /* A virtual base does not effect nearly emptiness. */
;
else if (CLASSTYPE_NEARLY_EMPTY_P (basetype))
{
derived class is not nearly empty either. */
CLASSTYPE_NEARLY_EMPTY_P (t) = 0;
else
- /* Remember we've seen one. */
+ /* Remember we've seen one. */
seen_non_virtual_nearly_empty_base_p = 1;
}
else if (!is_empty_class (basetype))
/* If BINFO is an unmarked virtual binfo for a class with a primary virtual
base, then BINFO has no primary base in this graph. Called from
- mark_primary_bases. DATA is the most derived type. */
+ mark_primary_bases. DATA is the most derived type. */
static tree dfs_unshared_virtual_bases (binfo, data)
tree binfo;
if (binfo != TYPE_BINFO (t))
/* The vtable fields will have been copied when duplicating the
base binfos. That information is bogus, make sure we don't try
- and use it. */
+ and use it. */
BINFO_VTABLE (binfo) = NULL_TREE;
/* If this is a virtual primary base, make sure its offset matches
- that which it is primary for. */
+ that which it is primary for. */
if (BINFO_PRIMARY_P (binfo) && TREE_VIA_VIRTUAL (binfo) &&
binfo_for_vbase (BINFO_TYPE (binfo), t) == binfo)
{
tree base_binfo;
if (!CLASSTYPE_HAS_PRIMARY_BASE_P (BINFO_TYPE (binfo)))
- /* Not a dynamic base. */
+ /* Not a dynamic base. */
continue;
base_binfo = get_primary_binfo (binfo);
/* Assume the path is non-virtual. See if there are any
virtual bases from (but not including) the overrider up
to and including the base where the function is
- defined. */
+ defined. */
for (base = TREE_CHAIN (path); base; base = TREE_CHAIN (base))
if (TREE_VIA_VIRTUAL (TREE_VALUE (base)))
{
base_fndecls);
}
- /* If there are no functions to hide, continue. */
+ /* If there are no functions to hide, continue. */
if (!base_fndecls)
continue;
- /* Remove any overridden functions. */
+ /* Remove any overridden functions. */
for (fns = TREE_VEC_ELT (method_vec, i); fns; fns = OVL_NEXT (fns))
{
fndecl = OVL_CURRENT (fns);
past the end of the class, and should be correctly aligned for a
class of the type indicated by BINFO; OFFSETS gives the offsets of
the empty bases allocated so far. T is the most derived
- type. Return non-zero iff we added it at the end. */
+ type. Return non-zero iff we added it at the end. */
static bool
layout_empty_base (binfo, eoc, offsets, t)
*BASE_ALIGN is a running maximum of the alignments of any base
class. OFFSETS gives the location of empty base subobjects. T is
the most derived type. Return non-zero if the new object cannot be
- nearly-empty. */
+ nearly-empty. */
static bool
build_base_field (rli, binfo, empty_p, offsets, t)
declared. An out-of-class definition can specify additional default
arguments. As it is the clones that are involved in overload
resolution, we must propagate the information from the DECL to its
- clones. */
+ clones. */
void
adjust_clone_args (decl)
clone_parms = orig_clone_parms;
- /* Skip the 'this' parameter. */
+ /* Skip the 'this' parameter. */
orig_clone_parms = TREE_CHAIN (orig_clone_parms);
orig_decl_parms = TREE_CHAIN (orig_decl_parms);
if (TREE_PURPOSE (decl_parms) && !TREE_PURPOSE (clone_parms))
{
/* A default parameter has been added. Adjust the
- clone's parameters. */
+ clone's parameters. */
tree exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (clone));
tree basetype = TYPE_METHOD_BASETYPE (TREE_TYPE (clone));
tree type;
it turns out not to be nearly empty. */
CLASSTYPE_NEARLY_EMPTY_P (t) = 1;
- /* Check all the base-classes. */
+ /* Check all the base-classes. */
check_bases (t, &cant_have_default_ctor, &cant_have_const_ctor,
&no_const_asn_ref);
/* Calculate the TYPE_SIZE, TYPE_ALIGN, etc for T. Calculate
BINFO_OFFSETs for all of the base-classes. Position the vtable
- pointer. Accumulate declared virtual functions on VIRTUALS_P. */
+ pointer. Accumulate declared virtual functions on VIRTUALS_P. */
static void
layout_class_type (t, empty_p, vfuns_p, virtuals_p)
{
tree x;
int vfuns;
- /* A TREE_LIST. The TREE_VALUE of each node is a FUNCTION_DECL. */
+ /* A TREE_LIST. The TREE_VALUE of each node is a FUNCTION_DECL. */
tree virtuals = NULL_TREE;
int n_fields = 0;
tree vfield;
my_friendly_assert (same_type_p (DECL_FIELD_CONTEXT (vfield),
BINFO_TYPE (primary)),
20010726);
- /* The vtable better be at the start. */
+ /* The vtable better be at the start. */
my_friendly_assert (integer_zerop (DECL_FIELD_OFFSET (vfield)),
20010726);
my_friendly_assert (integer_zerop (BINFO_OFFSET (primary)),
if (nonnull)
*nonnull = 1;
- /* if we're in a ctor or dtor, we know our type. */
+ /* if we're in a ctor or dtor, we know our type. */
if (DECL_LANG_SPECIFIC (current_function_decl)
&& (DECL_CONSTRUCTOR_P (current_function_decl)
|| DECL_DESTRUCTOR_P (current_function_decl)))
/* DECL_IGNORED_P is initially set for these types, to avoid clutter.
(See record_builtin_java_type in decl.c.) However, that causes
incorrect debug entries if these types are actually used.
- So we re-enable debug output after extern "Java". */
+ So we re-enable debug output after extern "Java". */
DECL_IGNORED_P (TYPE_NAME (java_byte_type_node)) = 0;
DECL_IGNORED_P (TYPE_NAME (java_short_type_node)) = 0;
DECL_IGNORED_P (TYPE_NAME (java_int_type_node)) = 0;
/*explicit_targs=*/NULL_TREE);
case TREE_LIST:
- /* Now we should have a baselink. */
+ /* Now we should have a baselink. */
my_friendly_assert (BASELINK_P (rhs), 990412);
return instantiate_type (lhstype, BASELINK_FUNCTIONS (rhs), flags);
/* Called from get_primary_binfo via dfs_walk. DATA is a TREE_LIST
who's TREE_PURPOSE is the TYPE of the required primary base and
- who's TREE_VALUE is a list of candidate binfos that we fill in. */
+ who's TREE_VALUE is a list of candidate binfos that we fill in. */
static tree
dfs_get_primary_binfo (binfo, data)
return result;
}
-/* If INDENTED_P is zero, indent to INDENT. Return non-zero. */
+/* If INDENTED_P is zero, indent to INDENT. Return non-zero. */
static int
maybe_indent_hierarchy (stream, indent, indented_p)
/* When building a secondary VTT, BINFO_VTABLE is set to a TREE_LIST with
PURPOSE the RTTI_BINFO, VALUE the real vtable pointer for this binfo,
and CHAIN the vtable pointer for this binfo after construction is
- complete. VALUE can also be another BINFO, in which case we recurse. */
+ complete. VALUE can also be another BINFO, in which case we recurse. */
static tree
binfo_ctor_vtable (binfo)
{
/* It's a primary virtual base, and this is not the construction
vtable. Find the base this is primary of in the inheritance graph,
- and use that base's vtable now. */
+ and use that base's vtable now. */
while (BINFO_PRIMARY_BASE_OF (binfo))
binfo = BINFO_PRIMARY_BASE_OF (binfo);
}
BINFO_TYPE (orig_binfo)),
20000517);
- /* If it doesn't have a vptr, we don't do anything. */
+ /* If it doesn't have a vptr, we don't do anything. */
if (!TYPE_CONTAINS_VPTR_P (BINFO_TYPE (binfo)))
return;
/* Each front end provides its own hooks, for toplev.c. */
const struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER;
-/* Tree code classes. */
+/* Tree code classes. */
#define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
the virtual function this one overrides, and whose TREE_CHAIN is
the old DECL_VINDEX. */
-/* Language-specific tree checkers. */
+/* Language-specific tree checkers. */
#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
tree value;
};
-/* The overloaded FUNCTION_DECL. */
+/* The overloaded FUNCTION_DECL. */
#define OVL_FUNCTION(NODE) \
(((struct tree_overload*)OVERLOAD_CHECK (NODE))->function)
#define OVL_CHAIN(NODE) TREE_CHAIN (NODE)
-/* Polymorphic access to FUNCTION and CHAIN. */
+/* Polymorphic access to FUNCTION and CHAIN. */
#define OVL_CURRENT(NODE) \
((TREE_CODE (NODE) == OVERLOAD) ? OVL_FUNCTION (NODE) : (NODE))
#define OVL_NEXT(NODE) \
((TREE_CODE (NODE) == OVERLOAD) ? TREE_CHAIN (NODE) : NULL_TREE)
/* If set, this was imported in a using declaration.
This is not to confuse with being used somewhere, which
- is not important for this node. */
+ is not important for this node. */
#define OVL_USED(NODE) TREE_USED (NODE)
struct tree_overload GTY(())
/* TREE_TYPE only indicates on local and class scope the current
type. For namespace scope, the presence of a type in any namespace
is indicated with global_type_node, and the real type behind must
- be found through lookup. */
+ be found through lookup. */
#define IDENTIFIER_TYPE_VALUE(NODE) identifier_type_value (NODE)
#define REAL_IDENTIFIER_TYPE_VALUE(NODE) TREE_TYPE (NODE)
#define SET_IDENTIFIER_TYPE_VALUE(NODE,TYPE) (TREE_TYPE (NODE) = (TYPE))
/* The node for `__null'. */
#define null_node cp_global_trees[CPTI_NULL]
-/* If non-NULL, a POINTER_TYPE equivalent to (java::lang::Class*). */
+/* If non-NULL, a POINTER_TYPE equivalent to (java::lang::Class*). */
#define jclass_node cp_global_trees[CPTI_JCLASS]
/* The declaration for `std::terminate'. */
#define current_namespace scope_chain->old_namespace
-/* The stack for namespaces of current declarations. */
+/* The stack for namespaces of current declarations. */
#define decl_namespace_list scope_chain->decl_ns_list
/* In a *_TYPE, nonzero means a built-in type. */
#define TYPE_BUILT_IN(NODE) TYPE_LANG_FLAG_6 (NODE)
-/* True if this a "Java" type, defined in 'extern "Java"'. */
+/* True if this a "Java" type, defined in 'extern "Java"'. */
#define TYPE_FOR_JAVA(NODE) TYPE_LANG_FLAG_3 (NODE)
/* Nonzero if this type is const-qualified. */
(CLASSTYPE_ALIGN (NODE) / BITS_PER_UNIT)
/* True if this a Java interface type, declared with
- '__attribute__ ((java_interface))'. */
+ '__attribute__ ((java_interface))'. */
#define TYPE_JAVA_INTERFACE(NODE) (LANG_TYPE_CLASS_CHECK (NODE)->java_interface)
/* A cons list of virtual functions which cannot be inherited by
non-NULL). */
#define VF_BASETYPE_VALUE(NODE) TREE_VALUE (NODE)
-/* Accessor macros for the BINFO_VIRTUALS list. */
+/* Accessor macros for the BINFO_VIRTUALS list. */
/* The number of bytes by which to adjust the `this' pointer when
calling this virtual function. Subtract this value from the this
- pointer. Always non-NULL, might be constant zero though. */
+ pointer. Always non-NULL, might be constant zero though. */
#define BV_DELTA(NODE) (TREE_PURPOSE (NODE))
/* If non-NULL, the vtable index at which to find the vcall offset
(TREE_LANG_FLAG_0 (NODE))
/* The _TYPE context in which this _DECL appears. This field holds the
- class where a virtual function instance is actually defined. */
+ class where a virtual function instance is actually defined. */
#define DECL_CLASS_CONTEXT(NODE) \
(DECL_CLASS_SCOPE_P (NODE) ? DECL_CONTEXT (NODE) : NULL_TREE)
#define SET_DECL_FRIEND_CONTEXT(NODE, CONTEXT) \
(DECL_LANG_SPECIFIC (NODE)->u.f.context = (CONTEXT))
-/* NULL_TREE in DECL_CONTEXT represents the global namespace. */
+/* NULL_TREE in DECL_CONTEXT represents the global namespace. */
#define CP_DECL_CONTEXT(NODE) \
(DECL_CONTEXT (NODE) ? DECL_CONTEXT (NODE) : global_namespace)
#define FROB_CONTEXT(NODE) ((NODE) == global_namespace ? NULL_TREE : (NODE))
/* For a NAMESPACE_DECL: the list of using namespace directives
The PURPOSE is the used namespace, the value is the namespace
- that is the common ancestor. */
+ that is the common ancestor. */
#define DECL_NAMESPACE_USING(NODE) DECL_VINDEX (NAMESPACE_DECL_CHECK (NODE))
/* In a NAMESPACE_DECL, the DECL_INITIAL is used to record all users
- of a namespace, to record the transitive closure of using namespace. */
+ of a namespace, to record the transitive closure of using namespace. */
#define DECL_NAMESPACE_USERS(NODE) DECL_INITIAL (NAMESPACE_DECL_CHECK (NODE))
/* In a NAMESPACE_DECL, points to the original namespace if this is
(DECL_LANG_SPECIFIC (NODE)->u.f.u.pending_inline_info)
/* For a TYPE_DECL: if this function has many fields, we'll sort them
- and put them into a TREE_VEC. */
+ and put them into a TREE_VEC. */
#define DECL_SORTED_FIELDS(NODE) \
(DECL_LANG_SPECIFIC (TYPE_DECL_CHECK (NODE))->u.f.u.sorted_fields)
(make_typename_type use) */
} tsubst_flags_t;
-/* The kind of checking we can do looking in a class hierarchy. */
+/* The kind of checking we can do looking in a class hierarchy. */
typedef enum base_access {
ba_any = 0, /* Do not check access, allow an ambiguous base,
prefer a non-virtual base */
ba_ignore = 1, /* Do not check access */
ba_check = 2, /* Check access */
ba_not_special = 3, /* Do not consider special privilege
- current_class_type might give. */
+ current_class_type might give. */
ba_quiet = 4, /* Do not issue error messages (bit mask). */
} base_access;
/* The kind of base we can find, looking in a class hierarchy.
- Values <0 indicate we failed. */
+ Values <0 indicate we failed. */
typedef enum base_kind {
bk_inaccessible = -3, /* The base is inaccessible */
bk_ambig = -2, /* The base is ambiguous */
bk_proper_base = 1, /* It is a proper base */
bk_via_virtual = 2 /* It is a proper base, but via a virtual
path. This might not be the canonical
- binfo. */
+ binfo. */
} base_kind;
/* Set by add_implicitly_declared_members() to keep those members from
enum tree_code code = PLUS_EXPR;
tree binfo;
- /* Try derived to base conversion. */
+ /* Try derived to base conversion. */
binfo = lookup_base (TREE_TYPE (intype), TREE_TYPE (type),
ba_check, NULL);
if (!binfo)
{
- /* Try base to derived conversion. */
+ /* Try base to derived conversion. */
binfo = lookup_base (TREE_TYPE (type), TREE_TYPE (intype),
ba_check, NULL);
code = MINUS_EXPR;
if (binfo)
{
expr = build_base_path (code, expr, binfo, 0);
- /* Add any qualifier conversions. */
+ /* Add any qualifier conversions. */
if (!same_type_p (TREE_TYPE (TREE_TYPE (expr)),
TREE_TYPE (type)))
{
if (binfo)
{
expr = build_base_path (code, expr, binfo, 0);
- /* Add any qualifier conversions. */
+ /* Add any qualifier conversions. */
if (!same_type_p (TREE_TYPE (TREE_TYPE (expr)),
TREE_TYPE (type)))
{
case NON_LVALUE_EXPR:
case NOP_EXPR:
- /* These have already decayed to rvalue. */
+ /* These have already decayed to rvalue. */
break;
case CALL_EXPR: /* we have a special meaning for volatile void fn() */
projects / gcc.git / commitdiff