OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Remove DR 295 implementation.

Browse Source 
cp:
	Remove DR 295 implementation.
	* pt.c (check_cv_quals_for_unify): Disable function & method cases.
	* tree.c (cp_build_qualified_type_real): Likewise. Don't warn
	about ignoring volatile qualifiers.

	* search.c (lookup_member): Correct documentation.
testsuite:
	* g++.dg/template/qualttp20.C: Adjust expected errors.
	* g++.old-deja/g++.jason/report.C: Likewise.
	* g++.old-deja/g++.other/qual1.C: Likewise.

From-SVN: r57209
This commit is contained in:
Nathan Sidwell 2002-09-16 19:09:05 +00:00 committed by Nathan Sidwell
parent 0e9cab878b
commit 171d2f505b
7 changed files with 48 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
gcc/cp/ChangeLog
View File

@ -1,3 +1,12 @@
2002-09-16 Nathan Sidwell <nathan@codesourcery.com>
Remove DR 295 implementation.
* pt.c (check_cv_quals_for_unify): Disable function & method cases.
* tree.c (cp_build_qualified_type_real): Likewise. Don't warn
about ignoring volatile qualifiers.
* search.c (lookup_member): Correct documentation.
2002-09-16 Geoffrey Keating <geoffk@apple.com>
* cp-tree.h (union lang_tree_node): Add chain_next option.

4
gcc/cp/pt.c
View File

@ -8570,9 +8570,7 @@ check_cv_quals_for_unify (strict, arg, parm)
{
/* If the cvr quals of parm will not unify with ARG, they'll be
ignored in instantiation, so we have to do the same here. */
if (TREE_CODE (arg) == REFERENCE_TYPE
|| TREE_CODE (arg) == FUNCTION_TYPE
|| TREE_CODE (arg) == METHOD_TYPE)
if (TREE_CODE (arg) == REFERENCE_TYPE)
parm_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
if (!POINTER_TYPE_P (arg) &&
TREE_CODE (arg) != TEMPLATE_TYPE_PARM)

17
gcc/cp/search.c
View File

@ -1400,15 +1400,16 @@ build_baselink (tree binfo, tree access_binfo, tree functions, tree optype)
}
/* Look for a member named NAME in an inheritance lattice dominated by
XBASETYPE. If PROTECT is 0 or two, we do not check access. If it is
1, we enforce accessibility. If PROTECT is zero, then, for an
ambiguous lookup, we return NULL. If PROTECT is 1, we issue an
error message. If PROTECT is 2, we return a TREE_LIST whose
TREE_TYPE is error_mark_node and whose TREE_VALUEs are the list of
ambiguous candidates.
XBASETYPE. If PROTECT is 0 or two, we do not check access. If it
is 1, we enforce accessibility. If PROTECT is zero, then, for an
ambiguous lookup, we return NULL. If PROTECT is 1, we issue error
messages about inaccessible or ambiguous lookup. If PROTECT is 2,
we return a TREE_LIST whose TREE_TYPE is error_mark_node and whose
TREE_VALUEs are the list of ambiguous candidates.
WANT_TYPE is 1 when we should only return TYPE_DECLs, if no
TYPE_DECL can be found return NULL_TREE. */
WANT_TYPE is 1 when we should only return TYPE_DECLs.
If nothing can be found return NULL_TREE and do not issue an error. */
tree
lookup_member (xbasetype, name, protect, want_type)

15
gcc/cp/tree.c
View File

