This is the mail archive of the
gdb-patches@sources.redhat.com
mailing list for the GDB project.
[patch/testsuite/cp] new cp_test_ptype_class
- From: Michael Chastain <mec dot gnu at mindspring dot com>
- To: gdb-patches at sources dot redhat dot com, carlton at bactrian dot org
- Date: Mon, 09 Aug 2004 18:45:10 -0400
- Subject: [patch/testsuite/cp] new cp_test_ptype_class
Here is the new ptype tester for C++.
This patch adds lib/cp-support.exp with two new procedures:
cp_test_ptype_class
cp_check_errata
As I posted earlier, cp_test_ptype_class takes a class description
table and compares each line of the "ptype" output against the
class description table.
I used Andrew's cool syntax for the class description table and it is
far more simple than anything in the existing code. For example, here
is a class with multiple inheritance and a virtual base pointer and
several methods and fields:
cp_test_ptype_class \
"ptype E" "" "class" "E" \
{
{ base "public B" }
{ base "public virtual V" }
{ base "public D" }
{ base "public C" }
{ vbase "V" }
{ method public "virtual int f();" }
{ method public "virtual int vg();" }
{ method public "virtual int vv();" }
{ field public "int e;" }
}
And here is a test for a pointer to an instance of the class:
cp_test_ptype_class "ptype pEe" "" "class" "E" ibid "*"
"ibid" refers back to the previous class info table for "class" "E",
not just to the immediate previous class table with whatever name.
This knocks a lot of duplicated info out of virtfunc.exp.
cp_check_errata is a new function that helps out with setup_xfail
and setup_kfail. Here is a test with an errata table:
cp_test_ptype_class \
"ptype e_instance" "" "class" "E" \
{
{ base "public A" }
{ base "private B" }
{ base "protected C" }
{ field public "int e;" }
{ field public "int ee;" }
{ method public "E();" }
{ method public "int efoo();" }
{ method public "int foo();" }
} \
"" \
{
{ "protected C" "private C" { setup_xfail "*-*-*" "gcc/13539" } }
}
The erratum line says: if you are expecting "protected C" anywhere,
but gdb actually emits "private C", then call setup_xfail
with PR gcc/13539. (This is for real; this is a gcc bug in
gcc 2.95.3 and gcc 3.3.4, fixed in gcc 3.4.1).
I converted virtfunc.exp and derivation.exp to cp_test_ptype_class.
More conversions are in the pipeline.
Tested on native i686-pc-linux-gnu with gcc 2.95.3, gcc 3.3.4,
gcc 3.4.1, and gcc HEAD 20040806, dwarf-2 and stabs+.
Also tested on native hppa2.0w-hp-hpux11.11 with hp ac++ A.03.45.
I am committing this now,
Michael C
2004-08-09 Michael Chastain <mec.gnu@mindspring.com>
* lib/cp-support.exp: New file.
* lib/cp-support.exp (cp_test_type_class): New function.
* gdb.cp/derivation.exp: Use cp_test_ptype_class.
* gdb.cp/virtfunc.exp (test_one_ptype): Removed.
* gdb.cp/virtfunc.exp (test_ptype_of_classes): Use
cp_test_ptype_class.
Index: gdb.cp/derivation.exp
===================================================================
RCS file: /cvs/src/src/gdb/testsuite/gdb.cp/derivation.exp,v
retrieving revision 1.7
diff -c -3 -p -r1.7 derivation.exp
*** gdb.cp/derivation.exp 11 Feb 2004 14:01:25 -0000 1.7
--- gdb.cp/derivation.exp 9 Aug 2004 08:44:46 -0000
*************** set bug_id 0
*** 38,43 ****
--- 38,45 ----
if { [skip_cplus_tests] } { continue }
+ load_lib "cp-support.exp"
+
set testfile "derivation"
set srcfile ${testfile}.cc
set binfile ${objdir}/${subdir}/${testfile}
*************** if ![runto 'marker1'] then {
*** 61,184 ****
gdb_test "up" ".*main.*" "up from marker1"
# Print class types and values.
- # See virtfunc.exp for a discussion of ptype.
# class A
- set re_class "((struct|class) A \{${ws}public:|struct A \{)"
- set re_fields "int a;${ws}int aa;"
- set re_methods "A\\((void|)\\);${ws}int afoo\\((void|)\\);${ws}int foo\\((void|)\\);"
- set re_synth_gcc_23 "A & operator=\\(A const ?&\\);${ws}A\\(A const ?&\\);"
- set re_all_methods "($re_methods|$re_methods${ws}$re_synth_gcc_23|$re_synth_gcc_23${ws}$re_methods)"
-
gdb_test "print a_instance" "\\$\[0-9\]+ = \{a = 1, aa = 2\}" "print value of a_instance"
! gdb_test_multiple "ptype a_instance" "ptype a_instance" {
! -re "type = $re_class${ws}$re_fields${ws}$re_methods$nl\}$nl$gdb_prompt $" {
! pass "ptype a_instance (no synth ops)"
! }
! -re "type = $re_class${ws}$re_fields${ws}$re_synth_gcc_23${ws}$re_methods${ws}$nl\}$nl$gdb_prompt $" {
! pass "ptype a_instance (with synth ops)"
}
- -re "type = $re_class${ws}$re_fields${ws}$re_methods${ws}$re_synth_gcc_23$nl\}$nl$gdb_prompt $" {
- pass "ptype a_instance (with synth ops)"
- }
- }
# class D
- set re_class "class D : private A, public B, protected C \{${ws}public:"
- set XX_class "class D : private A, public B, private C \{${ws}public:"
- set re_fields "int d;${ws}int dd;"
- set re_methods "D\\((void|)\\);${ws}int dfoo\\((void|)\\);${ws}int foo\\((void|)\\);"
- set re_synth_gcc_23 "D & operator=\\(D const ?&\\);${ws}D\\(D const ?&\\);"
- set re_all_methods "($re_methods|$re_methods${ws}$re_synth_gcc_23|$re_synth_gcc_23${ws}$re_methods)"
-
gdb_test_multiple "print d_instance" "print value of d_instance" {
-re "\\$\[0-9\]+ = \{<(class A|A)> = \{a = 1, aa = 2\}, <(class B|B)> = \{b = 3, bb = 4\}, <(class C|C)> = \{c = 5, cc = 6\}, d = 7, dd = 8\}$nl$gdb_prompt $" {
pass "print value of d_instance"
}
}
! gdb_test_multiple "ptype d_instance" "ptype d_instance" {
! -re "type = $re_class${ws}$re_fields${ws}$re_methods${ws}$re_synth_gcc_23$nl\}$nl$gdb_prompt $" {
! pass "ptype d_instance"
! }
! -re "type = $re_class${ws}$re_fields${ws}$re_all_methods$nl\}$nl$gdb_prompt $" {
! pass "ptype d_instance"
! }
! -re "type = $XX_class${ws}$re_fields${ws}$re_methods${ws}$re_synth_gcc_23$nl\}$nl$gdb_prompt $" {
! # This is a gcc bug, gcc/13539, gdb/1498.
! # Fixed in gcc HEAD 2004-01-13
! setup_xfail "*-*-*" "gcc/13539"
! fail "ptype d_instance"
! }
! -re "type = $XX_class${ws}$re_fields${ws}$re_all_methods$nl\}$nl$gdb_prompt $" {
! # This is a gcc bug, gcc/13539, gdb/1498.
! # Fixed in gcc HEAD 2004-01-13
! setup_xfail "*-*-*" "gcc/13539"
! fail "ptype d_instance"
}
- }
# class E
- set re_class "class E : public A, private B, protected C \{${ws}public:"
- set XX_class "class E : public A, private B, private C \{${ws}public:"
- set re_fields "int e;${ws}int ee;"
- set re_methods "E\\((void|)\\);${ws}int efoo\\((void|)\\);${ws}int foo\\((void|)\\);"
- set re_synth_gcc_23 "E & operator=\\(E const ?&\\);${ws}E\\(E const ?&\\);"
- set re_all_methods "($re_methods|$re_methods${ws}$re_synth_gcc_23|$re_synth_gcc_23${ws}$re_methods)"
-
gdb_test_multiple "print e_instance" "print value of e_instance" {
-re "\\$\[0-9\]+ = \{<(class A|A)> = \{a = 1, aa = 2\}, <(class B|B)> = \{b = 3, bb = 4\}, <(class C|C)> = \{c = 5, cc = 6\}, e = 9, ee = 10\}$nl$gdb_prompt $" {
pass "print value of e_instance"
}
}
! gdb_test_multiple "ptype e_instance" "ptype e_instance" {
! -re "type = $re_class${ws}$re_fields${ws}$re_methods${ws}$re_synth_gcc_23$nl\}$nl$gdb_prompt $" {
! pass "ptype e_instance"
! }
! -re "type = $re_class${ws}$re_fields${ws}$re_all_methods$nl\}$nl$gdb_prompt $" {
! pass "ptype e_instance"
! }
! -re "type = $XX_class${ws}$re_fields${ws}$re_methods${ws}$re_synth_gcc_23$nl\}$nl$gdb_prompt $" {
! # This is a gcc bug, gcc/13539, gdb/1498.
! # Fixed in gcc HEAD 2004-01-13
! setup_xfail "*-*-*" "gcc/13539"
! fail "ptype e_instance"
! }
! -re "type = $XX_class${ws}$re_fields${ws}$re_all_methods$nl\}$nl$gdb_prompt $" {
! # This is a gcc bug, gcc/13539, gdb/1498.
! # Fixed in gcc HEAD 2004-01-13
! setup_xfail "*-*-*" "gcc/13539"
! fail "ptype e_instance"
}
- }
# class F
- set re_class "class F : private A, public B, private C \{${ws}public:"
- set re_fields "int f;${ws}int ff;"
- set re_methods "F\\((void|)\\);${ws}int ffoo\\((void|)\\);${ws}int foo\\((void|)\\);"
- set re_synth_gcc_23 "F & operator=\\(F const ?&\\);${ws}F\\(F const ?&\\);"
- set re_all_methods "($re_methods|$re_methods${ws}$re_synth_gcc_23|$re_synth_gcc_23${ws}$re_methods)"
-
gdb_test_multiple "print f_instance" "print value of f_instance" {
-re "\\$\[0-9\]+ = \{<(class A|A)> = \{a = 1, aa = 2\}, <(class B|B)> = \{b = 3, bb = 4\}, <(class C|C)> = \{c = 5, cc = 6\}, f = 11, ff = 12\}$nl$gdb_prompt $" {
pass "print value of f_instance"
}
}
! gdb_test_multiple "ptype f_instance" "ptype f_instance" {
! -re "type = $re_class${ws}$re_fields${ws}$re_methods${ws}$re_synth_gcc_23$nl\}$nl$gdb_prompt $" {
! pass "ptype f_instance"
! }
! -re "type = $re_class${ws}$re_fields${ws}$re_all_methods$nl\}$nl$gdb_prompt $" {
! pass "ptype f_instance"
}
- }
# Print individual fields.
--- 63,153 ----
gdb_test "up" ".*main.*" "up from marker1"
# Print class types and values.
# class A
gdb_test "print a_instance" "\\$\[0-9\]+ = \{a = 1, aa = 2\}" "print value of a_instance"
! cp_test_ptype_class \
! "ptype a_instance" "" "class" "A" \
! {
! { field public "int a;" }
! { field public "int aa;" }
! { method public "A();" }
! { method public "int afoo();" }
! { method public "int foo();" }
}
# class D
gdb_test_multiple "print d_instance" "print value of d_instance" {
-re "\\$\[0-9\]+ = \{<(class A|A)> = \{a = 1, aa = 2\}, <(class B|B)> = \{b = 3, bb = 4\}, <(class C|C)> = \{c = 5, cc = 6\}, d = 7, dd = 8\}$nl$gdb_prompt $" {
pass "print value of d_instance"
}
}
! cp_test_ptype_class \
! "ptype d_instance" "" "class" "D" \
! {
! { base "private A" }
! { base "public B" }
! { base "protected C" }
! { field public "int d;" }
! { field public "int dd;" }
! { method public "D();" }
! { method public "int dfoo();" }
! { method public "int foo();" }
! } \
! "" \
! {
! { "protected C" "private C" { setup_xfail "*-*-*" "gcc/13539" } }
}
# class E
gdb_test_multiple "print e_instance" "print value of e_instance" {
-re "\\$\[0-9\]+ = \{<(class A|A)> = \{a = 1, aa = 2\}, <(class B|B)> = \{b = 3, bb = 4\}, <(class C|C)> = \{c = 5, cc = 6\}, e = 9, ee = 10\}$nl$gdb_prompt $" {
pass "print value of e_instance"
}
}
! cp_test_ptype_class \
! "ptype e_instance" "" "class" "E" \
! {
! { base "public A" }
! { base "private B" }
! { base "protected C" }
! { field public "int e;" }
! { field public "int ee;" }
! { method public "E();" }
! { method public "int efoo();" }
! { method public "int foo();" }
! } \
! "" \
! {
! { "protected C" "private C" { setup_xfail "*-*-*" "gcc/13539" } }
}
# class F
gdb_test_multiple "print f_instance" "print value of f_instance" {
-re "\\$\[0-9\]+ = \{<(class A|A)> = \{a = 1, aa = 2\}, <(class B|B)> = \{b = 3, bb = 4\}, <(class C|C)> = \{c = 5, cc = 6\}, f = 11, ff = 12\}$nl$gdb_prompt $" {
pass "print value of f_instance"
}
}
! cp_test_ptype_class \
! "ptype f_instance" "" "class" "F" \
! {
! { base "private A" }
! { base "public B" }
! { base "private C" }
! { field public "int f;" }
! { field public "int ff;" }
! { method public "F();" }
! { method public "int ffoo();" }
! { method public "int foo();" }
}
# Print individual fields.
Index: gdb.cp/virtfunc.exp
===================================================================
RCS file: /cvs/src/src/gdb/testsuite/gdb.cp/virtfunc.exp,v
retrieving revision 1.10
diff -c -3 -p -r1.10 virtfunc.exp
*** gdb.cp/virtfunc.exp 31 Jul 2004 10:48:01 -0000 1.10
--- gdb.cp/virtfunc.exp 9 Aug 2004 08:44:46 -0000
***************
*** 18,25 ****
# This file was written by Fred Fish. (fnf@cygnus.com)
# And rewritten by Michael Chastain <mec.gnu@mindspring.com>.
- set wsopt "\[\r\n\t \]*"
- set ws "\[\r\n\t \]+"
set nl "\[\r\n\]+"
if $tracelevel then {
--- 18,23 ----
*************** if $tracelevel then {
*** 28,33 ****
--- 26,33 ----
if { [skip_cplus_tests] } { continue }
+ load_lib "cp-support.exp"
+
set testfile "virtfunc"
set srcfile ${testfile}.cc
set binfile ${objdir}/${subdir}/${testfile}
*************** if { [gdb_compile "${srcdir}/${subdir}/
*** 36,479 ****
gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
}
- # Test ptype of a class.
- #
- # Different C++ compilers produce different output. I build up regular
- # expressions piece by piece to accommodate all the compilers that I
- # have seen: gcc 2.95.3, gcc 3.3.2 (ABI 1), gcc 3.4 prerelease (ABI 2);
- # and all the debug formats I have seen: dwarf-2 and stabs+.
- #
- # A complicated class declaration looks like this:
- #
- # class A : public virtual V { // re_class
- # private:
- # V * _vb$V; // re_vbptr
- # int a; // re_fields
- #
- # public: // re_access_methods
- # A & operator=(A const &); // re_synth_gcc_2
- # A(int, A const &); // ...
- # A(int); // ...
- # virtual int f(void); // re_methods
- # }
- #
- # RE_CLASS matches the class declaration. C++ allows multiple ways of
- # expressing this.
- #
- # struct ... { private: ... };
- # class ... { private: ... };
- # class ... { ... };
- #
- # RE_VBPTR matches the virtual base declarations. gcc 2.95.3 sometimes
- # emits these, but gcc 3.X.Y never emits these. The name depends on the
- # debug format.
- #
- # RE_FIELDS matches the data fields of the class.
- # RE_METHODS matches the methods explicitly declared for the class.
- #
- # RE_SYNTH_GCC_2 and RE_SYNTH_GCC_3 match the optional synthetic methods
- # of the class. gcc -gstabs+ emits these methods, and gcc -gdwarf-2
- # does not.
- #
- # RE_ACCESS_METHODS is an access specifier after RE_FIELDS and before
- # the methods (explicit methods and/or synthetic methods).
- # There is also an RE_ACCESS_FIELDS.
- #
- # When I get HP-UX aCC, I hope that I can just add RE_SYNTH_ACC_NNN.
- #
- # Yet another twist: with gcc v2, ctor and dtor methods have a hidden
- # argument in front, the "in-charge" flag. With gcc v3, there is no
- # hidden argument; instead, there are multiple object functions for
- # each ctor and dtor.
- #
- # -- chastain 2004-01-01
-
- proc test_one_ptype { command testname re_class re_vbptr re_access_fields re_fields re_access_methods re_methods re_synth_gcc_2 re_synth_gcc_3 re_star } {
- global gdb_prompt
- global wsopt
- global ws
- global nl
-
- gdb_test_multiple "$command" "$testname" {
- -re "type = $re_class${wsopt}$re_access_fields${wsopt}$re_fields${wsopt}$re_access_methods${wsopt}$re_methods$nl\}$re_star$nl$gdb_prompt $" {
- # gcc 2.95.3, dwarf-2, no vbptr
- # gcc 3.X, abi 1, dwarf-2
- # gcc 3.X, abi 2, dwarf-2
- pass "$testname"
- }
- -re "type = $re_class${wsopt}$re_vbptr${wsopt}$re_access_fields${wsopt}$re_fields${wsopt}$re_access_methods${wsopt}$re_methods$nl\}$re_star$nl$gdb_prompt $" {
- # gcc 2.95.3, dwarf-2, vbptr
- # TODO: drow says the vbptr is a bug
- pass "$testname"
- }
- -re "type = $re_class${wsopt}$re_access_fields${wsopt}$re_fields${wsopt}$re_access_methods${wsopt}$re_synth_gcc_2${wsopt}$re_methods$nl\}$re_star$nl$gdb_prompt $" {
- # gcc 2.95.3, stabs+, no vbptr
- pass "$testname"
- }
- -re "type = $re_class${wsopt}$re_vbptr${wsopt}$re_access_fields${wsopt}$re_fields${wsopt}$re_access_methods${wsopt}$re_synth_gcc_2${wsopt}$re_methods$nl\}$re_star$nl$gdb_prompt $" {
- # gcc 2.95.3, stabs+, vbptr
- # TODO: drow says the vbptr is a bug
- pass "$testname"
- }
- -re "type = $re_class${wsopt}$re_access_fields${wsopt}$re_fields${wsopt}$re_access_methods${wsopt}$re_synth_gcc_3${wsopt}$re_methods$nl\}$re_star$nl$gdb_prompt $" {
- # gcc 3.X, abi 1, stabs+
- pass "$testname"
- }
- -re "type = $re_class${wsopt}$re_access_fields${wsopt}$re_fields${wsopt}$re_access_methods${wsopt}$re_methods${wsopt}$re_synth_gcc_3$nl\}$re_star$nl$gdb_prompt $" {
- # gcc 3.X, abi 2, stabs+
- pass "$testname"
- }
- }
-
- }
-
proc test_ptype_of_classes {} {
- global gdb_prompt
- global ws
- global nl
# class VA
! test_one_ptype "ptype VA" "ptype VA" \
! "((struct|class) VA \{${ws}public:|struct VA \{)" \
! "" \
! "" "int va;" \
! "" "" \
! "VA & operator=\\(VA const ?&\\);${ws}VA\\(VA const ?&\\);${ws}VA\\((void|)\\);" \
! "(VA & operator=\\(VA const ?&\\);${ws}|)VA\\(VA const ?&\\);${ws}VA\\((void|)\\);" \
! ""
# class VB
! test_one_ptype "ptype VB" "ptype VB" \
! "((struct|class) VB \{${ws}public:|struct VB \{)" \
! "" \
! "" "int vb;" \
! "" "int fvb\\((void|)\\);${ws}virtual int vvb\\((void|)\\);" \
! "VB & operator=\\(VB const ?&\\);${ws}VB\\(VB const ?&\\);${ws}VB\\((void|)\\);" \
! "(VB & operator=\\(VB const ?&\\);${ws}|)VB\\(VB const ?&\\);${ws}VB\\((void|)\\);" \
! ""
# class V
! test_one_ptype "ptype V" "ptype V" \
! "class V : public VA, public VB \{${ws}public:" \
! "" \
! "" "int w;" \
! "" "int f\\((void|)\\);${ws}virtual int vv\\((void|)\\);" \
! "V & operator=\\(V const ?&\\);${ws}V\\(V const ?&\\);${ws}V\\((void|)\\);" \
! "(V & operator=\\(V const ?&\\);${ws}|)V\\(V const ?&\\);${ws}V\\((void|)\\);" \
! ""
# class A
! test_one_ptype "ptype A" "ptype A" \
! "class A : public virtual V \{(${ws}private:|)" \
! "V \\*(_vb.1V|_vb.V);" \
! "" "int a;" \
! "public:" "virtual int f\\((void|)\\);" \
! "A & operator=\\(A const ?&\\);${ws}A\\(int, A const ?&\\);${ws}A\\(int\\);" \
! "(A & operator=\\(A const ?&\\);${ws}|)A\\(A const ?&\\);${ws}A\\((void|)\\);" \
! ""
# class B
! test_one_ptype "ptype B" "ptype B" \
! "class B : public A \{(${ws}private:|)" \
! "V \\*(_vb.1V|_vb.V);" \
! "" "int b;" \
! "public:" "virtual int f\\((void|)\\);" \
! "B & operator=\\(B const ?&\\);${ws}B\\(int, B const ?&\\);${ws}B\\(int\\);" \
! "(B & operator=\\(B const ?&\\);${ws}|)B\\(B const ?&\\);${ws}B\\((void|)\\);" \
! ""
# class C
! test_one_ptype "ptype C" "ptype C" \
! "class C : public virtual V \{(${ws}private:|)" \
! "V \\*(_vb.1V|_vb.V);" \
! "public:" "int c;" \
! "" "" \
! "C & operator=\\(C const ?&\\);${ws}C\\(int, C const ?&\\);${ws}C\\(int\\);" \
! "(C & operator=\\(C const ?&\\);${ws}|)C\\(C const ?&\\);${ws}C\\((void|)\\);" \
! ""
# class AD
! test_one_ptype "ptype AD" "ptype AD" \
! "((struct|class) AD \{${ws}public:|struct AD \{)" \
! "" \
! "" "" \
! "" "virtual int vg\\((void|)\\);" \
! "AD & operator=\\(AD const ?&\\);${ws}AD\\(AD const ?&\\);${ws}AD\\((void|)\\);" \
! "(AD & operator=\\(AD const ?&\\);${ws}|)AD\\(AD const ?&\\);${ws}AD\\((void|)\\);" \
! ""
# class D
! test_one_ptype "ptype D" "ptype D" \
! "class D : public AD, public virtual V \{(${ws}private:|)" \
! "V \\*(_vb.1V|_vb.V);" \
! "public:" "int d;" \
! "" "static void s\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vd\\((void|)\\);${ws}int fd\\((void|)\\);" \
! "D & operator=\\(D const ?&\\);${ws}D\\(int, D const ?&\\);${ws}D\\(int\\);" \
! "(D & operator=\\(D const ?&\\);${ws}|)D\\(D const ?&\\);${ws}D\\((void|)\\);" \
! ""
# class E
- # TODO: E does not show a vbptr for V. That seems strange.
! test_one_ptype "ptype E" "ptype E" \
! "class E : public B, public virtual V, public D, public C \{(${ws}private:|)" \
! "" \
! "public:" "int e;" \
! "" "virtual int f\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vv\\((void|)\\);" \
! "E & operator=\\(E const ?&\\);${ws}E\\(int, E const ?&\\);${ws}E\\(int\\);" \
! "(E & operator=\\(E const ?&\\);${ws}|)E\\(E const ?&\\);${ws}E\\((void|)\\);" \
! ""
# An instance of D
! test_one_ptype "ptype dd" "ptype dd" \
! "class D : public AD, public virtual V \{(${ws}private:|)" \
! "V \\*(_vb.1V|_vb.V);" \
! "public:" "int d;" \
! "" "static void s\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vd\\((void|)\\);${ws}int fd\\((void|)\\);" \
! "D & operator=\\(D const ?&\\);${ws}D\\(int, D const ?&\\);${ws}D\\(int\\);" \
! "(D & operator=\\(D const ?&\\);${ws}|)D\\(D const ?&\\);${ws}D\\((void|)\\);" \
! ""
# An instance of D *
! test_one_ptype "ptype ppd" "ptype ppd" \
! "class D : public AD, public virtual V \{(${ws}private:|)" \
! "V \\*(_vb.1V|_vb.V);" \
! "public:" "int d;" \
! "" "static void s\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vd\\((void|)\\);${ws}int fd\\((void|)\\);" \
! "D & operator=\\(D const ?&\\);${ws}D\\(int, D const ?&\\);${ws}D\\(int\\);" \
! "(D & operator=\\(D const ?&\\);${ws}|)D\\(D const ?&\\);${ws}D\\((void|)\\);" \
! " ?\\*"
# An instance of AD *
# TODO: this should be named pADd, not pAd.
! test_one_ptype "ptype pAd" "ptype pAd" \
! "((struct|class) AD \{${ws}public:|struct AD \{)" \
! "" \
! "" "" \
! "" "virtual int vg\\((void|)\\);" \
! "AD & operator=\\(AD const ?&\\);${ws}AD\\(AD const ?&\\);${ws}AD\\((void|)\\);" \
! "(AD & operator=\\(AD const ?&\\);${ws}|)AD\\(AD const ?&\\);${ws}AD\\((void|)\\);" \
! " ?\\*"
!
! # An instance of A
!
! test_one_ptype "ptype a" "ptype a" \
! "class A : public virtual V \{(${ws}private:|)" \
! "V \\*(_vb.1V|_vb.V);" \
! "" "int a;" \
! "public:" "virtual int f\\((void|)\\);" \
! "A & operator=\\(A const ?&\\);${ws}A\\(int, A const ?&\\);${ws}A\\(int\\);" \
! "(A & operator=\\(A const ?&\\);${ws}|)A\\(A const ?&\\);${ws}A\\((void|)\\);" \
! ""
!
! # An instance of B
!
! test_one_ptype "ptype b" "ptype b" \
! "class B : public A \{(${ws}private:|)" \
! "V \\*(_vb.1V|_vb.V);" \
! "" "int b;" \
! "public:" "virtual int f\\((void|)\\);" \
! "B & operator=\\(B const ?&\\);${ws}B\\(int, B const ?&\\);${ws}B\\(int\\);" \
! "(B & operator=\\(B const ?&\\);${ws}|)B\\(B const ?&\\);${ws}B\\((void|)\\);" \
! ""
!
! # An instance of C
!
! test_one_ptype "ptype c" "ptype c" \
! "class C : public virtual V \{(${ws}private:|)" \
! "V \\*(_vb.1V|_vb.V);" \
! "public:" "int c;" \
! "" "" \
! "C & operator=\\(C const ?&\\);${ws}C\\(int, C const ?&\\);${ws}C\\(int\\);" \
! "(C & operator=\\(C const ?&\\);${ws}|)C\\(C const ?&\\);${ws}C\\((void|)\\);" \
! ""
!
! # An instance of D
! test_one_ptype "ptype d" "ptype d" \
! "class D : public AD, public virtual V \{(${ws}private:|)" \
! "V \\*(_vb.1V|_vb.V);" \
! "public:" "int d;" \
! "" "static void s\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vd\\((void|)\\);${ws}int fd\\((void|)\\);" \
! "D & operator=\\(D const ?&\\);${ws}D\\(int, D const ?&\\);${ws}D\\(int\\);" \
! "(D & operator=\\(D const ?&\\);${ws}|)D\\(D const ?&\\);${ws}D\\((void|)\\);" \
! ""
!
! # An instance of E
!
! test_one_ptype "ptype e" "ptype e" \
! "class E : public B, public virtual V, public D, public C \{(${ws}private:|)" \
! "" \
! "public:" "int e;" \
! "" "virtual int f\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vv\\((void|)\\);" \
! "E & operator=\\(E const ?&\\);${ws}E\\(int, E const ?&\\);${ws}E\\(int\\);" \
! "(E & operator=\\(E const ?&\\);${ws}|)E\\(E const ?&\\);${ws}E\\((void|)\\);" \
! ""
!
! # An instance of V
!
! test_one_ptype "ptype v" "ptype v" \
! "class V : public VA, public VB \{${ws}public:" \
! "" \
! "" "int w;" \
! "" "int f\\((void|)\\);${ws}virtual int vv\\((void|)\\);" \
! "V & operator=\\(V const ?&\\);${ws}V\\(V const ?&\\);${ws}V\\((void|)\\);" \
! "(V & operator=\\(V const ?&\\);${ws}|)V\\(V const ?&\\);${ws}V\\((void|)\\);" \
! ""
!
! # An instance of VB
!
! test_one_ptype "ptype vb" "ptype vb" \
! "((struct|class) VB \{${ws}public:|struct VB \{)" \
! "" \
! "" "int vb;" \
! "" "int fvb\\((void|)\\);${ws}virtual int vvb\\((void|)\\);" \
! "VB & operator=\\(VB const ?&\\);${ws}VB\\(VB const ?&\\);${ws}VB\\((void|)\\);" \
! "(VB & operator=\\(VB const ?&\\);${ws}|)VB\\(VB const ?&\\);${ws}VB\\((void|)\\);" \
! ""
!
! # An instance of A *
!
! test_one_ptype "ptype pAa" "ptype pAa" \
! "class A : public virtual V \{(${ws}private:|)" \
! "V \\*(_vb.1V|_vb.V);" \
! "" "int a;" \
! "public:" "virtual int f\\((void|)\\);" \
! "A & operator=\\(A const ?&\\);${ws}A\\(int, A const ?&\\);${ws}A\\(int\\);" \
! "(A & operator=\\(A const ?&\\);${ws}|)A\\(A const ?&\\);${ws}A\\((void|)\\);" \
! " ?\\*"
!
! # An instance of A *
!
! test_one_ptype "ptype pAe" "ptype pAe" \
! "class A : public virtual V \{(${ws}private:|)" \
! "V \\*(_vb.1V|_vb.V);" \
! "" "int a;" \
! "public:" "virtual int f\\((void|)\\);" \
! "A & operator=\\(A const ?&\\);${ws}A\\(int, A const ?&\\);${ws}A\\(int\\);" \
! "(A & operator=\\(A const ?&\\);${ws}|)A\\(A const ?&\\);${ws}A\\((void|)\\);" \
! " ?\\*"
!
! # An instance of B *
!
! test_one_ptype "ptype pBe" "ptype pBe" \
! "class B : public A \{(${ws}private:|)" \
! "V \\*(_vb.1V|_vb.V);" \
! "" "int b;" \
! "public:" "virtual int f\\((void|)\\);" \
! "B & operator=\\(B const ?&\\);${ws}B\\(int, B const ?&\\);${ws}B\\(int\\);" \
! "(B & operator=\\(B const ?&\\);${ws}|)B\\(B const ?&\\);${ws}B\\((void|)\\);" \
! " ?\\*"
! # An instance of D *
!
! test_one_ptype "ptype pDd" "ptype pDd" \
! "class D : public AD, public virtual V \{(${ws}private:|)" \
! "V \\*(_vb.1V|_vb.V);" \
! "public:" "int d;" \
! "" "static void s\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vd\\((void|)\\);${ws}int fd\\((void|)\\);" \
! "D & operator=\\(D const ?&\\);${ws}D\\(int, D const ?&\\);${ws}D\\(int\\);" \
! "(D & operator=\\(D const ?&\\);${ws}|)D\\(D const ?&\\);${ws}D\\((void|)\\);" \
! " ?\\*"
!
! # An instance of D *
!
! test_one_ptype "ptype pDe" "ptype pDe" \
! "class D : public AD, public virtual V \{(${ws}private:|)" \
! "V \\*(_vb.1V|_vb.V);" \
! "public:" "int d;" \
! "" "static void s\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vd\\((void|)\\);${ws}int fd\\((void|)\\);" \
! "D & operator=\\(D const ?&\\);${ws}D\\(int, D const ?&\\);${ws}D\\(int\\);" \
! "(D & operator=\\(D const ?&\\);${ws}|)D\\(D const ?&\\);${ws}D\\((void|)\\);" \
! " ?\\*"
!
! # An instance of V *
!
! test_one_ptype "ptype pVa" "ptype pVa" \
! "class V : public VA, public VB \{${ws}public:" \
! "" \
! "" "int w;" \
! "" "int f\\((void|)\\);${ws}virtual int vv\\((void|)\\);" \
! "V & operator=\\(V const ?&\\);${ws}V\\(V const ?&\\);${ws}V\\((void|)\\);" \
! "(V & operator=\\(V const ?&\\);${ws}|)V\\(V const ?&\\);${ws}V\\((void|)\\);" \
! " ?\\*"
!
! # An instance of V *
!
! test_one_ptype "ptype pVv" "ptype pVv" \
! "class V : public VA, public VB \{${ws}public:" \
! "" \
! "" "int w;" \
! "" "int f\\((void|)\\);${ws}virtual int vv\\((void|)\\);" \
! "V & operator=\\(V const ?&\\);${ws}V\\(V const ?&\\);${ws}V\\((void|)\\);" \
! "(V & operator=\\(V const ?&\\);${ws}|)V\\(V const ?&\\);${ws}V\\((void|)\\);" \
! " ?\\*"
!
! # An instance of V *
!
! test_one_ptype "ptype pVe" "ptype pVe" \
! "class V : public VA, public VB \{${ws}public:" \
! "" \
! "" "int w;" \
! "" "int f\\((void|)\\);${ws}virtual int vv\\((void|)\\);" \
! "V & operator=\\(V const ?&\\);${ws}V\\(V const ?&\\);${ws}V\\((void|)\\);" \
! "(V & operator=\\(V const ?&\\);${ws}|)V\\(V const ?&\\);${ws}V\\((void|)\\);" \
! " ?\\*"
!
! # An instance of V *
!
! test_one_ptype "ptype pVd" "ptype pVd" \
! "class V : public VA, public VB \{${ws}public:" \
! "" \
! "" "int w;" \
! "" "int f\\((void|)\\);${ws}virtual int vv\\((void|)\\);" \
! "V & operator=\\(V const ?&\\);${ws}V\\(V const ?&\\);${ws}V\\((void|)\\);" \
! "(V & operator=\\(V const ?&\\);${ws}|)V\\(V const ?&\\);${ws}V\\((void|)\\);" \
! " ?\\*"
!
! # An instance of AD *
- test_one_ptype "ptype pADe" "ptype pADe" \
- "((struct|class) AD \{${ws}public:|struct AD \{)" \
- "" \
- "" "" \
- "" "virtual int vg\\((void|)\\);" \
- "AD & operator=\\(AD const ?&\\);${ws}AD\\(AD const ?&\\);${ws}AD\\((void|)\\);" \
- "(AD & operator=\\(AD const ?&\\);${ws}|)AD\\(AD const ?&\\);${ws}AD\\((void|)\\);" \
- " ?\\*"
-
- # An instance of E *
-
- test_one_ptype "ptype pEe" "ptype pEe" \
- "class E : public B, public virtual V, public D, public C \{(${ws}private:|)" \
- "" \
- "public:" "int e;" \
- "" "virtual int f\\((void|)\\);${ws}virtual int vg\\((void|)\\);${ws}virtual int vv\\((void|)\\);" \
- "E & operator=\\(E const ?&\\);${ws}E\\(int, E const ?&\\);${ws}E\\(int\\);" \
- "(E & operator=\\(E const ?&\\);${ws}|)E\\(E const ?&\\);${ws}E\\((void|)\\);" \
- " ?\\*"
-
- # An instance of VB *
-
- test_one_ptype "ptype pVB" "ptype pVB" \
- "((struct|class) VB \{${ws}public:|struct VB \{)" \
- "" \
- "" "int vb;" \
- "" "int fvb\\((void|)\\);${ws}virtual int vvb\\((void|)\\);" \
- "VB & operator=\\(VB const ?&\\);${ws}VB\\(VB const ?&\\);${ws}VB\\((void|)\\);" \
- "(VB & operator=\\(VB const ?&\\);${ws}|)VB\\(VB const ?&\\);${ws}VB\\((void|)\\);" \
- " ?\\*"
}
# Call virtual functions.
--- 36,181 ----
gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
}
proc test_ptype_of_classes {} {
# class VA
! cp_test_ptype_class \
! "ptype VA" "" "class" "VA" \
! {
! { field public "int va;" }
! }
# class VB
! cp_test_ptype_class \
! "ptype VB" "" "class" "VB" \
! {
! { field public "int vb;" }
! { method public "int fvb();" }
! { method public "virtual int vvb();" }
! }
# class V
! cp_test_ptype_class \
! "ptype V" "" "class" "V" \
! {
! { base "public VA" }
! { base "public VB" }
! { field public "int w;" }
! { method public "int f();" }
! { method public "virtual int vv();" }
! }
# class A
! cp_test_ptype_class \
! "ptype A" "" "class" "A" \
! {
! { base "public virtual V" }
! { vbase "V" }
! { field private "int a;" }
! { method public "virtual int f();" }
! }
# class B
! cp_test_ptype_class \
! "ptype B" "" "class" "B" \
! {
! { base "public A" }
! { field private "int b;" }
! { method public "virtual int f();" }
! }
# class C
! cp_test_ptype_class \
! "ptype C" "" "class" "C" \
! {
! { base "public virtual V" }
! { vbase "V" }
! { field public "int c;" }
! }
# class AD
! cp_test_ptype_class \
! "ptype AD" "" "class" "AD" \
! {
! { method public "virtual int vg();" }
! }
# class D
! cp_test_ptype_class \
! "ptype D" "" "class" "D" \
! {
! { base "public AD" }
! { base "public virtual V" }
! { vbase "V" }
! { method public "static void s();" }
! { method public "virtual int vg();" }
! { method public "virtual int vd();" }
! { method public "int fd();" }
! { field public "int d;" }
! }
# class E
! cp_test_ptype_class \
! "ptype E" "" "class" "E" \
! {
! { base "public B" }
! { base "public virtual V" }
! { base "public D" }
! { base "public C" }
! { vbase "V" }
! { method public "virtual int f();" }
! { method public "virtual int vg();" }
! { method public "virtual int vv();" }
! { field public "int e;" }
! }
# An instance of D
! cp_test_ptype_class "ptype dd" "" "class" "D" ibid
# An instance of D *
! cp_test_ptype_class "ptype ppd" "" "class" "D" ibid "*"
# An instance of AD *
# TODO: this should be named pADd, not pAd.
! cp_test_ptype_class "ptype pAd" "" "class" "AD" ibid "*"
! # Instances of these classes.
! cp_test_ptype_class "ptype a" "" "class" "A" ibid
! cp_test_ptype_class "ptype b" "" "class" "B" ibid
! cp_test_ptype_class "ptype c" "" "class" "C" ibid
! cp_test_ptype_class "ptype d" "" "class" "D" ibid
! cp_test_ptype_class "ptype e" "" "class" "E" ibid
! cp_test_ptype_class "ptype v" "" "class" "V" ibid
! cp_test_ptype_class "ptype vb" "" "class" "VB" ibid
!
! # Instances of pointers to these classes.
!
! cp_test_ptype_class "ptype pAa" "" "class" "A" ibid "*"
! cp_test_ptype_class "ptype pAe" "" "class" "A" ibid "*"
! cp_test_ptype_class "ptype pBe" "" "class" "B" ibid "*"
! cp_test_ptype_class "ptype pDd" "" "class" "D" ibid "*"
! cp_test_ptype_class "ptype pDe" "" "class" "D" ibid "*"
! cp_test_ptype_class "ptype pVa" "" "class" "V" ibid "*"
! cp_test_ptype_class "ptype pVv" "" "class" "V" ibid "*"
! cp_test_ptype_class "ptype pVe" "" "class" "V" ibid "*"
! cp_test_ptype_class "ptype pVd" "" "class" "V" ibid "*"
! cp_test_ptype_class "ptype pADe" "" "class" "AD" ibid "*"
! cp_test_ptype_class "ptype pEe" "" "class" "E" ibid "*"
! cp_test_ptype_class "ptype pVB" "" "class" "VB" ibid "*"
}
# Call virtual functions.