mirror/gcc
2
0
Fork 0
mirror of git://gcc.gnu.org/git/gcc.git synced 2025-04-05 22:11:30 +08:00
Code Issues Packages Projects Releases Wiki Activity

cp-tree.h, [...]: Remove reference to macros BINDING_SCOPE, BINDING_VALUE and BINDING_TYPE.

Browse Source 
* cp-tree.h, name-lookup.h, decl.c, decl2.c: Remove reference to
	macros 	BINDING_SCOPE, BINDING_VALUE and BINDING_TYPE.

From-SVN: r71848
This commit is contained in:
Gabriel Dos Reis 2003-09-27 01:55:13 +00:00 committed by Gabriel Dos Reis
parent 07a6b250e7
commit 147135cc00
6 changed files with 88 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
gcc/cp/ChangeLog
View File

@ -1,3 +1,8 @@
2003-09-27 Gabriel Dos Reis <gdr@integrable-solutions.net>
* cp-tree.h, name-lookup.h, decl.c, decl2.c: Remove reference to
macros BINDING_SCOPE, BINDING_VALUE and BINDING_TYPE.
2003-09-26 Gabriel Dos Reis <gdr@integrable-solutions.net>
* decl.c (pop_binding_level, suspend_binding_level,
@ -14,7 +19,7 @@
(cp_parser_member_declaration): Use it.
(cp_parser_template_declaration_after_export): Likewise.
2003-09-22 Gabriel Dos Reis <gcc@integrable-solutions.net>
2003-09-22 Gabriel Dos Reis <gdr@integrable-solutions.net>
* cp-tree.h (scope_kind): Add new enumerator.
(keep_next_level): Change parameter type to bool.

6
gcc/cp/cp-tree.h
View File

@ -379,10 +379,10 @@ typedef enum cp_id_kind
/* The IDENTIFIER_BINDING is the innermost cxx_binding for the
identifier. It's PREVIOUS is the next outermost binding. Each
BINDING_VALUE is a DECL for the associated declaration. Thus,
VALUE field is a DECL for the associated declaration. Thus,
name lookup consists simply of pulling off the node at the front
of the list (modulo oddities for looking up the names of types,
and such.) You can use BINDING_SCOPE to determine the scope
and such.) You can use SCOPE field to determine the scope
that bound the name. */
#define IDENTIFIER_BINDING(NODE) \
(LANG_IDENTIFIER_CAST (NODE)->bindings)
@ -394,7 +394,7 @@ typedef enum cp_id_kind
/* If IDENTIFIER_CLASS_VALUE is set, then NODE is bound in the current
class, and IDENTIFIER_CLASS_VALUE is the value binding. This is
just a pointer to the BINDING_VALUE of one of the bindings in the
just a pointer to the VALUE field of one of the bindings in the
IDENTIFIER_BINDINGs list, so any time that this is non-NULL so is
IDENTIFIER_BINDING. */
#define IDENTIFIER_CLASS_VALUE(NODE) \

112
gcc/cp/decl.c
View File

@ -857,7 +857,7 @@ push_binding (tree id, tree decl, cxx_scope* level)
/* Now, fill in the binding information. */
binding->previous = IDENTIFIER_BINDING (id);
BINDING_SCOPE (binding) = level;
binding->scope = level;
INHERITED_VALUE_BINDING_P (binding) = 0;
LOCAL_BINDING_P (binding) = (level != class_binding_level);
@ -953,7 +953,7 @@ push_class_binding (tree id, tree decl)
other purpose. */
note_name_declared_in_class (id, decl);
if (binding && BINDING_SCOPE (binding) == class_binding_level)
if (binding && binding->scope == class_binding_level)
/* Supplement the existing binding. */
result = supplement_binding (IDENTIFIER_BINDING (id), decl);
else
@ -965,11 +965,11 @@ push_class_binding (tree id, tree decl)
because of the possibility of the `struct stat' hack; if DECL is
a class-name or enum-name we might prefer a field-name, or some
such. */
IDENTIFIER_CLASS_VALUE (id) = BINDING_VALUE (IDENTIFIER_BINDING (id));
IDENTIFIER_CLASS_VALUE (id) = IDENTIFIER_BINDING (id)->value;
/* If this is a binding from a base class, mark it as such. */
binding = IDENTIFIER_BINDING (id);
if (BINDING_VALUE (binding) == decl && TREE_CODE (decl) != TREE_LIST)
if (binding->value == decl && TREE_CODE (decl) != TREE_LIST)
{
if (TREE_CODE (decl) == OVERLOAD)
context = CP_DECL_CONTEXT (OVL_CURRENT (decl));
@ -984,7 +984,7 @@ push_class_binding (tree id, tree decl)
else
INHERITED_VALUE_BINDING_P (binding) = 0;
}
else if (BINDING_VALUE (binding) == decl)
else if (binding->value == decl)
/* We only encounter a TREE_LIST when push_class_decls detects an
ambiguity. Such an ambiguity can be overridden by a definition
in this class. */
@ -1015,14 +1015,14 @@ pop_binding (tree id, tree decl)
/* The DECL will be either the ordinary binding or the type
binding for this identifier. Remove that binding. */
if (BINDING_VALUE (binding) == decl)
BINDING_VALUE (binding) = NULL_TREE;
else if (BINDING_TYPE (binding) == decl)
BINDING_TYPE (binding) = NULL_TREE;
if (binding->value == decl)
binding->value = NULL_TREE;
else if (binding->type == decl)
binding->type = NULL_TREE;
else
abort ();
if (!BINDING_VALUE (binding) && !BINDING_TYPE (binding))
if (!binding->value && !binding->type)
{
/* We're completely done with the innermost binding for this
identifier. Unhook it from the list of bindings. */
@ -1031,9 +1031,8 @@ pop_binding (tree id, tree decl)
/* Add it to the free list. */
cxx_binding_free (binding);
/* Clear the BINDING_SCOPE so the garbage collector doesn't walk
it. */
BINDING_SCOPE (binding) = NULL;
/* Clear the SCOPE so the garbage collector doesn't walk it. */
binding->scope = NULL;
}
}
@ -1250,8 +1249,7 @@ poplevel (int keep, int reverse, int functionbody)
ns_binding = NULL_TREE;
if (outer_binding
&& (BINDING_SCOPE (outer_binding)
== current_binding_level->level_chain))
&& outer_binding->scope == current_binding_level->level_chain)
/* We have something like:
int i;
@ -1261,10 +1259,8 @@ poplevel (int keep, int reverse, int functionbody)
keep the binding of the inner `i' in this case. */
pop_binding (DECL_NAME (link), link);
else if ((outer_binding
&& (TREE_CODE (BINDING_VALUE (outer_binding))
== TYPE_DECL))
|| (ns_binding
&& TREE_CODE (ns_binding) == TYPE_DECL))
&& (TREE_CODE (outer_binding->value) == TYPE_DECL))
|| (ns_binding && TREE_CODE (ns_binding) == TYPE_DECL))
/* Here, we have something like:
typedef int I;
@ -1284,9 +1280,8 @@ poplevel (int keep, int reverse, int functionbody)
/* Keep track of what should have happened when we
popped the binding. */
if (outer_binding && BINDING_VALUE (outer_binding))
DECL_SHADOWED_FOR_VAR (link)
= BINDING_VALUE (outer_binding);
if (outer_binding && outer_binding->value)
DECL_SHADOWED_FOR_VAR (link) = outer_binding->value;
/* Add it to the list of dead variables in the next
outermost binding to that we can remove these when we
@ -1297,8 +1292,8 @@ poplevel (int keep, int reverse, int functionbody)
dead_vars_from_for);
/* Although we don't pop the cxx_binding, we do clear
its BINDING_SCOPE since the level is going away now. */
BINDING_SCOPE (IDENTIFIER_BINDING (DECL_NAME (link))) = 0;
its SCOPE since the scope is going away now. */
IDENTIFIER_BINDING (DECL_NAME (link))->scope = NULL;
}
}
else
@ -1502,12 +1497,12 @@ poplevel_class (void)
cxx_binding *binding;
binding = IDENTIFIER_BINDING (TREE_PURPOSE (shadowed));
while (binding && BINDING_SCOPE (binding) != b)
while (binding && binding->scope != b)
binding = binding->previous;
if (binding)
IDENTIFIER_CLASS_VALUE (TREE_PURPOSE (shadowed))
= BINDING_VALUE (binding);
= binding->value;
}
}
else
@ -2177,10 +2172,10 @@ set_identifier_type_value_with_scope (tree id,
binding_for_name (NAMESPACE_LEVEL (current_namespace), id);
if (decl)
{
if (BINDING_VALUE (binding))
if (binding->value)
supplement_binding (binding, decl);
else
BINDING_VALUE (binding) = decl;
binding->value = decl;
}
else
abort ();
@ -4108,9 +4103,9 @@ push_class_level_binding (tree name, tree x)
class, then we will need to restore IDENTIFIER_CLASS_VALUE when
we leave this class. Record the shadowed declaration here. */
binding = IDENTIFIER_BINDING (name);
if (binding && BINDING_VALUE (binding))
if (binding && binding->value)
{
tree bval = BINDING_VALUE (binding);
tree bval = binding->value;
tree old_decl = NULL_TREE;
if (INHERITED_VALUE_BINDING_P (binding))
@ -4122,9 +4117,9 @@ push_class_level_binding (tree name, tree x)
if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval)
&& !(TREE_CODE (x) == TYPE_DECL && DECL_ARTIFICIAL (x)))
{
old_decl = BINDING_TYPE (binding);
BINDING_TYPE (binding) = bval;
BINDING_VALUE (binding) = NULL_TREE;
old_decl = binding->type;
binding->type = bval;
binding->value = NULL_TREE;
INHERITED_VALUE_BINDING_P (binding) = 0;
}
else
@ -4151,7 +4146,7 @@ push_class_level_binding (tree name, tree x)
if (TREE_PURPOSE (shadow) == name
&& TREE_TYPE (shadow) == old_decl)
{
BINDING_VALUE (binding) = x;
binding->value = x;
INHERITED_VALUE_BINDING_P (binding) = 0;
TREE_TYPE (shadow) = x;
IDENTIFIER_CLASS_VALUE (name) = x;
@ -4330,7 +4325,7 @@ push_overloaded_decl (tree decl, int flags)
{
tree *d;
for (d = &BINDING_SCOPE (IDENTIFIER_BINDING (name))->names;
for (d = &IDENTIFIER_BINDING (name)->scope->names;
*d;
d = &TREE_CHAIN (*d))
if (*d == old
@ -4346,8 +4341,7 @@ push_overloaded_decl (tree decl, int flags)
TREE_CHAIN (*d));
/* And update the cxx_binding node. */
BINDING_VALUE (IDENTIFIER_BINDING (name))
= new_binding;
IDENTIFIER_BINDING (name)->value = new_binding;
POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, decl);
}
@ -4983,7 +4977,7 @@ follow_tag_typedef (tree type)
/* Given NAME, an IDENTIFIER_NODE,
return the structure (or union or enum) definition for that name.
Searches binding levels from BINDING_SCOPE up to the global level.
Searches binding levels from its SCOPE up to the global level.
If THISLEVEL_ONLY is nonzero, searches only the specified context
(but skips any sk_cleanup contexts to find one that is
meaningful for tags).
@ -5027,9 +5021,9 @@ lookup_tag (enum tree_code form, tree name,
class declaration, then we use the _TYPE node for the
template. See the example below. */
if (thislevel_only && !allow_template_parms_p
&& binding && BINDING_VALUE (binding)
&& DECL_CLASS_TEMPLATE_P (BINDING_VALUE (binding)))
old = BINDING_VALUE (binding);
&& binding && binding->value
&& DECL_CLASS_TEMPLATE_P (binding->value))
old = binding->value;
else if (binding)
old = select_decl (binding, LOOKUP_PREFER_TYPES);
else
@ -5472,7 +5466,7 @@ static tree
select_decl (cxx_binding *binding, int flags)
{
tree val;
val = BINDING_VALUE (binding);
val = binding->value;
timevar_push (TV_NAME_LOOKUP);
if (LOOKUP_NAMESPACES_ONLY (flags))
@ -5485,9 +5479,8 @@ select_decl (cxx_binding *binding, int flags)
/* If looking for a type, or if there is no non-type binding, select
the value binding. */
if (BINDING_TYPE (binding)
&& (!val || (flags & LOOKUP_PREFER_TYPES)))
val = BINDING_TYPE (binding);
if (binding->type && (!val || (flags & LOOKUP_PREFER_TYPES)))
val = binding->type;
/* 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
@ -5524,16 +5517,14 @@ unqualified_namespace_lookup (tree name, int flags, tree* spacesp)
*spacesp = tree_cons (scope, NULL_TREE, *spacesp);
/* Ignore anticipated built-in functions. */
if (b && BINDING_VALUE (b)
&& DECL_P (BINDING_VALUE (b))
&& DECL_LANG_SPECIFIC (BINDING_VALUE (b))
&& DECL_ANTICIPATED (BINDING_VALUE (b)))
if (b && b->value && DECL_P (b->value)
&& DECL_LANG_SPECIFIC (b->value) && DECL_ANTICIPATED (b->value))
/* Keep binding cleared. */;
else if (b)
{
/* Initialize binding for this context. */
binding.value = BINDING_VALUE (b);
binding.type = BINDING_TYPE (b);
binding.value = b->value;
binding.type = b->type;
}
/* Add all _DECLs seen through local using-directives. */
@ -5760,11 +5751,11 @@ lookup_name_real (tree name, int prefer_type, int nonclass,
continue;
/* If this is the kind of thing we're looking for, we're done. */
if (qualify_lookup (BINDING_VALUE (iter), flags))
binding = BINDING_VALUE (iter);
if (qualify_lookup (iter->value, flags))
binding = iter->value;
else if ((flags & LOOKUP_PREFER_TYPES)
&& qualify_lookup (BINDING_TYPE (iter), flags))
binding = BINDING_TYPE (iter);
&& qualify_lookup (iter->type, flags))
binding = iter->type;
else
binding = NULL_TREE;
@ -5836,7 +5827,7 @@ lookup_name_current_level (tree name)
{
while (1)
{
if (BINDING_SCOPE (IDENTIFIER_BINDING (name)) == b)
if (IDENTIFIER_BINDING (name)->scope == b)
POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, IDENTIFIER_VALUE (name));
if (b->kind == sk_cleanup)
@ -7773,12 +7764,11 @@ maybe_inject_for_scope_var (tree decl)
cxx_binding *outer_binding
= IDENTIFIER_BINDING (DECL_NAME (decl))->previous;
if (outer_binding && BINDING_SCOPE (outer_binding) == outer
&& (TREE_CODE (BINDING_VALUE (outer_binding)) == VAR_DECL)
&& DECL_DEAD_FOR_LOCAL (BINDING_VALUE (outer_binding)))
if (outer_binding && outer_binding->scope == outer
&& (TREE_CODE (outer_binding->value) == VAR_DECL)
&& DECL_DEAD_FOR_LOCAL (outer_binding->value))
{
BINDING_VALUE (outer_binding)
= DECL_SHADOWED_FOR_VAR (BINDING_VALUE (outer_binding));
outer_binding->value = DECL_SHADOWED_FOR_VAR (outer_binding->value);
current_binding_level->kind = sk_block;
}
}

43
gcc/cp/decl2.c
View File

@ -3159,7 +3159,7 @@ ambiguous_decl (tree name, cxx_binding *old, cxx_binding *new, int flags)
tree val, type;
my_friendly_assert (old != NULL, 393);
/* Copy the value. */
val = BINDING_VALUE (new);
val = new->value;
if (val)
switch (TREE_CODE (val))
{
@ -3188,43 +3188,43 @@ ambiguous_decl (tree name, cxx_binding *old, cxx_binding *new, int flags)
val = NULL_TREE;
}
if (!BINDING_VALUE (old))
BINDING_VALUE (old) = val;
else if (val && val != BINDING_VALUE (old))
if (!old->value)
old->value = val;
else if (val && val != old->value)
{
if (is_overloaded_fn (BINDING_VALUE (old)) && is_overloaded_fn (val))
BINDING_VALUE (old) = merge_functions (BINDING_VALUE (old), val);
if (is_overloaded_fn (old->value) && is_overloaded_fn (val))
old->value = merge_functions (old->value, val);
else
{
/* Some declarations are functions, some are not. */
if (flags & LOOKUP_COMPLAIN)
{
/* If we've already given this error for this lookup,
BINDING_VALUE (old) is error_mark_node, so let's not
old->value is error_mark_node, so let's not
repeat ourselves. */
if (BINDING_VALUE (old) != error_mark_node)
if (old->value != error_mark_node)
{
error ("use of `%D' is ambiguous", name);
cp_error_at (" first declared as `%#D' here",
BINDING_VALUE (old));
old->value);
}
cp_error_at (" also declared as `%#D' here", val);
}
BINDING_VALUE (old) = error_mark_node;
old->value = error_mark_node;
}
}
/* ... and copy the type. */
type = BINDING_TYPE (new);
type = new->type;
if (LOOKUP_NAMESPACES_ONLY (flags))
type = NULL_TREE;
if (!BINDING_TYPE (old))
BINDING_TYPE (old) = type;
else if (type && BINDING_TYPE (old) != type)
if (!old->type)
old->type = type;
else if (type && old->type != type)
{
if (flags & LOOKUP_COMPLAIN)
{
error ("`%D' denotes an ambiguous type",name);
error ("%J first type here", TYPE_MAIN_DECL (BINDING_TYPE (old)));
error ("%J first type here", TYPE_MAIN_DECL (old->type));
error ("%J other type here", TYPE_MAIN_DECL (type));
}
}
@ -3258,8 +3258,7 @@ lookup_using_namespace (tree name, cxx_binding *val, tree usings, tree scope,
if (val1)
val = ambiguous_decl (name, val, val1, flags);
}
POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP,
BINDING_VALUE (val) != error_mark_node);
POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, val->value != error_mark_node);
}
/* [namespace.qual]
@ -3286,7 +3285,7 @@ qualified_lookup_using_namespace (tree name, tree scope, cxx_binding *result,
seen = tree_cons (scope, NULL_TREE, seen);
if (binding)
result = ambiguous_decl (name, result, binding, flags);
if (!BINDING_VALUE (result) && !BINDING_TYPE (result))
if (!result->value && !result->type)
/* Consider using directives. */
for (usings = DECL_NAMESPACE_USING (scope); usings;
usings = TREE_CHAIN (usings))
@ -3993,16 +3992,16 @@ do_toplevel_using_decl (tree decl)
binding = binding_for_name (NAMESPACE_LEVEL (current_namespace), name);
oldval = BINDING_VALUE (binding);
oldtype = BINDING_TYPE (binding);
oldval = binding->value;
oldtype = binding->type;
do_nonmember_using_decl (scope, name, oldval, oldtype, &newval, &newtype);
/* Copy declarations found. */
if (newval)
BINDING_VALUE (binding) = newval;
binding->value = newval;
if (newtype)
BINDING_TYPE (binding) = newtype;
binding->type = newtype;
return;
}