@ -577,6 +577,11 @@ cp_build_qualified_type_real (type, type_quals, complain)
{
tree result;
int bad_quals = TYPE_UNQUALIFIED;
/* We keep bad function qualifiers separate, so that we can decide
whether to implement DR 295 or not. DR 295 break existing code,
unfortunately. Remove this variable to implement the defect
report. */
int bad_func_quals = TYPE_UNQUALIFIED;
if (type == error_mark_node)
return type;
@ -592,6 +597,8 @@ cp_build_qualified_type_real (type, type_quals, complain)
|| TREE_CODE (type) == METHOD_TYPE))
{
bad_quals |= type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
if (TREE_CODE (type) != REFERENCE_TYPE)
bad_func_quals |= type_quals & (TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
type_quals &= ~(TYPE_QUAL_CONST | TYPE_QUAL_VOLATILE);
}
@ -610,21 +617,23 @@ cp_build_qualified_type_real (type, type_quals, complain)
/*OK*/;
else if (!(complain & (tf_error | tf_ignore_bad_quals)))
return error_mark_node;
else if (bad_func_quals && !(complain & tf_error))
return error_mark_node;
else
{
if (complain & tf_ignore_bad_quals)
/* We're not going to warn about constifying things that can't
be constified. */
bad_quals &= ~TYPE_QUAL_CONST;
bad_quals |= bad_func_quals;
if (bad_quals)
{
tree bad_type = build_qualified_type (ptr_type_node, bad_quals);
if (!(complain & tf_ignore_bad_quals))
if (!(complain & tf_ignore_bad_quals)
|| bad_func_quals)
error ("`%V' qualifiers cannot be applied to `%T'",
bad_type, type);
else if (complain & tf_warning)
warning ("ignoring `%V' qualifiers on `%T'", bad_type, type);
}
}

20
gcc/testsuite/g++.dg/template/qualttp20.C
View File

@ -16,18 +16,20 @@ struct AS
template <typename T> struct B1 : T
{
typedef typename T::L __restrict__ r;// { dg-error "`__restrict' qualifiers cannot" "" }
typedef typename T::myT __restrict__ p;// { dg-warning "ignoring `__restrict'" "" }
typedef typename T::myT volatile *myvolatile; // { dg-warning "ignoring `volatile'" "" }
typename T::myT volatile *a; // { dg-warning "ignoring `volatile'" "" }
myvolatile b; // { dg-bogus "ignoring `volatile'" "" { xfail *-*-* } }
typedef typename T::myT __restrict__ p;// { dg-warning "ignoring `__restrict'" "" { xfail *-*-* } }
// The following are DR 295 dependent
typedef typename T::myT volatile *myvolatile; // { dg-error "qualifiers" "" }
typename T::myT volatile *a; // { dg-error "qualifiers" "" }
myvolatile b; // { dg-error "qualifiers" "" }
};
template <typename T> struct B2 : T
{
typedef typename T::myT const *myconst;
typename T::myT const *a;
myconst b;
// The following are DR 295 dependent
typedef typename T::myT const *myconst; // { dg-error "qualifiers" "" }
typename T::myT const *a; // { dg-error "qualifiers" "" }
myconst b; // { dg-error "qualifiers" "" }
};
B1<AS> b1; // { dg-error "instantiated" "" }
B2<AS> b2;
B2<AS> b2; // { dg-error "instantiated" "" }

5
gcc/testsuite/g++.old-deja/g++.jason/report.C
View File

@ -46,8 +46,9 @@ class X{
};
typedef int const * bart ();
typedef bart const * const * bar2; // ok - constifying qualifiers
typedef bart volatile * const * bar2v; // WARNING - qualifiers
//The following is DR295 dependant
typedef bart const * const * bar2; // ERROR - constifying qualifiers
typedef bart volatile * const * bar2v; // ERROR - qualifiers
bar2 baz (X::Y y)
{ // ERROR - in this context

5
gcc/testsuite/g++.old-deja/g++.other/qual1.C
View File

@ -10,8 +10,9 @@ class
{
public:
func_type *Function;
const func_type* function(void) { return Function; } // ok constifying
volatile func_type* functionv(void); // WARNING - qualifier
// The following is DR 295 dependent
const func_type* function(void) { return Function; } // ERROR - constifying
volatile func_type* functionv(void); // ERROR - qualifier
} action;
void work(const char *source)