classes.exp

gdb that s ported for PXA270 processor. definitely helpful for people interested in embedded system

	    return
	}
    }

    send_gdb "ptype class vA\n"
    gdb_expect {
	-re "type = (class|struct) vA \{(${ws}public:|)${ws}int va;${ws}int vx;${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|const vA) ?&\\);${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 $" {
	    pass "ptype class vA (obsolescent gcc or gdb)"
	}
	-re ".*$gdb_prompt $" {
	    fail "ptype class vA"
	}
	timeout {
	    fail "ptype class vA (timeout)"
	    return
	}
    }

    # Accept the form with embedded GNU style mangled virtual table constructs
    # for now, but with a FIXME.  At some future point, gdb should use a
    # portable representation for the virtual table constructs.

    # The format of a g++ virtual base pointer.
    set vbptr "(_vb\[$.\]|__vb_)\[0-9\]?"

    send_gdb "ptype class vB\n"
    gdb_expect {
	-re "type = class vB : public virtual vA \{${ws}public:${ws}int vb;${ws}int vx;${ws}vB & operator=\\(vB const ?&\\);${ws}vB\\((vB const|const vB) ?&\\);${ws}vB\\((void|)\\);${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"
        }
	-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)"
	}
	-re ".*$gdb_prompt $" {
	    fail "ptype class vB"
	}
	timeout {
	    fail "ptype class vB (timeout)"
	    return
	}
    }

    # Accept the form with embedded GNU style mangled virtual table constructs
    # for now, but with a FIXME.  At some future point, gdb should use a
    # portable representation for the virtual table constructs.

    send_gdb "ptype class vC\n"
    gdb_expect {
	-re "type = class vC : public virtual vA \{${ws}public:${ws}int vc;${ws}int vx;${ws}vC & operator=\\(vC const ?&\\);${ws}vC\\((vC const|const vC) ?&\\);${ws}vC\\((void|)\\);${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"
        }
	-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)"
	}
	-re ".*$gdb_prompt $" {
	    fail "ptype class vC"
	}
	timeout {
	    fail "ptype class vC (timeout)"
	    return
	}
    }

    # Accept the form with embedded GNU style mangled virtual table constructs
    # for now, but with a FIXME.  At some future point, gdb should use a
    # portable representation for the virtual table constructs.

    send_gdb "ptype class vD\n"
    gdb_expect {
	-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|const vD) ?&\\);${ws}vD\\((void|)\\);${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"
        }
	-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)"
	}
	-re ".*$gdb_prompt $" {
	    fail "ptype class vD"
	}
	timeout {
	    fail "ptype class vD (timeout)"
	    return
	}
    }

    # Accept the form with embedded GNU style mangled virtual table constructs
    # for now, but with a FIXME.  At some future point, gdb should use a
    # portable representation for the virtual table constructs.

    send_gdb "ptype class vE\n"
    gdb_expect {
	-re "type = class vE : public virtual vD \{${ws}public:${ws}int ve;${ws}int vx;${ws}vE & operator=\\(vE const ?&\\);${ws}vE\\((vE const|const vE) ?&\\);${ws}vE\\((void|)\\);${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"
        }
	-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)"
	}
	-re ".*$gdb_prompt $" {
	    fail "ptype class vE"
	}
	timeout {
	    fail "ptype class vE (timeout)"
	    return
	}
    }

    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)|(const Base1)) ?&\\);${ws}Base1\\(int\\);${ws}\}$nl$gdb_prompt $" {
	    pass "ptype class Base1"
	}
	-re "type = class Base1 \{${ws}public:${ws}int x;${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 $" {
	    pass "ptype class Base1 (obsolescent gcc or gdb)"
	}
	-re ".*$gdb_prompt $" {
	    fail "ptype class Base1"
	}
	timeout {
	    fail "ptype class Base1 (timeout)"
	    return
	}
    }

    send_gdb "ptype class Foo\n"
    gdb_expect {
        -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"
        }
	-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|const Foo) ?&\\);${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 $" {
	    pass "ptype class Foo (obsolescent gcc or gdb)"
	}
	-re ".*$gdb_prompt $" {
	    fail "ptype class Foo"
	}
	timeout {
	    fail "ptype class Foo (timeout)"
	    return
	}
    }

    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|const Bar) ?&\\);${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 $" {
	    pass "ptype class Bar (obsolescent gcc or gdb)"
	}
	-re ".*$gdb_prompt $" {
	    fail "ptype class Bar"
	}
	timeout {
	    fail "ptype class Bar (timeout)"
	    return
	}
    }
}