14
gcc/cp/name-lookup.c
View File

@ -336,7 +336,7 @@ supplement_binding (cxx_binding *binding, tree decl)
else if (TREE_CODE (bval) == TYPE_DECL && DECL_ARTIFICIAL (bval))
{
/* The old binding was a type name. It was placed in
BINDING_VALUE because it was thought, at the point it was
VALUE field because it was thought, at the point it was
declared, to be the only entity with such a name. Move the
type name into the type slot; it is now hidden by the new
binding. */
@ -395,7 +395,7 @@ find_binding (cxx_scope *scope, cxx_binding *binding)
timevar_push (TV_NAME_LOOKUP);
for (; binding != NULL; binding = binding->previous)
if (BINDING_SCOPE (binding) == scope)
if (binding->scope == scope)
POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, binding);
POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (cxx_binding *)0);
@ -409,7 +409,7 @@ cxx_scope_find_binding_for_name (cxx_scope *scope, tree name)
if (b)
{
/* Fold-in case where NAME is used only once. */
if (scope == BINDING_SCOPE (b) && b->previous == NULL)
if (scope == b->scope && b->previous == NULL)
return b;
return find_binding (scope, b);
}
@ -430,7 +430,7 @@ binding_for_name (cxx_scope *scope, tree name)
/* Not found, make a new one. */
result = cxx_binding_make (NULL, NULL);
result->previous = IDENTIFIER_NAMESPACE_BINDINGS (name);
BINDING_SCOPE (result) = scope;
result->scope = scope;
result->is_local = false;
result->value_is_inherited = false;
IDENTIFIER_NAMESPACE_BINDINGS (name) = result;
@ -465,10 +465,8 @@ set_namespace_binding (tree name, tree scope, tree val)
if (scope == NULL_TREE)
scope = global_namespace;
b = binding_for_name (NAMESPACE_LEVEL (scope), name);
if (!BINDING_VALUE (b)
|| TREE_CODE (val) == OVERLOAD
|| val == error_mark_node)
BINDING_VALUE (b) = val;
if (!b->value || TREE_CODE (val) == OVERLOAD || val == error_mark_node)
b->value = val;
else
supplement_binding (b, val);
timevar_pop (TV_NAME_LOOKUP);

14
gcc/cp/name-lookup.h
View File

@ -72,22 +72,10 @@ typedef struct cp_binding_level cxx_scope;
or namespace scope. */
#define LOCAL_BINDING_P(NODE) ((NODE)->is_local)
/* Nonzero if BINDING_VALUE is from a base class of the class which is
/* True if NODE->value is from a base class of the class which is
currently being defined. */
#define INHERITED_VALUE_BINDING_P(NODE) ((NODE)->value_is_inherited)
/* For a binding between a name and an entity at a non-local scope,
defines the scope where the binding is declared. (Either a class
_TYPE node, or a NAMESPACE_DECL.). */
#define BINDING_SCOPE(NODE) ((NODE)->scope)
/* This is the declaration bound to the name. Possible values:
variable, overloaded function, namespace, template, enumerator. */
#define BINDING_VALUE(NODE) ((NODE)->value)
/* If name is bound to a type, this is the type (struct, union, enum). */
#define BINDING_TYPE(NODE) ((NODE)->type)
/* Zero out a cxx_binding pointed to by B. */
#define cxx_binding_clear(B) memset ((B), 0, sizeof (cxx_binding))