From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- gcc/testsuite/g++.old-deja/g++.benjamin/scope02.C | 208 ++++++++++++++++++++++ 1 file changed, 208 insertions(+) create mode 100644 gcc/testsuite/g++.old-deja/g++.benjamin/scope02.C (limited to 'gcc/testsuite/g++.old-deja/g++.benjamin/scope02.C') diff --git a/gcc/testsuite/g++.old-deja/g++.benjamin/scope02.C b/gcc/testsuite/g++.old-deja/g++.benjamin/scope02.C new file mode 100644 index 000000000..1ff541b88 --- /dev/null +++ b/gcc/testsuite/g++.old-deja/g++.benjamin/scope02.C @@ -0,0 +1,208 @@ +// { dg-do assemble } +//980529 bkoz +//3.4.5 Class member access via pointer and non-pointer +// non-nested dtor calls + +int counter = 0; + +struct X { + int rank; + X(int init = 64) : rank(init) { } + ~X() { ++counter; } + typedef X classtype; +}; +typedef X globaltype; + +#if 0 +template +struct X_tem { + T rank; + X_tem(T init = T(64) ) : rank(init) { } + ~X_tem() { ++counter; } + typedef X_tem classtype_tem; +}; +typedef X_tem globaltype_tem; +#endif + + + + +int main(void) +{ + // 3.4.5 Class member access + // p 2 + // if the id-expression in a class member access is an + // unqualified-id, and the type of the object expression is of class + // type C (or pointer to class type C), the unqualified-id is looked + // up in the scope of class C. If the type of the object-expression + // is of pointer to scalar type, the unqualified-id is looked up in + // the context of the complete postfix-expression. + + // p 3 + // if the unqualitified id is ~type-name, and the type of the object + // expression is of a class type C (or pointer to class type C), the + // type-name is looked up in the context of the entire + // postfix-expression and in the scope of class C. The type-name + // shall refer to a class-name. If type-name is found in both + // contexts, the name shall refer to the same class type. If the + // type of the object expression is of scalar type, the type-name is + // looked up in the complete postfix-expression. + + typedef X localtype; + + // + // 1 non-templatized, pointer, unqualified + // + X x01 ; + X *px = &x01; + px->~X(); + + X x02 (66); + px = &x02; + px->~localtype(); + + X x03 (68); + px = &x03; + px->~classtype(); //-g++ //p3: unqual-id lookup in object and postfix-expr + + X x04 (70); + px = &x04; + px->~globaltype(); + + + // p 1 + // . . . the id-expression is first looked up in the class of the + // object-expression. If the identifier is not found, itis then + // looked up in the context of the entier postfix-expression and + // shall name a class or function template. If the lookup in the + // class of the object-expression finds a template, the name is also + // looked up in teh context of the entier postfix-expression and + // 1 if the name is not found, use the name from the object-expr + // 2 if the name found in postfix-expr != class template, use object-expr + // 3 if name found is class template, name must match object-expr or error + + // p 4 + + // if the id-expr in a class member acess is a qualified-id, the + // id-expression is looked up in both the context of the entire + // postfix-expr and in the scope of the class of the object-expr. If + // the name is found in both contexts, the id-expr shall refer to + // the same entity. + + + // + // 2 non-templatized, pointer, qualified + // + X x05 ; + px = &x05; + px->X::~X(); + + X x06 (66); + px = &x06; + px->X::~localtype(); + + X x07 (68); + px = &x07; + px->X::~classtype(); // -edg + + X x08 (70); + px = &x08; + px->X::~globaltype(); + + X x09 (66); + px = &x09; + px->localtype::~localtype(); + + X x10 (68); + px = &x10; + px->classtype::~classtype(); + + X x11 (70); + px = &x11; + px->globaltype::~globaltype(); + + X x12 (66); + px = &x12; + px->classtype::~localtype(); + + X x13 (68); + px = &x13; + px->globaltype::~localtype(); + + X x14 (70); + px = &x14; + px->localtype::~globaltype(); + + X x15 (70); + px = &x15; + px->classtype::~globaltype(); + + X x16 (70); + px = &x16; + px->localtype::~classtype(); //-edg + + X x17 (70); + px = &x17; + px->globaltype::~classtype(); //-edg + +#if 0 + // + // non-templatized, non-pointer + // + X xo5 ; + xo5.~X(); //unqualified + + localtype xo6 (66); + xo6.~localtype(); + + X xo7 (68); + xo7.~classtype(); + + X xo8 (70); + xo8.~globaltype(); + + + // + // templatized, pointer + // + X_tem xto1 ; + X_tem *pxt = &xto1; + pxt->~X_tem(); //unqualified + + typedef X_tem localtype_tem; + localtype_tem xto2 (66); + pxt = &xto2; + pxt->~localtype_tem(); + + //paragraph 2: unqualitifed id looked up in scope of post-fix expr if object + X_tem xto3 (68); + pxt = &xto3; + pxt->~classtype_tem(); + + X_tem xto4 (70); + pxt = &xto4; + pxt->~globaltype_tem(); + + // + // templatized, non-pointer + // + X_tem xto5 ; + xto5.~X_tem(); //unqualified + + localtype_tem xto6 (66); + xto6.~localtype_tem(); + + X_tem xto7 (68); + xto7.~classtype_tem(); + + X_tem xto8 (70); + xto8.~globaltype_tem(); +#endif + return 0; +} + + + + + + -- cgit v1.2.3