static GTY(()) tree global_type_node;
-/* Expect only namespace names now. */
+/* Expect only namespace names now. */
static int only_namespace_names;
/* Used only for jumps to as-yet undefined labels, since jumps to
component_bindings. */
tree tags;
- /* A list of USING_DECL nodes. */
+ /* A list of USING_DECL nodes. */
tree usings;
/* A list of used namespaces. PURPOSE is the namespace,
- VALUE the common ancestor with this binding_level's namespace. */
+ VALUE the common ancestor with this binding_level's namespace. */
tree using_directives;
/* If this binding level is the binding level for a class, then
struct cp_binding_level *b;
{
/* Resuming binding levels is meant only for namespaces,
- and those cannot nest into classes. */
+ and those cannot nest into classes. */
my_friendly_assert(!class_binding_level, 386);
/* Also, resuming a non-directly nested namespace is a no-no. */
my_friendly_assert(b->level_chain == current_binding_level, 386);
/* Namespace binding access routines: The namespace_bindings field of
the identifier is polymorphic, with three possible values:
NULL_TREE, a list of CPLUS_BINDINGS, or any other tree_node
- indicating the BINDING_VALUE of global_namespace. */
+ indicating the BINDING_VALUE of global_namespace. */
/* Check whether the a binding for the name to scope is known.
Assumes that the bindings of the name are already a list
- of bindings. Returns the binding found, or NULL_TREE. */
+ of bindings. Returns the binding found, or NULL_TREE. */
static tree
find_binding (name, scope)
if (BINDING_SCOPE (iter) == scope)
{
/* Move binding found to the front of the list, so
- subsequent lookups will find it faster. */
+ subsequent lookups will find it faster. */
if (prev)
{
TREE_CHAIN (prev) = TREE_CHAIN (iter);
/* Always returns a binding for name in scope. If the
namespace_bindings is not a list, convert it to one first.
- If no binding is found, make a new one. */
+ If no binding is found, make a new one. */
tree
binding_for_name (name, scope)
if (b && TREE_CODE (b) != CPLUS_BINDING)
{
- /* Get rid of optimization for global scope. */
+ /* Get rid of optimization for global scope. */
IDENTIFIER_NAMESPACE_BINDINGS (name) = NULL_TREE;
BINDING_VALUE (binding_for_name (name, global_namespace)) = b;
b = IDENTIFIER_NAMESPACE_BINDINGS (name);
}
if (b && (result = find_binding (name, scope)))
return result;
- /* Not found, make a new one. */
+ /* Not found, make a new one. */
result = make_node (CPLUS_BINDING);
TREE_CHAIN (result) = b;
IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
}
/* Return the binding value for name in scope, considering that
- namespace_binding may or may not be a list of CPLUS_BINDINGS. */
+ namespace_binding may or may not be a list of CPLUS_BINDINGS. */
tree
namespace_binding (name, scope)
}
/* Set the binding value for name in scope. If modifying the binding
- of global_namespace is attempted, try to optimize it. */
+ of global_namespace is attempted, try to optimize it. */
void
set_namespace_binding (name, scope, val)
int global = 0;
if (!global_namespace)
{
- /* This must be ::. */
+ /* This must be ::. */
my_friendly_assert (name == get_identifier ("::"), 377);
global = 1;
}
}
else
{
- /* Check whether this is an extended namespace definition. */
+ /* Check whether this is an extended namespace definition. */
d = IDENTIFIER_NAMESPACE_VALUE (name);
if (d != NULL_TREE && TREE_CODE (d) == NAMESPACE_DECL)
{
if (need_new)
{
- /* Make a new namespace, binding the name to it. */
+ /* Make a new namespace, binding the name to it. */
d = build_lang_decl (NAMESPACE_DECL, name, void_type_node);
/* The global namespace is not pushed, and the global binding
level is set elsewhere. */
if (implicit_use)
do_using_directive (d);
- /* Enter the name space. */
+ /* Enter the name space. */
current_namespace = d;
}
if (!b->namespace_p)
{
/* Shadow the marker, not the real thing, so that the marker
- gets restored later. */
+ gets restored later. */
tree old_type_value = REAL_IDENTIFIER_TYPE_VALUE (id);
b->type_shadowed
= tree_cons (id, old_type_value, b->type_shadowed);
{
tree binding = binding_for_name (id, current_namespace);
BINDING_TYPE (binding) = type;
- /* Store marker instead of real type. */
+ /* Store marker instead of real type. */
type = global_type_node;
}
SET_IDENTIFIER_TYPE_VALUE (id, type);
set_identifier_type_value_with_scope (id, type, current_binding_level);
}
-/* Return the type associated with id. */
+/* Return the type associated with id. */
tree
identifier_type_value (id)
tree id;
{
- /* There is no type with that name, anywhere. */
+ /* There is no type with that name, anywhere. */
if (REAL_IDENTIFIER_TYPE_VALUE (id) == NULL_TREE)
return NULL_TREE;
- /* This is not the type marker, but the real thing. */
+ /* This is not the type marker, but the real thing. */
if (REAL_IDENTIFIER_TYPE_VALUE (id) != global_type_node)
return REAL_IDENTIFIER_TYPE_VALUE (id);
/* Have to search for it. It must be on the global level, now.
- Ask lookup_name not to return non-types. */
+ Ask lookup_name not to return non-types. */
id = lookup_name_real (id, 2, 1, 0);
if (id)
return TREE_TYPE (id);
/* We may be defining a new type in the initializer
of a static member variable. We allow this when
not pedantic, and it is particularly useful for
- type punning via an anonymous union. */
+ type punning via an anonymous union. */
|| COMPLETE_TYPE_P (b->this_class))))
b = b->level_chain;
}
}
- /* Check for redeclaration and other discrepancies. */
+ /* Check for redeclaration and other discrepancies. */
if (TREE_CODE (olddecl) == FUNCTION_DECL
&& DECL_ARTIFICIAL (olddecl))
{
else if (TREE_CODE (newdecl) == NAMESPACE_DECL
&& DECL_NAMESPACE_ALIAS (newdecl)
&& DECL_NAMESPACE_ALIAS (newdecl) == DECL_NAMESPACE_ALIAS (olddecl))
- /* Redeclaration of namespace alias, ignore it. */
+ /* Redeclaration of namespace alias, ignore it. */
return 1;
else
{
definition. */
if (warn_redundant_decls && ! DECL_ARTIFICIAL (olddecl)
&& !(new_defines_function && DECL_INITIAL (olddecl) == NULL_TREE)
- /* Don't warn about extern decl followed by definition. */
+ /* Don't warn about extern decl followed by definition. */
&& !(DECL_EXTERNAL (olddecl) && ! DECL_EXTERNAL (newdecl))
- /* Don't warn about friends, let add_friend take care of it. */
+ /* Don't warn about friends, let add_friend take care of it. */
&& ! (DECL_FRIEND_P (newdecl) || DECL_FRIEND_P (olddecl)))
{
warning ("redundant redeclaration of `%D' in same scope", newdecl);
else if ((DECL_EXTERN_C_FUNCTION_P (x)
|| DECL_FUNCTION_TEMPLATE_P (x))
&& is_overloaded_fn (t))
- /* Don't do anything just yet. */;
+ /* Don't do anything just yet. */;
else if (t == wchar_decl_node)
{
if (pedantic && ! DECL_IN_SYSTEM_HEADER (x))
/* If declaring a type as a typedef, copy the type (unless we're
at line 0), and install this TYPE_DECL as the new type's typedef
- name. See the extensive comment in ../c-decl.c (pushdecl). */
+ name. See the extensive comment in ../c-decl.c (pushdecl). */
if (TREE_CODE (x) == TYPE_DECL)
{
tree type = TREE_TYPE (x);
|| (TREE_CODE (decl) != PARM_DECL
&& DECL_CONTEXT (decl) != NULL_TREE
/* Definitions of namespace members outside their namespace are
- possible. */
+ possible. */
&& TREE_CODE (DECL_CONTEXT (decl)) != NAMESPACE_DECL)
|| (TREE_CODE (decl) == TEMPLATE_DECL && !namespace_bindings_p ())
|| TREE_CODE (type) == UNKNOWN_TYPE
tree ud = current_binding_level->using_directives;
tree iter, ancestor;
- /* Check if we already have this. */
+ /* Check if we already have this. */
if (purpose_member (used, ud) != NULL_TREE)
return NULL_TREE;
- /* Recursively add all namespaces used. */
+ /* Recursively add all namespaces used. */
for (iter = DECL_NAMESPACE_USING (used); iter; iter = TREE_CHAIN (iter))
push_using_directive (TREE_PURPOSE (iter));
return 0;
/* If both functions come from different namespaces, this is not
- a redeclaration - this is a conflict with a used function. */
+ a redeclaration - this is a conflict with a used function. */
if (DECL_NAMESPACE_SCOPE_P (olddecl)
&& DECL_CONTEXT (olddecl) != DECL_CONTEXT (newdecl))
return "`%D' conflicts with used function";
return TREE_VALUE (tail);
}
else if (level->namespace_p)
- /* Do namespace lookup. */
+ /* Do namespace lookup. */
for (tail = current_namespace; 1; tail = CP_DECL_CONTEXT (tail))
{
tree old = binding_for_name (name, tail);
my_friendly_assert (TREE_CODE (namespace) == NAMESPACE_DECL, 370);
if (TREE_CODE (name) == NAMESPACE_DECL)
- /* This happens for A::B<int> when B is a namespace. */
+ /* This happens for A::B<int> when B is a namespace. */
return name;
else if (TREE_CODE (name) == TEMPLATE_DECL)
{
return t;
}
-/* Select the right _DECL from multiple choices. */
+/* Select the right _DECL from multiple choices. */
static tree
select_decl (binding, flags)
if (LOOKUP_NAMESPACES_ONLY (flags))
{
- /* We are not interested in types. */
+ /* We are not interested in types. */
if (val && TREE_CODE (val) == NAMESPACE_DECL)
return val;
return NULL_TREE;
&& (!val || ((flags & LOOKUP_PREFER_TYPES)
&& TREE_CODE (val) != TYPE_DECL)))
val = TYPE_STUB_DECL (BINDING_TYPE (binding));
- /* Don't return non-types if we really prefer types. */
+ /* Don't return non-types if we really prefer types. */
else if (val && LOOKUP_TYPES_ONLY (flags) && TREE_CODE (val) != TYPE_DECL
&& (TREE_CODE (val) != TEMPLATE_DECL
|| !DECL_CLASS_TEMPLATE_P (val)))
}
else
{
- /* Initialize binding for this context. */
+ /* Initialize binding for this context. */
BINDING_VALUE (b) = BINDING_VALUE (val);
BINDING_TYPE (b) = BINDING_TYPE (val);
}
- /* Add all _DECLs seen through local using-directives. */
+ /* Add all _DECLs seen through local using-directives. */
for (level = current_binding_level;
!level->namespace_p;
level = level->level_chain)
if (!lookup_using_namespace (name, b, level->using_directives,
scope, flags, spacesp))
- /* Give up because of error. */
+ /* Give up because of error. */
return error_mark_node;
- /* Add all _DECLs seen through global using-directives. */
- /* XXX local and global using lists should work equally. */
+ /* Add all _DECLs seen through global using-directives. */
+ /* XXX local and global using lists should work equally. */
siter = initial;
while (1)
{
if (!lookup_using_namespace (name, b, DECL_NAMESPACE_USING (siter),
scope, flags, spacesp))
- /* Give up because of error. */
+ /* Give up because of error. */
return error_mark_node;
if (siter == scope) break;
siter = CP_DECL_CONTEXT (siter);
int flags;
int val_is_implicit_typename = 0;
- /* Hack: copy flag set by parser, if set. */
+ /* Hack: copy flag set by parser, if set. */
if (only_namespace_names)
namespaces_only = 1;
prefer_type = looking_for_typename;
flags = lookup_flags (prefer_type, namespaces_only);
- /* If the next thing is '<', class templates are types. */
+ /* If the next thing is '<', class templates are types. */
if (looking_for_template)
flags |= LOOKUP_TEMPLATES_EXPECTED;
else
{
flags = lookup_flags (prefer_type, namespaces_only);
- /* If we're not parsing, we need to complain. */
+ /* If we're not parsing, we need to complain. */
flags |= LOOKUP_COMPLAIN;
}
tdecl = pushdecl (build_decl (TYPE_DECL, tname, type));
set_identifier_type_value (tname, NULL_TREE);
if ((int) rid_index < (int) RID_MAX)
- /* Built-in types live in the global namespace. */
+ /* Built-in types live in the global namespace. */
SET_IDENTIFIER_GLOBAL_VALUE (tname, tdecl);
}
if (rname != NULL_TREE)
if (size > 0)
type = make_signed_type (size);
else if (size > -32)
- { /* "__java_char" or ""__java_boolean". */
+ { /* "__java_char" or ""__java_boolean". */
type = make_unsigned_type (-size);
/*if (size == -1) TREE_SET_CODE (type, BOOLEAN_TYPE);*/
}
else
- { /* "__java_float" or ""__java_double". */
+ { /* "__java_float" or ""__java_double". */
type = make_node (REAL_TYPE);
TYPE_PRECISION (type) = - size;
layout_type (type);
/* Suppress generate debug symbol entries for these types,
since for normal C++ they are just clutter.
- However, push_lang_context undoes this if extern "Java" is seen. */
+ However, push_lang_context undoes this if extern "Java" is seen. */
DECL_IGNORED_P (decl) = 1;
TYPE_FOR_JAVA (type) = 1;
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 (type, name)
/* Create the global variables. */
push_to_top_level ();
- /* Enter the global namespace. */
+ /* Enter the global namespace. */
my_friendly_assert (global_namespace == NULL_TREE, 375);
push_namespace (get_identifier ("::"));
global_namespace = current_namespace;
/* Generate an initializer for a function naming variable from
NAME. NAME may be NULL, in which case we generate a special
- ERROR_MARK node which should be replaced later. */
+ ERROR_MARK node which should be replaced later. */
tree
cp_fname_init (name)
TREE_TYPE (init) = type;
else
/* We don't know the value until instantiation time. Make
- something which will be digested now, but replaced later. */
+ something which will be digested now, but replaced later. */
init = build (ERROR_MARK, type);
return init;
tree init = cp_fname_init (name);
tree decl = build_decl (VAR_DECL, id, TREE_TYPE (init));
- /* As we don't push the decl here, we must set the context. */
+ /* As we don't push the decl here, we must set the context. */
DECL_CONTEXT (decl) = current_function_decl;
DECL_PRETTY_FUNCTION_P (decl) = type_dep;
&& context != current_namespace && TREE_CODE (decl) == VAR_DECL)
{
/* When parsing the initializer, lookup should use the object's
- namespace. */
+ namespace. */
push_decl_namespace (context);
}
- /* We are only interested in class contexts, later. */
+ /* We are only interested in class contexts, later. */
if (context && TREE_CODE (context) == NAMESPACE_DECL)
context = NULL_TREE;
&& DECL_CONTEXT (decl) != current_namespace
&& init)
{
- /* Leave the namespace of the object. */
+ /* Leave the namespace of the object. */
pop_decl_namespace ();
}
type = build_exception_variant (type, raises);
decl = build_lang_decl (FUNCTION_DECL, declarator, type);
- /* Propagate volatile out from type to decl. */
+ /* Propagate volatile out from type to decl. */
if (TYPE_VOLATILE (type))
TREE_THIS_VOLATILE (decl) = 1;
/* Due to bison parser ickiness, we will have already looked
up an operator_name or PFUNCNAME within the current class
(see template_id in parse.y). If the current class contains
- such a name, we'll get a COMPONENT_REF here. Undo that. */
+ such a name, we'll get a COMPONENT_REF here. Undo that. */
my_friendly_assert (TREE_TYPE (TREE_OPERAND (fns, 0))
== current_class_type, 20001120);
size, integer_one_node));
}
- /* The size might be the result of a cast. */
+ /* The size might be the result of a cast. */
STRIP_TYPE_NOPS (size);
/* It might be a const variable or enumeration constant. */
break;
case ADDR_EXPR: /* C++ reference declaration */
- /* Fall through. */
+ /* Fall through. */
case ARRAY_REF:
case INDIRECT_REF:
ctype = NULL_TREE;
dname = DECL_NAME (get_first_fn (dname));
}
}
- /* Fall through. */
+ /* Fall through. */
case IDENTIFIER_NODE:
if (TREE_CODE (decl) == IDENTIFIER_NODE)
type = create_array_type_for_decl (dname, type, size);
- /* VLAs never work as fields. */
+ /* VLAs never work as fields. */
if (decl_context == FIELD && !processing_template_decl
&& TREE_CODE (type) == ARRAY_TYPE
&& TYPE_DOMAIN (type) != NULL_TREE
{
error ("size of member `%D' is not constant", dname);
/* Proceed with arbitrary constant size, so that offset
- computations don't get confused. */
+ computations don't get confused. */
type = create_array_type_for_decl (dname, TREE_TYPE (type),
integer_one_node);
}
/* This needs to be here, in case we are called
multiple times. */ ;
else if (TREE_COMPLEXITY (declarator) == -1)
- /* Namespace member. */
+ /* Namespace member. */
pop_decl_namespace ();
else if (friendp && (TREE_COMPLEXITY (declarator) < 2))
/* Don't fall out into global scope. Hides real bug? --eichin */ ;
TREE_TYPE (decl) = type;
}
else if (abstract_virtuals_error (decl, type))
- any_error = 1; /* Seems like a good idea. */
+ any_error = 1; /* Seems like a good idea. */
else if (POINTER_TYPE_P (type))
{
/* [dcl.fct]/6, parameter types cannot contain pointers
}
if (operator_code == CALL_EXPR)
- return; /* No restrictions on args. */
+ return; /* No restrictions on args. */
if (IDENTIFIER_TYPENAME_P (name) && ! DECL_TEMPLATE_INFO (decl))
{
TYPE_IDENTIFIER (t));
/* We need to remove the class scope binding for the
- TYPENAME_TYPE as otherwise poplevel_class gets confused. */
+ TYPENAME_TYPE as otherwise poplevel_class gets confused. */
for (shadowed = b->class_shadowed;
shadowed;
shadowed = TREE_CHAIN (shadowed))
if (TYPE_VALUES (enumtype))
{
- /* The next value is the previous value ... */
+ /* The next value is the previous value ... */
prev_value = DECL_INITIAL (TREE_VALUE (TYPE_VALUES (enumtype)));
/* ... plus one. */
value = cp_build_binary_op (PLUS_EXPR,
initializing value.
In finish_enum we will reset the type. Of course, if we're
- processing a template, there may be no value. */
+ processing a template, there may be no value. */
type = value ? TREE_TYPE (value) : NULL_TREE;
if (context && context == current_class_type)
decl1 = pushdecl (decl1);
else
{
- /* We need to set the DECL_CONTEXT. */
+ /* We need to set the DECL_CONTEXT. */
if (!DECL_CONTEXT (decl1) && DECL_TEMPLATE_INFO (decl1))
DECL_CONTEXT (decl1) = DECL_CONTEXT (DECL_TI_TEMPLATE (decl1));
/* And make sure we have enough default args. */
tree static_ctors;
tree static_dtors;
-/* The :: namespace. */
+/* The :: namespace. */
tree global_namespace;
\f
if (current_function_decl)
/* 14.5.2.2 [temp.mem]
- A local class shall not have member templates. */
+ A local class shall not have member templates. */
error ("invalid declaration of member template `%#D' in local class",
decl);
error ("template declaration of `%#D'", decl);
}
-/* Return true iff TYPE is a valid Java parameter or return type. */
+/* Return true iff TYPE is a valid Java parameter or return type. */
static int
acceptable_java_type (type)
int static_p = TREE_STATIC (anon_union_decl);
int external_p = DECL_EXTERNAL (anon_union_decl);
- /* The VAR_DECL's context is the same as the TYPE's context. */
+ /* The VAR_DECL's context is the same as the TYPE's context. */
DECL_CONTEXT (anon_union_decl) = DECL_CONTEXT (TYPE_NAME (type));
if (TYPE_FIELDS (type) == NULL_TREE)
one. However, that's not actually the case in SVR4; a strong definition
after a weak one is an error. Also, not making explicit
instantiations one_only means that we can end up with two copies of
- some template instantiations. */
+ some template instantiations. */
if (! flag_weak)
return;
DECL_COMDAT (decl) = 1;
}
- /* Now override some cases. */
+ /* Now override some cases. */
if (flag_weak)
DECL_COMDAT (decl) = 1;
else if (is_in_library)
guard_type = long_long_integer_type_node;
guard = build_decl (VAR_DECL, sname, guard_type);
- /* The guard should have the same linkage as what it guards. */
+ /* The guard should have the same linkage as what it guards. */
TREE_PUBLIC (guard) = TREE_PUBLIC (decl);
TREE_STATIC (guard) = TREE_STATIC (decl);
DECL_COMMON (guard) = DECL_COMMON (decl);
VARRAY_TREE_INIT (ssdf_decls, 32, "ssdf_decls");
/* Take this opportunity to initialize the map from priority
- numbers to information about that priority level. */
+ numbers to information about that priority level. */
priority_info_map = splay_tree_new (splay_tree_compare_ints,
/*delete_key_fn=*/0,
/*delete_value_fn=*/
This is done in a separate for cycle, because if some deferred
function is contained in another deferred function later in
deferred_fns varray, rest_of_compilation would skip this
- function and we really cannot expand the same function twice. */
+ function and we really cannot expand the same function twice. */
for (i = 0; i < deferred_fns_used; ++i)
{
tree decl = VARRAY_TREE (deferred_fns, i);
finish_repo ();
/* The entire file is now complete. If requested, dump everything
- to a file. */
+ to a file. */
{
int flags;
FILE *stream = dump_begin (TDI_all, &flags);
&& (!current_class_type
|| !lookup_member (current_class_type, id, 0, 0)))
{
- /* Do Koenig lookup if there are no class members. */
+ /* Do Koenig lookup if there are no class members. */
name = do_identifier (id, 0, args);
}
else if (TREE_CODE (name) == TEMPLATE_ID_EXPR
}
}
-/* Return 1 if root encloses child. */
+/* Return 1 if root encloses child. */
static int
is_namespace_ancestor (root, child)
/* Return the namespace that is the common ancestor
- of two given namespaces. */
+ of two given namespaces. */
tree
namespace_ancestor (ns1, ns2)
int indirect;
{
tree t;
- /* Using oneself is a no-op. */
+ /* Using oneself is a no-op. */
if (user == used)
return;
my_friendly_assert (TREE_CODE (user) == NAMESPACE_DECL, 380);
my_friendly_assert (TREE_CODE (used) == NAMESPACE_DECL, 380);
- /* Check if we already have this. */
+ /* Check if we already have this. */
t = purpose_member (used, DECL_NAMESPACE_USING (user));
if (t != NULL_TREE)
{
if (!indirect)
- /* Promote to direct usage. */
+ /* Promote to direct usage. */
TREE_INDIRECT_USING (t) = 0;
return;
}
- /* Add used to the user's using list. */
+ /* Add used to the user's using list. */
DECL_NAMESPACE_USING (user)
= tree_cons (used, namespace_ancestor (user, used),
DECL_NAMESPACE_USING (user));
TREE_INDIRECT_USING (DECL_NAMESPACE_USING (user)) = indirect;
- /* Add user to the used's users list. */
+ /* Add user to the used's users list. */
DECL_NAMESPACE_USERS (used)
= tree_cons (user, 0, DECL_NAMESPACE_USERS (used));
- /* Recursively add all namespaces used. */
+ /* Recursively add all namespaces used. */
for (t = DECL_NAMESPACE_USING (used); t; t = TREE_CHAIN (t))
/* indirect usage */
add_using_namespace (user, TREE_PURPOSE (t), 1);
- /* Tell everyone using us about the new used namespaces. */
+ /* Tell everyone using us about the new used namespaces. */
for (t = DECL_NAMESPACE_USERS (user); t; t = TREE_CHAIN (t))
add_using_namespace (TREE_PURPOSE (t), used, 1);
}
{
tree val, type;
my_friendly_assert (old != NULL_TREE, 393);
- /* Copy the value. */
+ /* Copy the value. */
val = BINDING_VALUE (new);
if (val)
switch (TREE_CODE (val))
{
case TEMPLATE_DECL:
/* If we expect types or namespaces, and not templates,
- or this is not a template class. */
+ or this is not a template class. */
if (LOOKUP_QUALIFIERS_ONLY (flags)
&& !DECL_CLASS_TEMPLATE_P (val))
val = NULL_TREE;
}
else
{
- /* Some declarations are functions, some are not. */
+ /* Some declarations are functions, some are not. */
if (flags & LOOKUP_COMPLAIN)
{
/* If we've already given this error for this lookup,
BINDING_VALUE (old) = error_mark_node;
}
}
- /* ... and copy the type. */
+ /* ... and copy the type. */
type = BINDING_TYPE (new);
if (LOOKUP_NAMESPACES_ONLY (flags))
type = NULL_TREE;
We are currently looking for names in namespace SCOPE, so we
look through USINGS for using-directives of namespaces
which have SCOPE as a common ancestor with the current scope.
- Returns zero on errors. */
+ Returns zero on errors. */
int
lookup_using_namespace (name, val, usings, scope, flags, spacesp)
tree iter;
tree val1;
/* Iterate over all used namespaces in current, searching for using
- directives of scope. */
+ directives of scope. */
for (iter = usings; iter; iter = TREE_CHAIN (iter))
if (TREE_VALUE (iter) == scope)
{
*spacesp = tree_cons (TREE_PURPOSE (iter), NULL_TREE,
*spacesp);
val1 = binding_for_name (name, TREE_PURPOSE (iter));
- /* Resolve ambiguities. */
+ /* Resolve ambiguities. */
val = ambiguous_decl (name, val, val1, flags);
}
return BINDING_VALUE (val) != error_mark_node;
/* [namespace.qual]
Accepts the NAME to lookup and its qualifying SCOPE.
Returns the name/type pair found into the CPLUS_BINDING RESULT,
- or 0 on error. */
+ or 0 on error. */
int
qualified_lookup_using_namespace (name, scope, result, flags)
tree result;
int flags;
{
- /* Maintain a list of namespaces visited... */
+ /* Maintain a list of namespaces visited... */
tree seen = NULL_TREE;
- /* ... and a list of namespace yet to see. */
+ /* ... and a list of namespace yet to see. */
tree todo = NULL_TREE;
tree usings;
/* Look through namespace aliases. */
result = ambiguous_decl (name, result,
binding_for_name (name, scope), flags);
if (!BINDING_VALUE (result) && !BINDING_TYPE (result))
- /* Consider using directives. */
+ /* Consider using directives. */
for (usings = DECL_NAMESPACE_USING (scope); usings;
usings = TREE_CHAIN (usings))
- /* If this was a real directive, and we have not seen it. */
+ /* If this was a real directive, and we have not seen it. */
if (!TREE_INDIRECT_USING (usings)
&& !purpose_member (TREE_PURPOSE (usings), seen))
todo = tree_cons (TREE_PURPOSE (usings), NULL_TREE, todo);
todo = TREE_CHAIN (todo);
}
else
- scope = NULL_TREE; /* If there never was a todo list. */
+ scope = NULL_TREE; /* If there never was a todo list. */
}
return result != error_mark_node;
}
/* [namespace.memdef]/2 */
/* Set the context of a declaration to scope. Complain if we are not
- outside scope. */
+ outside scope. */
void
set_decl_namespace (decl, scope, friendp)
{
tree old;
- /* Get rid of namespace aliases. */
+ /* Get rid of namespace aliases. */
scope = ORIGINAL_NAMESPACE (scope);
/* It is ok for friends to be qualified in parallel space. */
DECL_CONTEXT (decl) = FROB_CONTEXT (scope);
if (scope != current_namespace)
{
- /* See whether this has been declared in the namespace. */
+ /* See whether this has been declared in the namespace. */
old = namespace_binding (DECL_NAME (decl), scope);
if (!old)
- /* No old declaration at all. */
+ /* No old declaration at all. */
goto complain;
/* A template can be explicitly specialized in any namespace. */
if (processing_explicit_instantiation)
since it can't check for the correct constness at this
point. pushdecl will find those errors later. */
return;
- /* Since decl is a function, old should contain a function decl. */
+ /* Since decl is a function, old should contain a function decl. */
if (!is_overloaded_fn (old))
goto complain;
if (processing_template_decl || processing_specialization)
decl, scope);
}
-/* Compute the namespace where a declaration is defined. */
+/* Compute the namespace where a declaration is defined. */
static tree
decl_namespace (decl)
return global_namespace;
}
-/* Return the namespace where the current declaration is declared. */
+/* Return the namespace where the current declaration is declared. */
tree
current_decl_namespace ()
{
tree result;
- /* If we have been pushed into a different namespace, use it. */
+ /* If we have been pushed into a different namespace, use it. */
if (decl_namespace_list)
return TREE_PURPOSE (decl_namespace_list);
return result;
}
-/* Temporarily set the namespace for the current declaration. */
+/* Temporarily set the namespace for the current declaration. */
void
push_decl_namespace (decl)
decl_namespace_list = TREE_CHAIN (decl_namespace_list);
}
-/* Enter a class or namespace scope. */
+/* Enter a class or namespace scope. */
void
push_scope (t)
pushclass (t, 2);
}
-/* Leave scope pushed by push_scope. */
+/* Leave scope pushed by push_scope. */
void
pop_scope (t)
total number of functions being compared, which should usually be the
case. */
- /* We must find only functions, or exactly one non-function. */
+ /* We must find only functions, or exactly one non-function. */
if (!k->functions)
k->functions = fn;
else if (is_overloaded_fn (k->functions) && is_overloaded_fn (fn))
if (arg_assoc_namespace (k, context))
return 1;
- /* Process baseclasses. */
+ /* Process baseclasses. */
for (i = 0; i < CLASSTYPE_N_BASECLASSES (type); i++)
if (arg_assoc_class (k, TYPE_BINFO_BASETYPE (type, i)))
return 1;
- /* Process friends. */
+ /* Process friends. */
for (list = DECL_FRIENDLIST (TYPE_MAIN_DECL (type)); list;
list = TREE_CHAIN (list))
if (k->name == TREE_PURPOSE (list))
for (friends = TREE_VALUE (list); friends;
friends = TREE_CHAIN (friends))
/* Only interested in global functions with potentially hidden
- (i.e. unqualified) declarations. */
+ (i.e. unqualified) declarations. */
if (TREE_PURPOSE (friends) == error_mark_node && TREE_VALUE (friends)
&& decl_namespace (TREE_VALUE (friends)) == context)
if (add_function (k, TREE_VALUE (friends)))
case ENUMERAL_TYPE:
return arg_assoc_namespace (k, decl_namespace (TYPE_MAIN_DECL (type)));
case OFFSET_TYPE:
- /* Pointer to member: associate class type and value type. */
+ /* Pointer to member: associate class type and value type. */
if (arg_assoc_type (k, TYPE_OFFSET_BASETYPE (type)))
return 1;
return arg_assoc_type (k, TREE_TYPE (type));
/* The basetype is referenced in the first arg type, so just
fall through. */
case FUNCTION_TYPE:
- /* Associate the parameter types. */
+ /* Associate the parameter types. */
if (arg_assoc_args (k, TYPE_ARG_TYPES (type)))
return 1;
- /* Associate the return type. */
+ /* Associate the return type. */
return arg_assoc_type (k, TREE_TYPE (type));
case TEMPLATE_TYPE_PARM:
case BOUND_TEMPLATE_TEMPLATE_PARM:
}
/* Performs Koenig lookup depending on arguments, where fns
- are the functions found in normal lookup. */
+ are the functions found in normal lookup. */
tree
lookup_arg_dependent (name, fns, args)
return k.functions;
}
-/* Process a namespace-alias declaration. */
+/* Process a namespace-alias declaration. */
void
do_namespace_alias (alias, namespace)
{
if (TREE_CODE (namespace) != NAMESPACE_DECL)
{
- /* The parser did not find it, so it's not there. */
+ /* The parser did not find it, so it's not there. */
error ("unknown namespace `%D'", namespace);
return;
}
namespace = ORIGINAL_NAMESPACE (namespace);
- /* Build the alias. */
+ /* Build the alias. */
alias = build_lang_decl (NAMESPACE_DECL, alias, void_type_node);
DECL_NAMESPACE_ALIAS (alias) = namespace;
pushdecl (alias);
}
/* Check a non-member using-declaration. Return the name and scope
- being used, and the USING_DECL, or NULL_TREE on failure. */
+ being used, and the USING_DECL, or NULL_TREE on failure. */
static tree
validate_nonmember_using_decl (decl, scope, name)
abort ();
if (DECL_P (*name))
*name = DECL_NAME (*name);
- /* Make a USING_DECL. */
+ /* Make a USING_DECL. */
return push_using_decl (*scope, *name);
}
-/* Process local and global using-declarations. */
+/* Process local and global using-declarations. */
static void
do_nonmember_using_decl (scope, name, oldval, oldtype, newval, newtype)
return;
}
- /* Check for using functions. */
+ /* Check for using functions. */
if (BINDING_VALUE (decls) && is_overloaded_fn (BINDING_VALUE (decls)))
{
tree tmp, tmp1;
}
}
-/* Process a using-declaration not appearing in class or local scope. */
+/* Process a using-declaration not appearing in class or local scope. */
void
do_toplevel_using_decl (decl)
do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
- /* Copy declarations found. */
+ /* Copy declarations found. */
if (newval)
BINDING_VALUE (binding) = newval;
if (newtype)
return value;
}
-/* Process a using-directive. */
+/* Process a using-directive. */
void
do_using_directive (namespace)
namespace = TREE_OPERAND (namespace, 1);
if (TREE_CODE (namespace) == IDENTIFIER_NODE)
{
- /* Lookup in lexer did not find a namespace. */
+ /* Lookup in lexer did not find a namespace. */
if (!processing_template_decl)
error ("namespace `%T' undeclared", namespace);
return;
projects / platform / upstream / linaro-gcc.git / commitdiff