Re: [rfa/c++testsuite] The remaining v3 testsuite fixes (or at least most of them)

Jim Blandy
2001-12-07T21:48:01Z

Please commit this, and the static member test patch above. Thanks!

Daniel Jacobowitz <drow@mvista.com> writes:
> [This patch includes my previous patch today, for the static member test,
> but not its changelog; I will commit them separately, but editing it out of
> this diff would have been tricky.]
>
> These are mostly "more of the same" demangler changes:
> - const & -> const ?&
> - \\(void\\) -> \\((void|)\\)
>
> There are also changes to accept classes without the explicit vtbl member,
> or the implicit int parameter that v2 seemed to use to construct classes
> with virtual bases. I also allow the function name in "Breakpoint at "
> messages to contain the base demangled name, including argument list; makes
> sense for overloaded functions.
>
> I currently except class data printouts with explicit "_vptr.vC = $hex"
> style entries. I can suppress those if people think that better, but I'd
> rather get this in first; so I labelled the passes with FIXMEs. Our
> handling of these is a little inconsistent.
>
> These handle all the tests that should pass in my current half-submitted
> codebase, and only changes the name of one FAIL and one FAIL to PASS in the
> v2 test results:
>
> 111c111
> < FAIL: gdb.c++/classes.exp: continue to enums2
> ---
> > FAIL: gdb.c++/classes.exp: continue to enums2(\(\)|)
> 1342c1342
> < FAIL: gdb.c++/namespace.exp: info func xyzq
> ---
> > PASS: gdb.c++/namespace.exp: info func xyzq
>
> (The fail was because the testsuite expected functions to be sorted by
> basename and not by full name including namespace).
>
> Is this OK to commit?
>
> --
> Daniel Jacobowitz Carnegie Mellon University
> MontaVista Software Debian GNU/Linux Developer
>
>
> 2001-12-05 Daniel Jacobowitz <drow@mvista.com>
>
> * gdb.c++/classes.exp, gdb.c++/derivation.exp,
> gdb.c++/inherit.exp, gdb.c++/method.exp,
> gdb.c++/namespace.exp, gdb.c++/templates.exp,
> gdb.c++/userdef.exp, gdb.c++/virtfunc.exp: Updates for v3 demangler
> and class layout support.
>
>
> Index: gdb.c++/classes.exp
> ===================================================================
> RCS file: /cvs/src/src/gdb/testsuite/gdb.c++/classes.exp,v
> retrieving revision 1.8
> diff -u -p -r1.8 classes.exp
> --- classes.exp 2001/07/03 19:52:46 1.8
> +++ classes.exp 2001/12/05 22:48:25
> @@ -239,10 +239,10 @@ proc test_ptype_class_objects {} {
> setup_xfail_format "DWARF 1"
> send_gdb "ptype class B\n"
> gdb_expect {
> - -re "type = class B : public A \{${ws}public:${ws}int b;${ws}int x;${ws}B & operator=\\(B const &\\);${ws}B\\(B const &\\);${ws}B\\((void|)\\);${ws}\}$nl$gdb_prompt $" {
> + -re "type = class B : public A \{${ws}public:${ws}int b;${ws}int x;${ws}B & operator=\\(B const ?&\\);${ws}B\\(B const ?&\\);${ws}B\\((void|)\\);${ws}\}$nl$gdb_prompt $" {
> pass "ptype class B"
> }
> - -re "type = class B : public A \{${ws}public:${ws}int b;${ws}int x;((${ws}B & operator=\\(B const &\\);)|(${ws}B\\(B const &\\);)|(${ws}B\\((void|)\\);))*${ws}\}$nl$gdb_prompt $" {
> + -re "type = class B : public A \{${ws}public:${ws}int b;${ws}int x;((${ws}B & operator=\\(B const ?&\\);)|(${ws}B\\(B const ?&\\);)|(${ws}B\\((void|)\\);))*${ws}\}$nl$gdb_prompt $" {
> pass "ptype class B (obsolescent gcc or gdb)"
> }
> -re ".*$gdb_prompt $" {
> @@ -257,10 +257,10 @@ proc test_ptype_class_objects {} {
> setup_xfail_format "DWARF 1"
> send_gdb "ptype class C\n"
> gdb_expect {
> - -re "type = class C : public A \{${ws}public:${ws}int c;${ws}int x;${ws}C & operator=\\(C const &\\);${ws}C\\(C const &\\);${ws}C\\((void|)\\);${ws}\}$nl$gdb_prompt $" {
> + -re "type = class C : public A \{${ws}public:${ws}int c;${ws}int x;${ws}C & operator=\\(C const ?&\\);${ws}C\\(C const ?&\\);${ws}C\\((void|)\\);${ws}\}$nl$gdb_prompt $" {
> pass "ptype class C"
> }
> - -re "type = class C : public A \{${ws}public:${ws}int c;${ws}int x;((${ws}C & operator=\\(C const &\\);)|(${ws}C\\(C const &\\);)|(${ws}C\\((void|)\\);))*${ws}\}$nl$gdb_prompt $" {
> + -re "type = class C : public A \{${ws}public:${ws}int c;${ws}int x;((${ws}C & operator=\\(C const ?&\\);)|(${ws}C\\(C const ?&\\);)|(${ws}C\\((void|)\\);))*${ws}\}$nl$gdb_prompt $" {
> pass "ptype class C (obsolescent gcc or gdb)"
> }
> -re ".*$gdb_prompt $" {
> @@ -275,10 +275,10 @@ proc test_ptype_class_objects {} {
> setup_xfail_format "DWARF 1"
> send_gdb "ptype class D\n"
> gdb_expect {
> - -re "type = class D : public B, public C \{${ws}public:${ws}int d;${ws}int x;${ws}D & operator=\\(D const &\\);${ws}D\\(D const &\\);${ws}D\\((void|)\\);${ws}\}$nl$gdb_prompt $" {
> + -re "type = class D : public B, public C \{${ws}public:${ws}int d;${ws}int x;${ws}D & operator=\\(D const ?&\\);${ws}D\\(D const ?&\\);${ws}D\\((void|)\\);${ws}\}$nl$gdb_prompt $" {
> pass "ptype class D"
> }
> - -re "type = class D : public B, public C \{${ws}public:${ws}int d;${ws}int x;((${ws}D & operator=\\(D const &\\);)|(${ws}D\\(D const &\\);)|(${ws}D\\((void|)\\);))*${ws}\}$nl$gdb_prompt $" {
> + -re "type = class D : public B, public C \{${ws}public:${ws}int d;${ws}int x;((${ws}D & operator=\\(D const ?&\\);)|(${ws}D\\(D const ?&\\);)|(${ws}D\\((void|)\\);))*${ws}\}$nl$gdb_prompt $" {
> pass "ptype class D (obsolescent gcc or gdb)"
> }
> -re ".*$gdb_prompt $" {
> @@ -293,10 +293,10 @@ proc test_ptype_class_objects {} {
> setup_xfail_format "DWARF 1"
> send_gdb "ptype class E\n"
> gdb_expect {
> - -re "type = class E : public D \{${ws}public:${ws}int e;${ws}int x;${ws}E & operator=\\(E const &\\);${ws}E\\(E const &\\);${ws}E\\((void|)\\);${ws}\}$nl$gdb_prompt $" {
> + -re "type = class E : public D \{${ws}public:${ws}int e;${ws}int x;${ws}E & operator=\\(E const ?&\\);${ws}E\\(E const ?&\\);${ws}E\\((void|)\\);${ws}\}$nl$gdb_prompt $" {
> pass "ptype class E"
> }
> - -re "type = class E : public D \{${ws}public:${ws}int e;${ws}int x;((${ws}E & operator=\\(E const &\\);)|(${ws}E\\(E const &\\);)|(${ws}E\\((void|)\\);))*${ws}\}$nl$gdb_prompt $" {
> + -re "type = class E : public D \{${ws}public:${ws}int e;${ws}int x;((${ws}E & operator=\\(E const ?&\\);)|(${ws}E\\(E const ?&\\);)|(${ws}E\\((void|)\\);))*${ws}\}$nl$gdb_prompt $" {
> pass "ptype class E"
> }
> -re ".*$gdb_prompt $" {
> @@ -308,12 +308,28 @@ proc test_ptype_class_objects {} {
> }
> }
>
> + # With g++ 2.x and stabs debug info, we misinterpret static methods
> + # whose name matches their argument mangling.
> + send_gdb "ptype class Static\n"
> + gdb_expect {
> + -re "type = (class|struct) Static \{(${ws}public:|)${ws}Static & operator=\\(Static const ?&\\);${ws}Static\\(Static const ?&\\);${ws}Static\\((void|)\\);${ws}static void ii\\(int, int\\);${ws}\}$nl$gdb_prompt $" {
> + pass "ptype class Static"
> + }
> + -re ".*$gdb_prompt $" {
> + fail "ptype class Static"
> + }
> + timeout {
> + fail "ptype class Static (timeout)"
> + return
> + }
> + }
> +
> send_gdb "ptype class vA\n"
> gdb_expect {
> - -re "type = (class|struct) vA \{(${ws}public:|)${ws}int va;${ws}int vx;${ws}vA & operator=\\(vA const &\\);${ws}vA\\(vA const &\\);${ws}vA\\((void|)\\);${ws}\}$nl$gdb_prompt $" {
> + -re "type = (class|struct) vA \{(${ws}public:|)${ws}int va;${ws}int vx;${ws}vA & operator=\\(vA const ?&\\);${ws}vA\\(vA const ?&\\);${ws}vA\\((void|)\\);${ws}\}$nl$gdb_prompt $" {
> pass "ptype class vA"
> }
> - -re "type = (class|struct) vA \{(${ws}public:|)${ws}int va;${ws}int vx;((${ws}vA & operator=\\(vA const &\\);)|(${ws}vA\\(vA const &\\);)|(${ws}vA\\((void|)\\);))*${ws}\}$nl$gdb_prompt $" {
> + -re "type = (class|struct) vA \{(${ws}public:|)${ws}int va;${ws}int vx;((${ws}vA & operator=\\(vA const ?&\\);)|(${ws}vA\\(vA const ?&\\);)|(${ws}vA\\((void|)\\);))*${ws}\}$nl$gdb_prompt $" {
> pass "ptype class vA (obsolescent gcc or gdb)"
> }
> -re ".*$gdb_prompt $" {
> @@ -335,14 +351,17 @@ proc test_ptype_class_objects {} {
> setup_xfail_format "DWARF 1"
> send_gdb "ptype class vB\n"
> gdb_expect {
> - -re "type = class vB : public virtual vA \{${ws}private:${ws}vA \\*${vbptr}vA;${ws}public:${ws}int vb;${ws}int vx;${ws}vB & operator=\\(vB const &\\);${ws}vB\\(int, vB const &\\);${ws}vB\\(int\\);${ws}\}$nl$gdb_prompt $" {
> + -re "type = class vB : public virtual vA \{${ws}public:${ws}int vb;${ws}int vx;${ws}vB & operator=\\(vB const ?&\\);${ws}vB\\(vB const ?&\\);${ws}vB\\(\\);${ws}\}$nl$gdb_prompt $" {
> + pass "ptype class vB"
> + }
> + -re "type = class vB : public virtual vA \{${ws}private:${ws}vA \\*${vbptr}vA;${ws}public:${ws}int vb;${ws}int vx;${ws}vB & operator=\\(vB const ?&\\);${ws}vB\\(int, vB const ?&\\);${ws}vB\\(int\\);${ws}\}$nl$gdb_prompt $" {
> setup_xfail "*-*-*"
> fail "ptype class vB (FIXME: non-portable virtual table constructs)"
> }
> -re "type = class vB : public virtual vA \{${ws}public:${ws}int vb;${ws}int vx;${ws}\}$nl$gdb_prompt $" {
> pass "ptype class vB (aCC)"
> }
> - -re "type = class vB : public virtual vA \{${ws}private:${ws}vA \\*_vb.vA;${ws}public:${ws}int vb;${ws}int vx;((${ws}vB & operator=\\(vB const &\\);)|(${ws}vB\\(int, vB const &\\);)|(${ws}vB\\(int\\);))*${ws}\}$nl$gdb_prompt $" {
> + -re "type = class vB : public virtual vA \{${ws}private:${ws}vA \\*_vb.vA;${ws}public:${ws}int vb;${ws}int vx;((${ws}vB & operator=\\(vB const ?&\\);)|(${ws}vB\\(int, vB const ?&\\);)|(${ws}vB\\(int\\);))*${ws}\}$nl$gdb_prompt $" {
> setup_xfail "*-*-*"
> fail "ptype class vB (FIXME) (obsolescent gcc or gdb)"
> }
> @@ -362,14 +381,17 @@ proc test_ptype_class_objects {} {
> setup_xfail_format "DWARF 1"
> send_gdb "ptype class vC\n"
> gdb_expect {
> - -re "type = class vC : public virtual vA \{${ws}private:${ws}vA \\*${vbptr}vA;${ws}public:${ws}int vc;${ws}int vx;${ws}vC & operator=\\(vC const &\\);${ws}vC\\(int, vC const &\\);${ws}vC\\(int\\);${ws}\}$nl$gdb_prompt $" {
> + -re "type = class vC : public virtual vA \{${ws}public:${ws}int vc;${ws}int vx;${ws}vC & operator=\\(vC const ?&\\);${ws}vC\\(vC const ?&\\);${ws}vC\\(\\);${ws}\}$nl$gdb_prompt $" {
> + pass "ptype class vC"
> + }
> + -re "type = class vC : public virtual vA \{${ws}private:${ws}vA \\*${vbptr}vA;${ws}public:${ws}int vc;${ws}int vx;${ws}vC & operator=\\(vC const ?&\\);${ws}vC\\(int, vC const ?&\\);${ws}vC\\(int\\);${ws}\}$nl$gdb_prompt $" {
> setup_xfail "*-*-*"
> fail "ptype class vC (FIXME: non-portable virtual table constructs)"
> }
> -re "type = class vC : public virtual vA \{${ws}public:${ws}int vc;${ws}int vx;${ws}\}$nl$gdb_prompt $" {
> pass "ptype class vC (aCC)"
> }
> - -re "type = class vC : public virtual vA \{${ws}private:${ws}vA \\*_vb.vA;${ws}public:${ws}int vc;${ws}int vx;((${ws}vC & operator=\\(vC const &\\);)|(${ws}vC\\(int, vC const &\\);)|(${ws}vC\\(int\\);))*${ws}\}$nl$gdb_prompt $" {
> + -re "type = class vC : public virtual vA \{${ws}private:${ws}vA \\*_vb.vA;${ws}public:${ws}int vc;${ws}int vx;((${ws}vC & operator=\\(vC const ?&\\);)|(${ws}vC\\(int, vC const ?&\\);)|(${ws}vC\\(int\\);))*${ws}\}$nl$gdb_prompt $" {
> setup_xfail "*-*-*"
> fail "ptype class vC (FIXME) (obsolescent gcc or gdb)"
> }
> @@ -389,14 +411,17 @@ proc test_ptype_class_objects {} {
> setup_xfail_format "DWARF 1"
> send_gdb "ptype class vD\n"
> gdb_expect {
> - -re "type = class vD : public virtual vB, public virtual vC \{${ws}private:${ws}vC \\*${vbptr}vC;${ws}vB \\*${vbptr}vB;${ws}public:${ws}int vd;${ws}int vx;${ws}vD & operator=\\(vD const &\\);${ws}vD\\(int, vD const &\\);${ws}vD\\(int\\);${ws}\}$nl$gdb_prompt $" {
> + -re "type = class vD : public virtual vB, public virtual vC \{${ws}public:${ws}int vd;${ws}int vx;${ws}vD & operator=\\(vD const ?&\\);${ws}vD\\(vD const ?&\\);${ws}vD\\(\\);${ws}\}$nl$gdb_prompt $" {
> + pass "ptype class vD"
> + }
> + -re "type = class vD : public virtual vB, public virtual vC \{${ws}private:${ws}vC \\*${vbptr}vC;${ws}vB \\*${vbptr}vB;${ws}public:${ws}int vd;${ws}int vx;${ws}vD & operator=\\(vD const ?&\\);${ws}vD\\(int, vD const ?&\\);${ws}vD\\(int\\);${ws}\}$nl$gdb_prompt $" {
> setup_xfail "*-*-*"
> fail "ptype class vD (FIXME: non-portable virtual table constructs)"
> }
> -re "type = class vD : public virtual vB, public virtual vC \{${ws}public:${ws}int vd;${ws}int vx;${ws}\}$nl$gdb_prompt $" {
> pass "ptype class vD (aCC)"
> }
> - -re "type = class vD : public virtual vB, public virtual vC \{${ws}private:${ws}vC \\*_vb.vC;${ws}vB \\*_vb.vB;${ws}public:${ws}int vd;${ws}int vx;((${ws}vD & operator=\\(vD const &\\);)|(${ws}vD\\(int, vD const &\\);)|(${ws}vD\\(int\\);))*${ws}\}$nl$gdb_prompt $" {
> + -re "type = class vD : public virtual vB, public virtual vC \{${ws}private:${ws}vC \\*_vb.vC;${ws}vB \\*_vb.vB;${ws}public:${ws}int vd;${ws}int vx;((${ws}vD & operator=\\(vD const ?&\\);)|(${ws}vD\\(int, vD const ?&\\);)|(${ws}vD\\(int\\);))*${ws}\}$nl$gdb_prompt $" {
> setup_xfail "*-*-*"
> fail "ptype class vD (FIXME) (obsolescent gcc or gdb)"
> }
> @@ -416,14 +441,17 @@ proc test_ptype_class_objects {} {
> setup_xfail_format "DWARF 1"
> send_gdb "ptype class vE\n"
> gdb_expect {
> - -re "type = class vE : public virtual vD \{${ws}private:${ws}vD \\*${vbptr}vD;${ws}public:${ws}int ve;${ws}int vx;${ws}vE & operator=\\(vE const &\\);${ws}vE\\(int, vE const &\\);${ws}vE\\(int\\);${ws}\}$nl$gdb_prompt $" {
> + -re "type = class vE : public virtual vD \{${ws}public:${ws}int ve;${ws}int vx;${ws}vE & operator=\\(vE const ?&\\);${ws}vE\\(vE const ?&\\);${ws}vE\\(\\);${ws}\}$nl$gdb_prompt $" {
> + pass "ptype class vE"
> + }
> + -re "type = class vE : public virtual vD \{${ws}private:${ws}vD \\*${vbptr}vD;${ws}public:${ws}int ve;${ws}int vx;${ws}vE & operator=\\(vE const ?&\\);${ws}vE\\(int, vE const ?&\\);${ws}vE\\(int\\);${ws}\}$nl$gdb_prompt $" {
> setup_xfail "*-*-*"
> fail "ptype class vE (FIXME: non-portable virtual table constructs)"
> }
> -re "type = class vE : public virtual vD \{${ws}public:${ws}int ve;${ws}int vx;${ws}\}$nl$gdb_prompt $" {
> pass "ptype class vE (aCC)"
> }
> - -re "type = class vE : public virtual vD \{${ws}private:${ws}vD \\*_vb.vD;${ws}public:${ws}int ve;${ws}int vx;((${ws}vE & operator=\\(vE const &\\);)|(${ws}vE\\(int, vE const &\\);)|(${ws}vE\\(int\\);))*${ws}\}$nl$gdb_prompt $" {
> + -re "type = class vE : public virtual vD \{${ws}private:${ws}vD \\*_vb.vD;${ws}public:${ws}int ve;${ws}int vx;((${ws}vE & operator=\\(vE const ?&\\);)|(${ws}vE\\(int, vE const ?&\\);)|(${ws}vE\\(int\\);))*${ws}\}$nl$gdb_prompt $" {
> setup_xfail "*-*-*"
> fail "ptype class vE (FIXME) (obsolescent gcc or gdb)"
> }
> @@ -439,10 +467,10 @@ proc test_ptype_class_objects {} {
> setup_xfail_format "DWARF 1"
> send_gdb "ptype class Base1\n"
> gdb_expect {
> - -re "type = class Base1 \{${ws}public:${ws}int x;${ws}Base1 & operator=\\(Base1 const &\\);${ws}Base1\\(Base1 const &\\);${ws}Base1\\(int\\);${ws}\}$nl$gdb_prompt $" {
> + -re "type = class Base1 \{${ws}public:${ws}int x;${ws}Base1 & operator=\\(Base1 const ?&\\);${ws}Base1\\(Base1 const ?&\\);${ws}Base1\\(int\\);${ws}\}$nl$gdb_prompt $" {
> pass "ptype class Base1"
> }
> - -re "type = class Base1 \{${ws}public:${ws}int x;((${ws}Base1 & operator=\\(Base1 const &\\);)|(${ws}Base1\\(Base1 const &\\);)|(${ws}Base1\\(int\\);))*${ws}\}$nl$gdb_prompt $" {
> + -re "type = class Base1 \{${ws}public:${ws}int x;((${ws}Base1 & operator=\\(Base1 const ?&\\);)|(${ws}Base1\\(Base1 const ?&\\);)|(${ws}Base1\\(int\\);))*${ws}\}$nl$gdb_prompt $" {
> pass "ptype class Base1 (obsolescent gcc or gdb)"
> }
> -re ".*$gdb_prompt $" {
> @@ -460,10 +488,10 @@ proc test_ptype_class_objects {} {
> -re "type = class Foo \{${ws}public:${ws}int x;${ws}int y;${ws}static int st;\r\n${ws}Foo\\(int, int\\);${ws}int operator!.void.;${ws}operator int.void.;${ws}int times.int.;$nl\}$nl$gdb_prompt $" {
> pass "ptype class Foo(aCC)"
> }
> - -re "type = class Foo \{${ws}public:${ws}int x;${ws}int y;${ws}static int st;${ws}Foo & operator=\\(Foo const &\\);${ws}Foo\\(Foo const &\\);${ws}Foo\\(int, int\\);${ws}int operator!\\((void|)\\);${ws}operator int\\((void|)\\);${ws}int times\\(int\\);${ws}\}$nl$gdb_prompt $" {
> + -re "type = class Foo \{${ws}public:${ws}int x;${ws}int y;${ws}static int st;${ws}Foo & operator=\\(Foo const ?&\\);${ws}Foo\\(Foo const ?&\\);${ws}Foo\\(int, int\\);${ws}int operator!\\((void|)\\);${ws}operator int\\((void|)\\);${ws}int times\\(int\\);${ws}\}$nl$gdb_prompt $" {
> pass "ptype class Foo"
> }
> - -re "type = class Foo \{${ws}public:${ws}int x;${ws}int y;${ws}static int st;((${ws}Foo & operator=\\(Foo const &\\);)|(${ws}Foo\\(Foo const &\\);)|(${ws}Foo\\(int, int\\);)|(${ws}int operator!\\((void|)\\);)|(${ws}int operator int\\((void|)\\);)|(${ws}int times\\(int\\);))*${ws}\}$nl$gdb_prompt $" {
> + -re "type = class Foo \{${ws}public:${ws}int x;${ws}int y;${ws}static int st;((${ws}Foo & operator=\\(Foo const ?&\\);)|(${ws}Foo\\(Foo const ?&\\);)|(${ws}Foo\\(int, int\\);)|(${ws}int operator!\\((void|)\\);)|(${ws}int operator int\\((void|)\\);)|(${ws}int times\\(int\\);))*${ws}\}$nl$gdb_prompt $" {
> pass "ptype class Foo (obsolescent gcc or gdb)"
> }
> -re ".*$gdb_prompt $" {
> @@ -478,10 +506,10 @@ proc test_ptype_class_objects {} {
> setup_xfail_format "DWARF 1"
> send_gdb "ptype class Bar\n"
> gdb_expect {
> - -re "type = class Bar : public Base1, public Foo \{${ws}public:${ws}int z;${ws}Bar & operator=\\(Bar const &\\);${ws}Bar\\(Bar const &\\);${ws}Bar\\(int, int, int\\);${ws}\}$nl$gdb_prompt $" {
> + -re "type = class Bar : public Base1, public Foo \{${ws}public:${ws}int z;${ws}Bar & operator=\\(Bar const ?&\\);${ws}Bar\\(Bar const ?&\\);${ws}Bar\\(int, int, int\\);${ws}\}$nl$gdb_prompt $" {
> pass "ptype class Bar"
> }
> - -re "type = class Bar : public Base1, public Foo \{${ws}public:${ws}int z;((${ws}Bar & operator=\\(Bar const &\\);)|(${ws}Bar\\(Bar const &\\);)|(${ws}Bar\\(int, int, int\\);))*${ws}\}$nl$gdb_prompt $" {
> + -re "type = class Bar : public Base1, public Foo \{${ws}public:${ws}int z;((${ws}Bar & operator=\\(Bar const ?&\\);)|(${ws}Bar\\(Bar const ?&\\);)|(${ws}Bar\\(int, int, int\\);))*${ws}\}$nl$gdb_prompt $" {
> pass "ptype class Bar (obsolescent gcc or gdb)"
> }
> -re ".*$gdb_prompt $" {
> @@ -835,7 +863,7 @@ proc do_tests {} {
> }
>
> gdb_breakpoint enums2
> - if [ gdb_continue enums2 ]==0 then {
> + if [ gdb_continue "enums2(\\(\\)|)" ]==0 then {
> gdb_test "finish" "" ""
> test_enums
> }
> Index: gdb.c++/derivation.exp
> ===================================================================
> RCS file: /cvs/src/src/gdb/testsuite/gdb.c++/derivation.exp,v
> retrieving revision 1.6
> diff -u -p -r1.6 derivation.exp
> --- derivation.exp 2001/11/01 23:41:09 1.6
> +++ derivation.exp 2001/12/05 22:48:25
> @@ -90,7 +90,7 @@ gdb_expect {
>
> send_gdb "ptype a_instance\n"
> gdb_expect {
> - -re "type = class A \{\r\n\[\t \]*public:\r\n\[\t \]*int a;\r\n\[\t \]*int aa;\[\r\n\t ]+A & operator=\\(A const ?&\\);\[\r\n\t ]+A\\(A const ?&\\);\[\r\n\t ]+A\\(void\\);\r\n\[\t \]*int afoo\\((void|)\\);\r\n\[\t \]*int foo\\((void|)\\);\r\n\}.*$gdb_prompt $" { pass "ptype a_instance (with synth ops)" }
> + -re "type = class A \{\r\n\[\t \]*public:\r\n\[\t \]*int a;\r\n\[\t \]*int aa;\[\r\n\t ]+A & operator=\\(A const ?&\\);\[\r\n\t ]+A\\(A const ?&\\);\[\r\n\t ]+A\\((void|)\\);\r\n\[\t \]*int afoo\\((void|)\\);\r\n\[\t \]*int foo\\((void|)\\);\r\n\}.*$gdb_prompt $" { pass "ptype a_instance (with synth ops)" }
> -re "type = class A \{\r\n\[\t \]*public:\r\n\[\t \]*int a;\r\n\[\t \]*int aa;\[\r\n\t \]+A\\(void\\);\r\n\[\t \]*int afoo\\((void|)\\);\r\n\[\t \]*int foo\\((void|)\\);\r\n\}.*$gdb_prompt $" { pass "ptype a_instance (no synth ops)" }
> -re ".*$gdb_prompt $" { fail "ptype a_instance" }
> timeout { fail "(timeout) ptype a_instance" }
> @@ -112,7 +112,7 @@ gdb_expect {
> if {$gcc_compiled} then {
> send_gdb "ptype d_instance\n"
> gdb_expect {
> - -re "type = class D : private A, public B, (protected|private) C \{\r\n\[\t \]*public:\r\n\[\t \]*int d;\r\n\[\t \]*int dd;\[\r\n\t ]+D & operator=\\(D const ?&\\);\[\r\n\t ]+D\\(D const ?&\\);\[\r\n\t \]+D\\(void\\);\r\n\[\t \]*int dfoo\\((void|)\\);\r\n\[\t \]*int foo\\((void|)\\);\r\n\}.*$gdb_prompt $" { pass "ptype d_instance" }
> + -re "type = class D : private A, public B, (protected|private) C \{\r\n\[\t \]*public:\r\n\[\t \]*int d;\r\n\[\t \]*int dd;\[\r\n\t ]+D & operator=\\(D const ?&\\);\[\r\n\t ]+D\\(D const ?&\\);\[\r\n\t \]+D\\((void|)\\);\r\n\[\t \]*int dfoo\\((void|)\\);\r\n\[\t \]*int foo\\((void|)\\);\r\n\}.*$gdb_prompt $" { pass "ptype d_instance" }
> -re "type = class D : private A, public B, private C \{\r\n\[\t \]*public:\r\n\[\t \]*int d;\r\n\[\t \]*int dd;\[\r\n\t \]+D\\(void\\);\r\n\[\t \]*int dfoo\\((void|)\\);\r\n\[\t \]*int foo\\((void|)\\);\r\n\}.*$gdb_prompt $" { pass "ptype d_instance" }
> -re ".*$gdb_prompt $" { fail "ptype d_instance" }
> timeout { fail "(timeout) ptype d_instance" }
> @@ -142,15 +142,15 @@ gdb_expect {
> if {$gcc_compiled} {
> send_gdb "ptype e_instance\n"
> gdb_expect {
> - -re "type = class E : public A, private B, (protected|private) C \{\r\n\[\t \]*public:\r\n\[\t \]*int e;\r\n\[\t \]*int ee;\[\r\n\t ]+E & operator=\\(E const ?&\\);\[\r\n\t ]+E\\(E const ?&\\);\[\r\n\t \]+E\\(void\\);\r\n\[\t \]*int efoo\\((void|)\\);\r\n\[\t \]*int foo\\((void|)\\);\r\n\}.*$gdb_prompt $" { pass "ptype e_instance" }
> - -re "type = class E : public A, private B, private C \{\r\n\[\t \]*public:\r\n\[\t \]*int e;\r\n\[\t \]*int ee;\[\r\n\t \]+E\\(void\\);\r\n\[\t \]*int efoo\\((void|)\\);\r\n\[\t \]*int foo\\((void|)\\);\r\n\}.*$gdb_prompt $" { pass "ptype e_instance" }
> + -re "type = class E : public A, private B, (protected|private) C \{\r\n\[\t \]*public:\r\n\[\t \]*int e;\r\n\[\t \]*int ee;\[\r\n\t ]+E & operator=\\(E const ?&\\);\[\r\n\t ]+E\\(E const ?&\\);\[\r\n\t \]+E\\((void|)\\);\r\n\[\t \]*int efoo\\((void|)\\);\r\n\[\t \]*int foo\\((void|)\\);\r\n\}.*$gdb_prompt $" { pass "ptype e_instance" }
> + -re "type = class E : public A, private B, private C \{\r\n\[\t \]*public:\r\n\[\t \]*int e;\r\n\[\t \]*int ee;\[\r\n\t \]+E\\((void|)\\);\r\n\[\t \]*int efoo\\((void|)\\);\r\n\[\t \]*int foo\\((void|)\\);\r\n\}.*$gdb_prompt $" { pass "ptype e_instance" }
> -re ".*$gdb_prompt $" { fail "ptype e_instance" }
> timeout { fail "(timeout) ptype e_instance" }
> }
> } else {
> send_gdb "ptype e_instance\n"
> gdb_expect {
> - -re "type = class E : public A, private B, protected C \{\r\n\[\t \]*public:\r\n\[\t \]*int e;\r\n\[\t \]*int ee;\[\r\n\t \]+E\\(void\\);\r\n\[\t \]*int efoo\\((void|)\\);\r\n\[\t \]*int foo\\((void|)\\);\r\n\}.*$gdb_prompt $" { pass "ptype e_instance" }
> + -re "type = class E : public A, private B, protected C \{\r\n\[\t \]*public:\r\n\[\t \]*int e;\r\n\[\t \]*int ee;\[\r\n\t \]+E\\((void|)\\);\r\n\[\t \]*int efoo\\((void|)\\);\r\n\[\t \]*int foo\\((void|)\\);\r\n\}.*$gdb_prompt $" { pass "ptype e_instance" }
> -re ".*$gdb_prompt $" { fail "ptype e_instance" }
> timeout { fail "(timeout) ptype e_instance" }
> }
> @@ -171,8 +171,8 @@ gdb_expect {
>
> send_gdb "ptype f_instance\n"
> gdb_expect {
> - -re "type = class F : private A, public B, private C \{\r\n\[\t \]*public:\r\n\[\t \]*int f;\r\n\[\t \]*int ff;\[\r\n\t ]+F & operator=\\(F const ?&\\);\[\r\n\t ]+F\\(F const ?&\\);\[\r\n\t \]+F\\(void\\);\r\n\[\t \]*int ffoo\\((void|)\\);\r\n\[\t \]*int foo\\((void|)\\);\r\n\}.*$gdb_prompt $" { pass "ptype f_instance" }
> - -re "type = class F : private A, public B, private C \{\r\n\[\t \]*public:\r\n\[\t \]*int f;\r\n\[\t \]*int ff;\[\r\n\t \]+F\\(void\\);\r\n\[\t \]*int ffoo\\((void|)\\);\r\n\[\t \]*int foo\\((void|)\\);\r\n\}.*$gdb_prompt $" { pass "ptype f_instance" }
> + -re "type = class F : private A, public B, private C \{\r\n\[\t \]*public:\r\n\[\t \]*int f;\r\n\[\t \]*int ff;\[\r\n\t ]+F & operator=\\(F const ?&\\);\[\r\n\t ]+F\\(F const ?&\\);\[\r\n\t \]+F\\((void|)\\);\r\n\[\t \]*int ffoo\\((void|)\\);\r\n\[\t \]*int foo\\((void|)\\);\r\n\}.*$gdb_prompt $" { pass "ptype f_instance" }
> + -re "type = class F : private A, public B, private C \{\r\n\[\t \]*public:\r\n\[\t \]*int f;\r\n\[\t \]*int ff;\[\r\n\t \]+F\\((void|)\\);\r\n\[\t \]*int ffoo\\((void|)\\);\r\n\[\t \]*int foo\\((void|)\\);\r\n\}.*$gdb_prompt $" { pass "ptype f_instance" }
> -re ".*$gdb_prompt $" { fail "ptype f_instance" }
> timeout { fail "(timeout) ptype f_instance" }
> }
> Index: gdb.c++/inherit.exp
> ===================================================================
> RCS file: /cvs/src/src/gdb/testsuite/gdb.c++/inherit.exp,v
> retrieving revision 1.3
> diff -u -p -r1.3 inherit.exp
> --- inherit.exp 2001/03/06 08:21:53 1.3
> +++ inherit.exp 2001/12/05 22:48:25
> @@ -731,6 +731,9 @@ proc test_print_svi_classes {} {
> -re ".* = \{\<vA\> = \{va = 3, vx = 4\}, ${vbptr}vA = $hex, vb = 5, vx = 6\}$nl$gdb_prompt $" {
> pass "print g_vB"
> }
> + -re ".* = \{\<vA\> = \{va = 3, vx = 4\}, _vptr.vB = $hex, vb = 5, vx = 6\}$nl$gdb_prompt $" {
> + pass "print g_vB (FIXME v3 vtbl ptr)"
> + }
> -re ".*invalid address 0x0.*$gdb_prompt $" {
> # Does not happen with gcc cygnus-2.4.5-930828
> fail "print g_vB (known bug with gcc cygnus-2.4.5-930417)"
> @@ -755,6 +758,9 @@ proc test_print_svi_classes {} {
> -re ".* = \{\<vA\> = \{va = 7, vx = 8\}, ${vbptr}vA = $hex, vc = 9, vx = 10\}$nl$gdb_prompt $" {
> pass "print g_vC"
> }
> + -re ".* = \{\<vA\> = \{va = 7, vx = 8\}, _vptr.vC = $hex, vc = 9, vx = 10\}$nl$gdb_prompt $" {
> + pass "print g_vC (FIXME v3 vtbl ptr)"
> + }
> -re ".*$gdb_prompt $" { fail "print g_vC" }
> timeout { fail "print g_vC (timeout)" }
> }
> @@ -948,6 +954,9 @@ proc test_print_mvi_classes {} {
> -re ".* = \{\<vB\> = \{\<vA\> = \{va = 19, vx = 20\}, ${vbptr}vA = $hex, vb = 21, vx = 22\}, \<vC\> = \{${vbptr}vA = $hex, vc = 23, vx = 24\}, ${vbptr}vC = $hex, ${vbptr}vB = $hex, vd = 25, vx = 26\}$nl$gdb_prompt $" {
> pass "print g_vD"
> }
> + -re ".* = \{\<vB\> = \{\<vA\> = \{va = 19, vx = 20\}, _vptr.vB = $hex, vb = 21, vx = 22\}, \<vC\> = \{_vptr.vC = $hex, vc = 23, vx = 24\}, _vptr.vD = $hex, vd = 25, vx = 26\}$nl$gdb_prompt $" {
> + pass "print g_vD (FIXME v3 vtbl ptr)"
> + }
> -re ".*invalid address 0x0.*$gdb_prompt $" {
> # Does not happen with gcc cygnus-2.4.5-930828
> fail "print g_vD (known bug with gcc cygnus-2.4.5-930417)"
> @@ -971,6 +980,9 @@ proc test_print_mvi_classes {} {
> }
> -re ".* = \{\<vD\> = \{\<vB\> = \{\<vA\> = \{va = 0, vx = 0\}, ${vbptr}vA = $hex, vb = 0, vx = 0\}, \<vC\> = \{${vbptr}vA = $hex, vc = 0, vx = 0\}, ${vbptr}vC = $hex, ${vbptr}vB = $hex, vd = 0, vx = 0\}, ${vbptr}vD = $hex, ve = 27, vx = 28\}$nl$gdb_prompt $" {
> pass "print g_vE"
> + }
> + -re ".* = \{\<vD\> = \{\<vB\> = \{\<vA\> = \{va = 0, vx = 0\}, _vptr.vB = $hex, vb = 0, vx = 0\}, \<vC\> = \{_vptr.vC = $hex, vc = 0, vx = 0\}, _vptr.vD = $hex, vd = 0, vx = 0\}, _vptr.vE = $hex, ve = 27, vx = 28\}$nl$gdb_prompt $" {
> + pass "print g_vE (FIXME v3 vtbl ptr)"
> }
> -re ".*$gdb_prompt $" { fail "print g_vE" }
> timeout { fail "print g_vE (timeout)" }
> Index: gdb.c++/method.exp
> ===================================================================
> RCS file: /cvs/src/src/gdb/testsuite/gdb.c++/method.exp,v
> retrieving revision 1.2
> diff -u -p -r1.2 method.exp
> --- method.exp 2001/03/06 08:21:54 1.2
> +++ method.exp 2001/12/05 22:48:25
> @@ -81,7 +81,7 @@ gdb_expect {
>
> send_gdb "continue\n"
> gdb_expect {
> - -re "Continuing\\.\r\n\r\nBreakpoint \[0-9\]*, A::foo \\(this=$hex, arg=13\\) at .*method\\.cc:38\r\n38\[\t \]*x \\+= arg;\r\n$gdb_prompt $" {
> + -re "Continuing\\.\r\n\r\nBreakpoint \[0-9\]*, A::foo(\\(int\\)|) \\(this=$hex, arg=13\\) at .*method\\.cc:38\r\n38\[\t \]*x \\+= arg;\r\n$gdb_prompt $" {
> pass "continued and got breakpoint in A::foo"
> }
> -re ".*$gdb_prompt $" { fail "continuing and breaking in A::foo" }
> @@ -124,7 +124,7 @@ gdb_expect {
>
> send_gdb "continue\n"
> gdb_expect {
> - -re "Continuing\\.\r\n\r\nBreakpoint \[0-9\]*, A::bar \\(this=$hex, arg=15\\) at .*method\\.cc:44\r\n44\[\t \]*return arg \\+ 2 \\* x;\r\n$gdb_prompt $" {
> + -re "Continuing\\.\r\n\r\nBreakpoint \[0-9\]*, A::bar(\\(int\\) const|) \\(this=$hex, arg=15\\) at .*method\\.cc:44\r\n44\[\t \]*return arg \\+ 2 \\* x;\r\n$gdb_prompt $" {
> pass "continued and got breakpoint in A::bar"
> }
> -re ".*$gdb_prompt $" { fail "continuing and breaking in A::bar" }
> @@ -181,7 +181,7 @@ gdb_expect {
>
> send_gdb "continue\n"
> gdb_expect {
> - -re "Continuing\\.\r\n\r\nBreakpoint \[0-9\]*, funk::getFunky \\(this=$hex, a=1, b=2\\) at .*method\\.cc:20\r\n20\[\t \]*res = a \\+ b - data_;\r\n$gdb_prompt $" {
> + -re "Continuing\\.\r\n\r\nBreakpoint \[0-9\]*, funk::getFunky(\\(int, int\\)|) \\(this=$hex, a=1, b=2\\) at .*method\\.cc:20\r\n20\[\t \]*res = a \\+ b - data_;\r\n$gdb_prompt $" {
> pass "continued and got breakpoint in funk::getfunky"
> }
> -re ".*$gdb_prompt $" { fail "continuing and breaking in funk::getfunky" }
> @@ -226,7 +226,7 @@ gdb_expect {
>
> send_gdb "ptype A\n"
> gdb_expect {
> - -re "type = class A \{\r\n\[ \]*public:\r\n\[ \]*int x;\r\n\[ \]*int y;\r\n\r\n\[ \]*A & operator=\\(A const &\\);\r\n\[ \]*A\\(A const &\\);\r\n\[ \]*A\\(void\\);\r\n\[ \]*int foo\\(int\\);\r\n\[ \]*int bar\\(int\\) const;\r\n\[ \]*int baz\\(int, char\\) volatile;\r\n\[ \]*int qux\\(int, float\\) const volatile;\r\n\}\r\n$gdb_prompt $" {
> + -re "type = class A \{\r\n\[ \]*public:\r\n\[ \]*int x;\r\n\[ \]*int y;\r\n\r\n\[ \]*A & operator=\\(A const ?&\\);\r\n\[ \]*A\\(A const ?&\\);\r\n\[ \]*A\\((void|)\\);\r\n\[ \]*int foo\\(int\\);\r\n\[ \]*int bar\\(int\\) const;\r\n\[ \]*int baz\\(int, char\\) volatile;\r\n\[ \]*int qux\\(int, float\\) (const volatile|volatile const);\r\n\}\r\n$gdb_prompt $" {
> pass "ptype A"
> }
> -re "type = class A \{\r\n\[ \]*public:\r\n\[ \]*int x;\r\n\[ \]*int y;\r\n\r\n\[ \]*int foo\\(int\\);\r\n\[ \]*int bar\\(int\\) const;\r\n\[ \]*int baz\\(int, char\\);\r\n\[ \]*int qux\\(int, float\\) const;\r\n\}\r\n$gdb_prompt $" {
> Index: gdb.c++/misc.cc
> ===================================================================
> RCS file: /cvs/src/src/gdb/testsuite/gdb.c++/misc.cc,v
> retrieving revision 1.4
> diff -u -p -r1.4 misc.cc
> --- misc.cc 2000/07/09 05:16:11 1.4
> +++ misc.cc 2001/12/05 22:48:25
> @@ -269,6 +269,14 @@ void inheritance1 (void)
> inheritance2 ();
> }
>
> +// ======================== static member functions =====================
> +
> +class Static {
> +public:
> + static void ii(int, int);
> +};
> +void Static::ii (int, int) { }
> +
> // ======================== virtual base classes=========================
>
> class vA {
> Index: gdb.c++/namespace.exp
> ===================================================================
> RCS file: /cvs/src/src/gdb/testsuite/gdb.c++/namespace.exp,v
> retrieving revision 1.7
> diff -u -p -r1.7 namespace.exp
> --- namespace.exp 2001/11/21 00:13:30 1.7
> +++ namespace.exp 2001/12/05 22:48:25
> @@ -113,6 +113,9 @@ gdb_expect {
> -re "All functions.*File.*namespace.cc:\r\nint AAA::A_xyzq\\(int\\);\r\nint BBB::B_xyzq\\(int\\);\r\nchar AAA::xyzq\\(char\\);\r\nchar BBB::xyzq\\(char\\);\r\nchar BBB::CCC::xyzq\\(char\\);\r\nchar BBB::Class::xyzq\\(char\\);\r\n$gdb_prompt $" {
> pass "info func xyzq"
> }
> + -re "All functions.*File.*namespace.cc:\r\nint AAA::A_xyzq\\(int\\);\r\nchar AAA::xyzq\\(char\\);\r\nint BBB::B_xyzq\\(int\\);\r\nchar BBB::CCC::xyzq\\(char\\);\r\nchar BBB::Class::xyzq\\(char\\);\r\nchar BBB::xyzq\\(char\\);\r\n$gdb_prompt $" {
> + pass "info func xyzq"
> + }
> -re ".*$gdb_prompt $" { fail "info func xyzq" }
> timeout { fail "(timeout) info func xyzq" }
> }
> Index: gdb.c++/templates.exp
> ===================================================================
> RCS file: /cvs/src/src/gdb/testsuite/gdb.c++/templates.exp,v
> retrieving revision 1.8
> diff -u -p -r1.8 templates.exp
> --- templates.exp 2001/11/13 18:54:40 1.8
> +++ templates.exp 2001/12/05 22:48:25
> @@ -287,7 +287,7 @@ gdb_expect {
>
> send_gdb "ptype fvpchar\n"
> gdb_expect {
> - -re "type = (class |)Foo<volatile char \\*> \\{\r\n\[ \t\]*public:\r\n\[ \t\]*int x;\r\n\[ \t\]*.*char.*\\*t;\r\n\r\n\[ \t\]*.*char \\* foo\\(int,.*char.*\\*\\);\r\n\\}\r\n$gdb_prompt $" { pass "ptype fvpchar" }
> + -re "type = (class |)Foo<volatile char ?\\*> \\{\r\n\[ \t\]*public:\r\n\[ \t\]*int x;\r\n\[ \t\]*.*char.*\\*t;\r\n\r\n\[ \t\]*.*char \\* foo\\(int,.*char.*\\*\\);\r\n\\}\r\n$gdb_prompt $" { pass "ptype fvpchar" }
> -re "$gdb_prompt $" { fail "ptype fvpchar" }
> timeout { fail "(timeout) ptype fvpchar" }
> }
> @@ -417,7 +417,7 @@ gdb_expect {
>
> send_gdb "ptype siip\n"
> gdb_expect {
> - -re "type = class Spec<int,int \\*> \\{\r\n\[ \t\]*public:\r\n\[ \t\]*int x;\r\n\r\n\[ \t\]*.*int spec\\(int \\*\\);\r\n\\}\r\n$gdb_prompt $" { pass "ptype siip" }
> + -re "type = class Spec<int,int ?\\*> \\{\r\n\[ \t\]*public:\r\n\[ \t\]*int x;\r\n\r\n\[ \t\]*.*int spec\\(int ?\\*\\);\r\n\\}\r\n$gdb_prompt $" { pass "ptype siip" }
> -re "$gdb_prompt $" { fail "ptype siip" }
> timeout { fail "(timeout) ptype siip" }
> }
> Index: gdb.c++/userdef.exp
> ===================================================================
> RCS file: /cvs/src/src/gdb/testsuite/gdb.c++/userdef.exp,v
> retrieving revision 1.3
> diff -u -p -r1.3 userdef.exp
> --- userdef.exp 2001/03/21 20:51:16 1.3
> +++ userdef.exp 2001/12/05 22:48:25
> @@ -52,7 +52,7 @@ if ![runto_main] then {
> send_gdb "break marker1\n" ; gdb_expect -re ".*$gdb_prompt $"
> send_gdb "cont\n"
> gdb_expect {
> - -re "Break.* marker1 \\(\\) at .*:$decimal.*$gdb_prompt $" {
> + -re "Break.* marker1(\\(\\)|) \\(\\) at .*:$decimal.*$gdb_prompt $" {
> send_gdb "up\n"
> gdb_expect {
> -re ".*$gdb_prompt $" { pass "up from marker1" }
> Index: gdb.c++/virtfunc.exp
> ===================================================================
> RCS file: /cvs/src/src/gdb/testsuite/gdb.c++/virtfunc.exp,v
> retrieving revision 1.4
> diff -u -p -r1.4 virtfunc.exp
> --- virtfunc.exp 2001/11/08 19:12:30 1.4
> +++ virtfunc.exp 2001/12/05 22:48:25
> @@ -138,6 +138,9 @@ proc test_ptype_of_classes {} {
> -re "type = class A : public virtual V \{${ws}private:${ws}V \\*${vbptr}V;${ws}int a;${ws}public:${ws}A & operator=\\(A const ?&\\);${ws}A\\(int, A const ?&\\);${ws}A\\(int\\);${ws}virtual int f\\((void|)\\);${ws}\}$nl$gdb_prompt $" {
> pass "ptype A"
> }
> + -re "type = class A : public virtual V \{${ws}private:${ws}int a;${ws}public:${ws}A & operator=\\(A const ?&\\);${ws}A\\(A const ?&\\);${ws}A\\(\\);${ws}virtual int f\\((void|)\\);${ws}\}$nl$gdb_prompt $" {
> + pass "ptype A"
> + }
> -re "type = class A : public virtual V \{${ws}private:${ws}int a;${ws}public:${ws}virtual int f\\((void|)\\);${ws}\}$nl$gdb_prompt $" {
> pass "ptype A (aCC)"
> }
> @@ -164,6 +167,9 @@ proc test_ptype_of_classes {} {
> -re "type = class B : public A \{${ws}private:${ws}int b;${ws}public:${ws}B & operator=\\(B const ?&\\);${ws}B\\(int, B const ?&\\);${ws}B\\(int\\);${ws}virtual int f\\((void|)\\);${ws}\}$nl$gdb_prompt $" {
> pass "ptype B"
> }
> + -re "type = class B : public A \{${ws}private:${ws}int b;${ws}public:${ws}B & operator=\\(B const ?&\\);${ws}B\\(B const ?&\\);${ws}B\\(\\);${ws}virtual int f\\((void|)\\);${ws}\}$nl$gdb_prompt $" {
> + pass "ptype B"
> + }
> -re "type = class B : public A \{${ws}private:${ws}int b;${ws}public:${ws}virtual int f \\((void|)\\);${ws}\}$nl$gdb_prompt $" {
> pass "ptype B (aCC)"
> }
> @@ -183,6 +189,9 @@ proc test_ptype_of_classes {} {
> -re "type = class C : public virtual V \{${ws}private:${ws}V \\*${vbptr}V;${ws}public:${ws}int c;${ws}C & operator=\\(C const ?&\\);${ws}C\\(int, C const ?&\\);${ws}C\\(int\\);${ws}\}$nl$gdb_prompt $" {
> pass "ptype C"
> }
> + -re "type = class C : public virtual V \{${ws}public:${ws}int c;${ws}C & operator=\\(C const ?&\\);${ws}C\\(C const ?&\\);${ws}C\\(\\);${ws}\}$nl$gdb_prompt $" {
> + pass "ptype C"
> + }
> -re "type = class C : public virtual V \{${ws}public:${ws}int c;${ws}\}$nl$gdb_prompt $" {
> pass "ptype C (aCC)"
> }
> @@ -221,6 +230,9 @@ proc test_ptype_of_classes {} {
> -re "type = class D : public AD, public virtual V \{${ws}private:${ws}V \\*${vbptr}V;${ws}public:${ws}int d;${ws}D & operator=\\(D const ?&\\);${ws}D\\(int, D const ?&\\);${ws}D\\(int\\);${ws}static void s\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vd\\((void|)\\);${ws}int fd\\((void|)\\);${ws}\}$nl$gdb_prompt $" {
> pass "ptype D"
> }
> + -re "type = class D : public AD, public virtual V \{${ws}public:${ws}int d;${ws}D & operator=\\(D const ?&\\);${ws}D\\(D const ?&\\);${ws}D\\(\\);${ws}static void s\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vd\\((void|)\\);${ws}int fd\\((void|)\\);${ws}\}$nl$gdb_prompt $" {
> + pass "ptype D"
> + }
> -re "type = class D : public AD, public virtual V \{${ws}public:${ws}int d;${ws}static void s\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vd\\((void|)\\);${ws}int fd\\((void|)\\);${ws}\}$nl$gdb_prompt $" {
> pass "ptype D (aCC)"
> }
> @@ -240,6 +252,9 @@ proc test_ptype_of_classes {} {
> -re "type = class E : public B, public virtual V, public D, public C \{${ws}public:${ws}int e;${ws}E & operator=\\(E const ?&\\);${ws}E\\(int, E const ?&\\);${ws}E\\(int\\);${ws}virtual int f\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vv\\((void|)\\);${ws}\}$nl$gdb_prompt $" {
> pass "ptype E"
> }
> + -re "type = class E : public B, public virtual V, public D, public C \{${ws}public:${ws}int e;${ws}E & operator=\\(E const ?&\\);${ws}E\\(E const ?&\\);${ws}E\\(\\);${ws}virtual int f\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vv\\((void|)\\);${ws}\}$nl$gdb_prompt $" {
> + pass "ptype E"
> + }
> -re "type = class E : public B, public virtual V, public D, public C \{${ws}public:${ws}int e;${ws}virtual int f \\((void|)\\);${ws}virtual int vg \\((void|)\\);${ws}virtual int vv \\((void|)\\);${ws}\}$nl$gdb_prompt $" {
> pass "ptype E (aCC)"
> }
> @@ -259,6 +274,9 @@ proc test_ptype_of_classes {} {
> -re "type = class D : public AD, public virtual V \{${ws}private:${ws}V \\*${vbptr}V;${ws}public:${ws}int d;${ws}D & operator=\\(D const ?&\\);${ws}D\\(int, D const ?&\\);${ws}D\\(int\\);${ws}static void s\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vd\\((void|)\\);${ws}int fd\\((void|)\\);${ws}\}$nl$gdb_prompt $" {
> pass "ptype dd"
> }
> + -re "type = class D : public AD, public virtual V \{${ws}public:${ws}int d;${ws}D & operator=\\(D const ?&\\);${ws}D\\(D const ?&\\);${ws}D\\(\\);${ws}static void s\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vd\\((void|)\\);${ws}int fd\\((void|)\\);${ws}\}$nl$gdb_prompt $" {
> + pass
> + }
> -re "type = class D : public AD, public virtual V \{${ws}public:${ws}int d;${ws}static void s\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vd\\((void|)\\);${ws}int fd\\((void|)\\);${ws}\}$nl$gdb_prompt $" {
> pass "ptype d (aCC)"
> }
> @@ -392,6 +425,9 @@ proc test_ptype_of_classes {} {
> -re "type = class E : public B, public virtual V, public D, public C \{${ws}public:${ws}int e;${ws}E & operator=\\(E const ?&\\);${ws}E\\(int, E const ?&\\);${ws}E\\(int\\);${ws}virtual int f\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vv\\((void|)\\);${ws}\}$nl$gdb_prompt $" {
> pass "ptype e"
> }
> + -re "type = class E : public B, public virtual V, public D, public C \{${ws}public:${ws}int e;${ws}E & operator=\\(E const ?&\\);${ws}E\\(E const ?&\\);${ws}E\\(\\);${ws}virtual int f\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vv\\((void|)\\);${ws}\}$nl$gdb_prompt $" {
> + pass "ptype e"
> + }
> -re "type = class E : public B, public virtual V, public D, public C \{${ws}public:${ws}int e;${ws}virtual int f \\((void|)\\);${ws}virtual int vg \\((void|)\\);${ws}virtual int vv \\((void|)\\);${ws}\}$nl$gdb_prompt $" {
> pass "ptype e (aCC)"
> }
> @@ -449,6 +485,9 @@ proc test_ptype_of_classes {} {
> -re "type = class A : public virtual V \{${ws}private:${ws}V \\*${vbptr}V;${ws}int a;${ws}public:${ws}A & operator=\\(A const ?&\\);${ws}A\\(int, A const ?&\\);${ws}A\\(int\\);${ws}virtual int f\\((void|)\\);${ws}\} \[*\]+$nl$gdb_prompt $" {
> pass "ptype pAa"
> }
> + -re "type = class A : public virtual V \{${ws}private:${ws}int a;${ws}public:${ws}A & operator=\\(A const ?&\\);${ws}A\\(A const ?&\\);${ws}A\\(\\);${ws}virtual int f\\((void|)\\);${ws}\} \[*\]+$nl$gdb_prompt $" {
> + pass "ptype pAa"
> + }
> -re "type = class A : public virtual V \{${ws}private:${ws}int a;${ws}public:${ws}virtual int f\\((void|)\\);${ws}\} \[*\]+$nl$gdb_prompt $" {
> pass "ptype pAa (aCC)"
> }
> @@ -468,6 +507,9 @@ proc test_ptype_of_classes {} {
> -re "type = class A : public virtual V \{${ws}private:${ws}V \\*${vbptr}V;${ws}int a;${ws}public:${ws}A & operator=\\(A const ?&\\);${ws}A\\(int, A const ?&\\);${ws}A\\(int\\);${ws}virtual int f\\((void|)\\);${ws}\} \[*\]+$nl$gdb_prompt $" {
> pass "ptype pAe"
> }
> + -re "type = class A : public virtual V \{${ws}private:${ws}int a;${ws}public:${ws}A & operator=\\(A const ?&\\);${ws}A\\(A const ?&\\);${ws}A\\(\\);${ws}virtual int f\\((void|)\\);${ws}\} \[*\]+$nl$gdb_prompt $" {
> + pass "ptype pAe"
> + }
> -re "type = class A : public virtual V \{${ws}private:${ws}int a;${ws}public:${ws}virtual int f\\((void|)\\);${ws}\} \[*\]+$nl$gdb_prompt $" {
> pass "ptype pAe (aCC)"
> }
> @@ -487,6 +529,9 @@ proc test_ptype_of_classes {} {
> -re "type = class B : public A \{${ws}private:${ws}int b;${ws}public:${ws}B & operator=\\(B const ?&\\);${ws}B\\(int, B const ?&\\);${ws}B\\(int\\);${ws}virtual int f\\((void|)\\);${ws}\} \[*\]+$nl$gdb_prompt $" {
> pass "ptype pBe"
> }
> + -re "type = class B : public A \{${ws}private:${ws}int b;${ws}public:${ws}B & operator=\\(B const ?&\\);${ws}B\\(B const ?&\\);${ws}B\\(\\);${ws}virtual int f\\((void|)\\);${ws}\} \[*\]+$nl$gdb_prompt $" {
> + pass "ptype pBe"
> + }
> -re "type = class B : public A \{${ws}private:${ws}int b;${ws}public:${ws}virtual int f \\((void|)\\);${ws}\} \[*\]+$nl$gdb_prompt $" {
> pass "ptype pBe (aCC)"
> }
> @@ -506,6 +551,9 @@ proc test_ptype_of_classes {} {
> -re "type = class D : public AD, public virtual V \{${ws}private:${ws}V \\*${vbptr}V;${ws}public:${ws}int d;${ws}D & operator=\\(D const ?&\\);${ws}D\\(int, D const ?&\\);${ws}D\\(int\\);${ws}static void s\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vd\\((void|)\\);${ws}int fd\\((void|)\\);${ws}\} \[*\]+$nl$gdb_prompt $" {
> pass "ptype pDd"
> }
> + -re "type = class D : public AD, public virtual V \{${ws}public:${ws}int d;${ws}D & operator=\\(D const ?&\\);${ws}D\\(D const ?&\\);${ws}D\\(\\);${ws}static void s\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vd\\((void|)\\);${ws}int fd\\((void|)\\);${ws}\} \[*\]+$nl$gdb_prompt $" {
> + pass "ptype pDd"
> + }
> -re "type = class D : public AD, public virtual V \{${ws}public:${ws}int d;${ws}static void s\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vd\\((void|)\\);${ws}int fd\\((void|)\\);${ws}\} \[*\]+$nl$gdb_prompt $" {
> pass "ptype pDd (aCC)"
> }
> @@ -525,6 +573,9 @@ proc test_ptype_of_classes {} {
> -re "type = class D : public AD, public virtual V \{${ws}private:${ws}V \\*${vbptr}V;${ws}public:${ws}int d;${ws}D & operator=\\(D const ?&\\);${ws}D\\(int, D const ?&\\);${ws}D\\(int\\);${ws}static void s\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vd\\((void|)\\);${ws}int fd\\((void|)\\);${ws}\} \[*\]+$nl$gdb_prompt $" {
> pass "ptype pDe"
> }
> + -re "type = class D : public AD, public virtual V \{${ws}public:${ws}int d;${ws}D & operator=\\(D const ?&\\);${ws}D\\(D const ?&\\);${ws}D\\(\\);${ws}static void s\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vd\\((void|)\\);${ws}int fd\\((void|)\\);${ws}\} \[*\]+$nl$gdb_prompt $" {
> + pass "ptype pDe"
> + }
> -re "type = class D : public AD, public virtual V \{${ws}public:${ws}int d;${ws}static void s\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vd\\((void|)\\);${ws}int fd\\((void|)\\);${ws}\} \[*\]+$nl$gdb_prompt $" {
> pass "ptype pDe (aCC)"
> }
> @@ -637,6 +688,9 @@ proc test_ptype_of_classes {} {
> send_gdb "ptype pEe\n"
> gdb_expect {
> -re "type = class E : public B, public virtual V, public D, public C \{${ws}public:${ws}int e;${ws}E & operator=\\(E const ?&\\);${ws}E\\(int, E const ?&\\);${ws}E\\(int\\);${ws}virtual int f\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vv\\((void|)\\);${ws}\} \[*\]+$nl$gdb_prompt $" {
> + pass "ptype pEe"
> + }
> + -re "type = class E : public B, public virtual V, public D, public C \{${ws}public:${ws}int e;${ws}E & operator=\\(E const ?&\\);${ws}E\\(E const ?&\\);${ws}E\\(\\);${ws}virtual int f\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vv\\((void|)\\);${ws}\} \[*\]+$nl$gdb_prompt $" {
> pass "ptype pEe"
> }
> -re "type = class E : public B, public virtual V, public D, public C \{${ws}public:${ws}int e;${ws}virtual int f \\((void|)\\);${ws}virtual int vg \\((void|)\\);${ws}virtual int vv \\((void|)\\);${ws}\} \[*\]+$nl$gdb_prompt $" {
>