#
# Test simple access to class members.
#

proc test_non_inherited_member_access {} {
    global gdb_prompt
    
    # Print non-inherited members of g_A.

    gdb_test "print g_A.a" ".* = 1" "g_A.a incorrect"

    gdb_test "print g_A.x" ".* = 2" "g_A.x incorrect"

    # Print non-inherited members of g_B.

    gdb_test "print g_B.b" ".* = 5" "g_B.b incorrect"

    gdb_test "print g_B.x" ".* = 6" "g_B.x incorrect"

    # Print non-inherited members of g_C.

    gdb_test "print g_C.c" ".* = 9" "g_C.c incorrect"

    gdb_test "print g_C.x" ".* = 10" "g_C.x incorrect"

    # Print non-inherited members of g_D.

    gdb_test "print g_D.d" ".* = 19" "g_D.d incorrect"

    gdb_test "print g_D.x" ".* = 20" "g_D.x incorrect"

    # Print non-inherited members of g_E.

    gdb_test "print g_E.e" ".* = 31" "g_E.e incorrect"

    gdb_test "print g_E.x" ".* = 32" "g_E.x incorrect"
}

#
# Try access to non-members that are members of another class.
# Should give errors.
#

proc test_wrong_class_members {} {
    global gdb_prompt

    gdb_test "print g_A.b" "There is no member( or method|) named b." "print g_A.b should be error"

    gdb_test "print g_B.c" "There is no member( or method|) named c." "print g_B.c should be error"

    gdb_test "print g_B.d" "There is no member( or method|) named d." "print g_B.d should be error"

    gdb_test "print g_C.b" "There is no member( or method|) named b." "print g_C.b should be error"

    gdb_test "print g_C.d" "There is no member( or method|) named d." "print g_C.d should be error"

    gdb_test "print g_D.e" "There is no member( or method|) named e." "print g_D.e should be error"
}

#
# Try access to non-members that are not members of any class.
# Should give errors.
#

proc test_nonexistent_members {} {
    global gdb_prompt

    gdb_test "print g_A.y" "There is no member( or method|) named y." "print g_A.y should be error"

    gdb_test "print g_B.z" "There is no member( or method|) named z." "print g_B.z should be error"

    gdb_test "print g_C.q" "There is no member( or method|) named q." "print g_C.q should be error"

    gdb_test "print g_D.p" "There is no member( or method|) named p." "print g_D.p should be error"
}

#
# Call a method that expects a base class parameter with base, inherited,
# and unrelated class arguments.
#

proc test_method_param_class {} {
    gdb_test "call class_param.Aptr_a (&g_A)" ".* = 1" "base class param->a"
    gdb_test "call class_param.Aptr_x (&g_A)" ".* = 2" "base class param->x"
    gdb_test "call class_param.Aptr_a (&g_B)" ".* = 3" "inherited class param->a"
    gdb_test "call class_param.Aptr_x (&g_B)" ".* = 4" "inherited class param->x"
    gdb_test "call class_param.Aref_a (g_A)" ".* = 1" "base class (&param)->a"
    gdb_test "call class_param.Aref_x (g_A)" ".* = 2" "base class (&param)->x"
    gdb_test "call class_param.Aref_a (g_B)" ".* = 3" "inherited class (&param)->a"
    gdb_test "call class_param.Aref_x (g_B)" ".* = 4" "inherited class (&param)->x"
    gdb_test "call class_param.Aval_a (g_A)" ".* = 1" "base class param.a"
    gdb_test "call class_param.Aval_x (g_A)" ".* = 2" "base class param.x"
    gdb_test "call class_param.Aval_a (g_B)" ".* = 3" "inherited class param.a"
    gdb_test "call class_param.Aval_x (g_B)" ".* = 4" "inherited class param.x"

    gdb_test "call class_param.Aptr_a (&foo)" "Cannot resolve .*" "unrelated class *param"
    gdb_test "call class_param.Aref_a (foo)" "Cannot resolve .*" "unrelated class &param"
    gdb_test "call class_param.Aval_a (foo)" "Cannot resolve .*" "unrelated class param"
}

#
# Examine a class with an enum field.
#

proc test_enums {} {
    global gdb_prompt