URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [gdb/] [testsuite/] [gdb.base/] [pointers.exp] - Blame information for rev 1765

Details | Compare with Previous | View Log


# Copyright 1998, 1999, 2000 Free Software Foundation, Inc.
 
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
# Please email any bugs, comments, and/or additions to this file to:
# bug-gdb@prep.ai.mit.edu
 
# This file was written by Elena Zannoni (ezannoni@cygnus.com)
 
# This file is part of the gdb testsuite
#
# tests for pointer arithmetic and pointer dereferencing
# with integer type variables and pointers to integers
#
 
if $tracelevel then {
        strace $tracelevel
        }
 
#
# test running programs
#
set prms_id 0
set bug_id 0
 
set testfile "pointers"
set srcfile ${testfile}.c
set binfile ${objdir}/${subdir}/${testfile}
 
if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug additional_flags=-w}] != "" } {
     gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
    }
 
if [get_compiler_info ${binfile}] {
    return -1;
}
 
gdb_exit
gdb_start
gdb_reinitialize_dir $srcdir/$subdir
gdb_load ${binfile}
 
 
#
# set it up at a breakpoint so we can play with the variable values
#
 
if ![runto_main] then {
    perror "couldn't run to breakpoint"
    continue
}
 
gdb_test "next " "more_code.*;" "continuing after dummy()"
 
 
#
# let's see if gdb catches some illegal operations on pointers
#
# I must comment these out because strict type checking is not
# supported in this version of GDB. I do not really know
# what the expected gdb reply is.
#
 
#send_gdb "print v_int_pointer2 = &v_int_pointer\n"
#gdb_expect {
#    -re ".*.*$gdb_prompt $" {
#        pass "illegal pointer assignment rejected"
#      }
#    -re ".*$gdb_prompt $" { fail "illegal pointer assignment rejected" }
#    timeout           { fail "(timeout) illegal pointer assignment rejected" }
#  }
 
 
#send_gdb "print v_unsigned_int_pointer = &v_int\n"
#gdb_expect {
#    -re ".*.*$gdb_prompt $" {
#        pass "illegal pointer assignment rejected"
#      }
#    -re ".*$gdb_prompt $" { fail "illegal pointer assignment rejected" }
#    timeout           { fail "(timeout) ilegal pointer assignment rejected" }
#  }
 
#send_gdb "print v_unsigned_int_pointer == v_double_pointer\n"
#gdb_expect {
#    -re ".*.*$gdb_prompt $" {
#        pass "illegal pointer operation (+) rejected"
#      }
#    -re ".*$gdb_prompt $" { fail "illegal pointer operation (+) rejected" }
#    timeout           { fail "(timeout) illegal pointer operation (+) rejected" }
#  }
 
 
#send_gdb "print v_unsigned_int_pointer * v_double_pointer\n"
#gdb_expect {
#    -re ".*Argument to arithmetic operation not a number or boolean.*$gdb_prompt $" {
#        pass "illegal pointer operation (*) rejected"
#      }
#    -re ".*$gdb_prompt $" { fail "illegal pointer operation (*) rejected" }
#    timeout           { fail "(timeout) illegal pointer operation (*) rejected" }
#  }
 
 
#send_gdb "print v_unsigned_int_pointer = v_double_pointer\n"
#gdb_expect {
#    -re ".*.*$gdb_prompt $" {
#        pass "ilegal pointer assignment rejected"
#      }
#    -re ".*$gdb_prompt $" { fail "illegal pointer assignment rejected" }
#    timeout           { fail "(timeout) illegal pointer assignment rejected" }
#  }
 
 
#send_gdb "print v_unsigned_int_pointer = v_unsigned_int\n"
#gdb_expect {
#    -re ".*.*$gdb_prompt $" {
#        pass "illegal pointer assignment rejected"
#      }
#    -re ".*$gdb_prompt $" { fail "illegal pointer assignment rejected" }
#    timeout           { fail "(timeout) illegal pointer assignment rejected" }
#  }
 
gdb_test "set variable v_int_pointer=&v_int_array\[0\]" "" "set pointer to beginning of array"
gdb_test "set variable v_int_pointer2=&v_int_array\[1\]" "" "set pointer to end of array"
 
 
send_gdb "print *v_int_pointer\n"
gdb_expect {
    -re ".*= 6.*$gdb_prompt $" {
        pass "print object pointed to"
      }
    -re ".*$gdb_prompt $" { fail "print object pointed to" }
    timeout           { fail "(timeout) print object pointed to" }
  }
 
send_gdb "print *v_int_pointer2\n"
gdb_expect {
    -re ".*= 18.*$gdb_prompt $" {
        pass "print object pointed to"
      }
    -re ".*$gdb_prompt $" { fail "print object pointed to" }
    timeout           { fail "(timeout) print object pointed to" }
  }
 
 
send_gdb "print v_int_pointer == v_int_pointer2\n"
gdb_expect {
    -re ".*= $false.*$gdb_prompt $" {
        pass "pointer1==pointer2"
      }
    -re ".*$gdb_prompt $" { fail "pointer1==pointer2" }
    timeout           { fail "(timeout) pointer1==pointer2" }
  }
 
send_gdb "print v_int_pointer != v_int_pointer2\n"
gdb_expect {
    -re ".*= $true.*$gdb_prompt $" {
        pass "pointer1!=pointer2"
      }
    -re ".*$gdb_prompt $" { fail "pointer1!=pointer2" }
    timeout           { fail "(timeout) pointer1!=pointer2" }
  }
 
 
send_gdb "print v_int_pointer <= v_int_pointer2\n"
gdb_expect {
    -re ".*= $true.*$gdb_prompt $" {
        pass "pointer1<=pointer2"
      }
    -re ".*$gdb_prompt $" { fail "pointer1<=pointer2" }
    timeout           { fail "(timeout) pointer1<=pointer2" }
  }
 
 
send_gdb "print v_int_pointer >= v_int_pointer2\n"
gdb_expect {
    -re ".*= $false.*$gdb_prompt $" {
        pass "pointer1>=pointer2"
      }
    -re ".*$gdb_prompt $" { fail "pointer1>=pointer2" }
    timeout           { fail "(timeout) pointer1>=pointer2" }
  }
 
 
send_gdb "print v_int_pointer < v_int_pointer2\n"
gdb_expect {
    -re ".*= $true.*$gdb_prompt $" {
        pass "pointer1
      }
    -re ".*$gdb_prompt $" { fail "pointer1
    timeout           { fail "(timeout) pointer1
  }
 
send_gdb "print v_int_pointer > v_int_pointer2\n"
gdb_expect {
    -re ".*= $false.*$gdb_prompt $" {
        pass "pointer1>pointer2"
      }
    -re ".*$gdb_prompt $" { fail "pointer1>pointer2" }
    timeout           { fail "(timeout) pointer1>pointer2" }
  }
 
 
gdb_test "set variable y = *v_int_pointer++" "" "set y = *v_int_pointer++"
send_gdb "print y\n"
gdb_expect {
    -re ".*= 6.*$gdb_prompt $" {
        send_gdb "print *v_int_pointer\n"
        gdb_expect {
             -re ".*= 18.*$gdb_prompt $" {
                 pass "pointer assignment and increment"
               }
             -re ".*$gdb_prompt $" { fail "pointer assignment and increment" }
             timeout           { fail "(timeout) pointer assignment and increment" }
         }
         }
    -re ".*$gdb_prompt $" { fail "pointer assignment and increment" }
    timeout           { fail "(timeout) pointer assignment and increment" }
  }
 
 
 
 
gdb_test "set variable y = *--v_int_pointer2" "" "set y = *--v_int_pointer2"
send_gdb "print y\n"
gdb_expect {
    -re ".*= 6.*$gdb_prompt $" {
        send_gdb "print *v_int_pointer2\n"
        gdb_expect {
             -re ".*= 6.*$gdb_prompt $" {
                 pass "pointer decrement and assignment"
               }
             -re ".*$gdb_prompt $" { fail "pointer decrement and assignment" }
             timeout           { fail "(timeout) pointer decrement and assignment" }
         }
         }
    -re ".*$gdb_prompt $" { fail "pointer decrement and assignment" }
    timeout           { fail "(timeout) pointer decrement and assignment" }
  }
 
gdb_test "set variable y =v_int_pointer-v_int_pointer2" "" "set y =v_int_pointer-v_int_pointer2"
send_gdb "print y\n"
gdb_expect {
    -re ".*= 1.*$gdb_prompt $" {
        pass "pointer1-pointer2"
      }
    -re ".*$gdb_prompt $" { fail "pointer1-pointer2" }
    timeout           { fail "(timeout) pointer1-pointer2" }
  }
 
gdb_test "set variable v_int_pointer=v_int_array" "" "set v_int_pointer=v_int_array"
send_gdb "print *v_int_pointer\n"
gdb_expect {
    -re ".*= 6.*$gdb_prompt $" {
        pass "print array element through pointer"
      }
    -re ".*$gdb_prompt $" { fail "print array element through pointer" }
    timeout           { fail "(timeout) print array element through pointer" }
  }
 
 
send_gdb "print *(v_int_pointer+1)\n"
gdb_expect {
    -re ".*= 18.*$gdb_prompt $" {
        pass "print array element through pointer"
      }
    -re ".*$gdb_prompt $" { fail "print array element through pointer" }
    timeout           { fail "(timeout) print array element through pointer" }
  }
 
# test print elements of array through pointers
 
send_gdb "print (*rptr)\[0\]\n"
gdb_expect {
    -re ".*= 0.*$gdb_prompt $" {
        pass "print array element through pointer"
      }
    -re ".*$gdb_prompt $" { fail "print array element through pointer" }
    timeout           { fail "(timeout) print array element through pointer" }
  }
 
send_gdb "print (*rptr)\[1\]\n"
gdb_expect {
    -re ".*= 1.*$gdb_prompt $" {
        pass "print array element through pointer"
      }
    -re ".*$gdb_prompt $" { fail "print array element through pointer" }
    timeout           { fail "(timeout) print array element through pointer" }
  }
 
 
send_gdb "print (*rptr)\[2\]\n"
gdb_expect {
    -re ".*= 2.*$gdb_prompt $" {
        pass "print array element through pointer"
      }
    -re ".*$gdb_prompt $" { fail "print array element through pointer" }
    timeout           { fail "(timeout) print array element through pointer" }
  }
 
gdb_test "set variable rptr = rptr+1" "" "increment rptr"
 
send_gdb "print (*rptr)\[0\]\n"
gdb_expect {
    -re ".*= 3.*$gdb_prompt $" {
        pass "print array element through pointer"
      }
    -re ".*$gdb_prompt $" { fail "print array element through pointer" }
    timeout           { fail "(timeout) print array element through pointer" }
  }
 
 
send_gdb "print (*rptr)\[1\]\n"
gdb_expect {
    -re ".*= 4.*$gdb_prompt $" {
        pass "print array element through pointer"
      }
    -re ".*$gdb_prompt $" { fail "print array element through pointer" }
    timeout           { fail "(timeout) print array element through pointer" }
  }
 
 
send_gdb "print (*rptr)\[2\]\n"
gdb_expect {
    -re ".*= 5.*$gdb_prompt $" {
        pass "print array element through pointer"
      }
    -re ".*$gdb_prompt $" { fail "print array element through pointer" }
    timeout           { fail "(timeout) print array element through pointer" }
  }
 
 
send_gdb "print *( *(matrix+1) +2)\n"
gdb_expect {
    -re ".*= 5.*$gdb_prompt $" {
        pass "print array element w/ pointer arithmetic"
      }
    -re ".*$gdb_prompt $" { fail "print array element w/ pointer arithemtic" }
    timeout           { fail "(timeout) print array element w/ pointer arithmetic" }
  }
 
 
send_gdb "print **ptr_to_ptr_to_float\n"
gdb_expect {
    -re ".*= 100.*$gdb_prompt $" {
        pass "print through ptr to ptr"
      }
    -re ".*$gdb_prompt $" { fail "print through ptr to ptr" }
    timeout           { fail "(timeout) print through ptr to ptr" }
  }
 
# tests for pointers
# with elementary type variables and pointers.
#
 
send_gdb "break marker1\n" ; gdb_expect -re ".*$gdb_prompt $"
 
    send_gdb "cont\n"
    gdb_expect {
        -re "Break.* marker1 \\(\\) at .*:$decimal.*$gdb_prompt $" {
            send_gdb "up\n"
            gdb_expect {
                -re ".*more_code.*$gdb_prompt $" {
                    pass "up from marker1"
                }
                -re ".*$gdb_prompt $" {
                    fail "up from marker1"
                }
                timeout { fail "up from marker1 (timeout)" }
            }
        }
        -re "$gdb_prompt $" { fail "continue to marker1"  }
        timeout { fail "(timeout) continue to marker1"  }
    }
 
 
send_gdb "print *pUC\n"
gdb_expect {
    -re ".\[0-9\]* = 21 \'.025\'.*$gdb_prompt $" {
        pass "print value of *pUC"
      }
    -re ".*$gdb_prompt $" { fail "print value of *pUC" }
    timeout           { fail "(timeout) print value of *pUC" }
  }
 
 
send_gdb "ptype pUC\n"
gdb_expect {
    -re "type = unsigned char \\*.*$gdb_prompt $"  { pass "ptype pUC" }
    -re ".*$gdb_prompt $"   {  fail "ptype pUC" }
    timeout             { fail "(timeout) ptype pUC" }
}
 
send_gdb "print *pS\n"
gdb_expect {
    -re ".\[0-9\]* = -14.*$gdb_prompt $" {
        pass "print value of *pS"
      }
    -re ".*$gdb_prompt $" { fail "print value of *pS" }
    timeout           { fail "(timeout) print value of *pS" }
  }
 
 
send_gdb "ptype pS\n"
gdb_expect {
    -re "type = short \\*.*$gdb_prompt $"  { pass "ptype pS" }
    -re "type = short int \\*.*$gdb_prompt $"  { pass "ptype pS" }
    -re ".*$gdb_prompt $"   {  fail "ptype pS" }
    timeout             { fail "(timeout) ptype pS" }
}
 
send_gdb "print *pUS\n"
gdb_expect {
    -re ".\[0-9\]* = 7.*$gdb_prompt $" {
        pass "print value of *pUS"
      }
    -re ".*$gdb_prompt $" { fail "print value of *pUS" }
    timeout           { fail "(timeout) print value of *pUS" }
  }
 
 
send_gdb "ptype pUS\n"
gdb_expect {
    -re "type = unsigned short \\*.*$gdb_prompt $"  { pass "ptype pUS" }
    -re "type = short unsigned int \\*.*$gdb_prompt $"  { pass "ptype pUS" }
    -re ".*$gdb_prompt $"   {  fail "ptype pUS" }
    timeout             { fail "(timeout) ptype pUS" }
}
 
send_gdb "print *pI\n"
gdb_expect {
    -re ".\[0-9\]* = 102.*$gdb_prompt $" {
        pass "print value of *pI"
      }
    -re ".*$gdb_prompt $" { fail "print value of *pI" }
    timeout           { fail "(timeout) print value of *pI" }
  }
 
 
send_gdb "ptype pI\n"
gdb_expect {
    -re "type = int \\*.*$gdb_prompt $"  { pass "ptype pI" }
    -re ".*$gdb_prompt $"   {  fail "ptype pI" }
    timeout             { fail "(timeout) ptype pI" }
}
 
send_gdb "print *pUI\n"
gdb_expect {
    -re ".\[0-9\]* = 1002.*$gdb_prompt $" {
        pass "print value of *pUI"
      }
    -re ".*$gdb_prompt $" { fail "print value of *pUI" }
    timeout           { fail "(timeout) print value of *pUI" }
  }
 
 
send_gdb "ptype pUI\n"
gdb_expect {
    -re "type = unsigned int \\*.*$gdb_prompt $"  { pass "ptype pUI" }
    -re ".*$gdb_prompt $"   {  fail "ptype pUI" }
    timeout             { fail "(timeout) ptype pUI" }
}
 
send_gdb "print *pL\n"
gdb_expect {
    -re ".\[0-9\]* = -234.*$gdb_prompt $" {
        pass "print value of *pL"
      }
    -re ".*$gdb_prompt $" { fail "print value of *pL" }
    timeout           { fail "(timeout) print value of *pL" }
  }
 
 
send_gdb "ptype pL\n"
gdb_expect {
    -re "type = long \\*.*$gdb_prompt $"  { pass "ptype pL" }
    -re "type = long int \\*.*$gdb_prompt $"  { pass "ptype pL" }
    -re ".*$gdb_prompt $"   {  fail "ptype pL" }
    timeout             { fail "(timeout) ptype pL" }
}
 
send_gdb "print *pUL\n"
gdb_expect {
    -re ".\[0-9\]* = 234.*$gdb_prompt $" {
        pass "print value of *pUL"
      }
    -re ".*$gdb_prompt $" { fail "print value of *pUL" }
    timeout           { fail "(timeout) print value of *pUL" }
  }
 
 
send_gdb "ptype pUL\n"
gdb_expect {
    -re "type = unsigned long \\*.*$gdb_prompt $"  { pass "ptype pUL" }
    -re "type = long unsigned int \\*.*$gdb_prompt $"  { pass "ptype pUL" }
    -re ".*$gdb_prompt $"   {  fail "ptype pUL" }
    timeout             { fail "(timeout) ptype pUL" }
}
 
send_gdb "print *pF\n"
gdb_expect {
    -re ".\[0-9\]* = 1.2\[0-9\]*e\\+10.*$gdb_prompt $" {
        pass "print value of *pF"
      }
    -re ".*$gdb_prompt $" { fail "print value of *pF" }
    timeout           { fail "(timeout) print value of *pF" }
  }
 
 
send_gdb "ptype pF\n"
gdb_expect {
    -re "type = float \\*.*$gdb_prompt $"  { pass "ptype pF" }
    -re ".*$gdb_prompt $"   {  fail "ptype pF" }
    timeout             { fail "(timeout) ptype pF" }
}
 
send_gdb "print *pD\n"
gdb_expect {
    -re ".\[0-9\]* = -1.2\[0-9\]*e\\-37.*$gdb_prompt $" {
        pass "print value of *pD"
      }
    -re ".*$gdb_prompt $" { fail "print value of *pD" }
    timeout           { fail "(timeout) print value of *pD" }
  }
 
 
send_gdb "ptype pD\n"
gdb_expect {
    -re "type = double \\*.*$gdb_prompt $"  { pass "ptype pD" }
    -re ".*$gdb_prompt $"   {  fail "ptype pD" }
    timeout             { fail "(timeout) ptype pD" }
}
 
send_gdb "print ******ppppppC\n"
gdb_expect {
    -re ".\[0-9\]* = 65 \'A\'.*$gdb_prompt $" {
        pass "print value of ******ppppppC"
      }
    -re ".*$gdb_prompt $" { fail "print value of ******ppppppC" }
    timeout           { fail "(timeout) print value of ******ppppppC" }
  }
 
 
send_gdb "ptype pC\n"
gdb_expect {
    -re "type = char \\*.*$gdb_prompt $"  { pass "ptype pC" }
    -re ".*$gdb_prompt $"   {  fail "ptype pC" }
    timeout             { fail "(timeout) ptype pC" }
}
 
send_gdb "ptype ppC\n"
gdb_expect {
    -re "type = char \\*\\*.*$gdb_prompt $"  { pass "ptype ppC" }
    -re ".*$gdb_prompt $"   {  fail "ptype ppC" }
    timeout             { fail "(timeout) ptype ppC" }
}
 
send_gdb "ptype pppC\n"
gdb_expect {
    -re "type = char \\*\\*\\*.*$gdb_prompt $"  { pass "ptype  pppC" }
    -re ".*$gdb_prompt $"   {  fail "ptype pppC" }
    timeout             { fail "(timeout) ptype pppC" }
}
 
send_gdb "ptype ppppC\n"
gdb_expect {
    -re "type = char \\*\\*\\*\\*.*$gdb_prompt $"  { pass "ptype ppppC" }
    -re ".*$gdb_prompt $"   {  fail "ptype ppppC" }
    timeout             { fail "(timeout) ptype ppppC" }
}
 
send_gdb "ptype pppppC\n"
gdb_expect {
    -re "type = char \\*\\*\\*\\*\\*.*$gdb_prompt $"  { pass "ptype pppppC" }
    -re ".*$gdb_prompt $"   {  fail "ptype pppppC" }
    timeout             { fail "(timeout) ptype pppppC" }
}
 
send_gdb "ptype ppppppC\n"
gdb_expect {
    -re "type = char \\*\\*\\*\\*\\*\\*.*$gdb_prompt $"  { pass "ptype ppppppC" }
    -re ".*$gdb_prompt $"   {  fail "ptype ppppppC" }
    timeout             { fail "(timeout) ptype ppppppC" }
}
 

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [gdb/] [testsuite/] [gdb.base/] [pointers.exp] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	578	markom	`# Copyright 1998, 1999, 2000 Free Software Foundation, Inc.`
2
3			`# This program is free software; you can redistribute it and/or modify`
4			`# it under the terms of the GNU General Public License as published by`
5			`# the Free Software Foundation; either version 2 of the License, or`
6			`# (at your option) any later version.`
7			`#`
8			`# This program is distributed in the hope that it will be useful,`
9			`# but WITHOUT ANY WARRANTY; without even the implied warranty of`
10			`# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
11			`# GNU General Public License for more details.`
12			`#`
13			`# You should have received a copy of the GNU General Public License`
14			`# along with this program; if not, write to the Free Software`
15			`# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.`
16
17			`# Please email any bugs, comments, and/or additions to this file to:`
18			`# bug-gdb@prep.ai.mit.edu`
19
20			`# This file was written by Elena Zannoni (ezannoni@cygnus.com)`
21
22			`# This file is part of the gdb testsuite`
23			`#`
24			`# tests for pointer arithmetic and pointer dereferencing`
25			`# with integer type variables and pointers to integers`
26			`#`
27
28			`if $tracelevel then {`
29			`strace $tracelevel`
30			`}`
31
32			`#`
33			`# test running programs`
34			`#`
35			`set prms_id 0`
36			`set bug_id 0`
37
38			`set testfile "pointers"`
39			`set srcfile ${testfile}.c`
40			`set binfile ${objdir}/${subdir}/${testfile}`
41
42			`if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug additional_flags=-w}] != "" } {`
43			`gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."`
44			`}`
45
46			`if [get_compiler_info ${binfile}] {`
47			`return -1;`
48			`}`
49
50			`gdb_exit`
51			`gdb_start`
52			`gdb_reinitialize_dir $srcdir/$subdir`
53			`gdb_load ${binfile}`
54
55
56			`#`
57			`# set it up at a breakpoint so we can play with the variable values`
58			`#`
59
60			`if ![runto_main] then {`
61			`perror "couldn't run to breakpoint"`
62			`continue`
63			`}`
64
65			`gdb_test "next " "more_code.*;" "continuing after dummy()"`
66
67
68			`#`
69			`# let's see if gdb catches some illegal operations on pointers`
70			`#`
71			`# I must comment these out because strict type checking is not`
72			`# supported in this version of GDB. I do not really know`
73			`# what the expected gdb reply is.`
74			`#`
75
76			`#send_gdb "print v_int_pointer2 = &v_int_pointer\n"`
77			`#gdb_expect {`
78			`# -re "..$gdb_prompt $" {`
79			`# pass "illegal pointer assignment rejected"`
80			`# }`
81			`# -re ".*$gdb_prompt $" { fail "illegal pointer assignment rejected" }`
82			`# timeout { fail "(timeout) illegal pointer assignment rejected" }`
83			`# }`
84
85
86			`#send_gdb "print v_unsigned_int_pointer = &v_int\n"`
87			`#gdb_expect {`
88			`# -re "..$gdb_prompt $" {`
89			`# pass "illegal pointer assignment rejected"`
90			`# }`
91			`# -re ".*$gdb_prompt $" { fail "illegal pointer assignment rejected" }`
92			`# timeout { fail "(timeout) ilegal pointer assignment rejected" }`
93			`# }`
94
95			`#send_gdb "print v_unsigned_int_pointer == v_double_pointer\n"`
96			`#gdb_expect {`
97			`# -re "..$gdb_prompt $" {`
98			`# pass "illegal pointer operation (+) rejected"`
99			`# }`
100			`# -re ".*$gdb_prompt $" { fail "illegal pointer operation (+) rejected" }`
101			`# timeout { fail "(timeout) illegal pointer operation (+) rejected" }`
102			`# }`
103
104
105			`#send_gdb "print v_unsigned_int_pointer * v_double_pointer\n"`
106			`#gdb_expect {`
107			`# -re ".Argument to arithmetic operation not a number or boolean.$gdb_prompt $" {`
108			`# pass "illegal pointer operation (*) rejected"`
109			`# }`
110			`# -re ".$gdb_prompt $" { fail "illegal pointer operation () rejected" }`
111			`# timeout { fail "(timeout) illegal pointer operation (*) rejected" }`
112			`# }`
113
114
115			`#send_gdb "print v_unsigned_int_pointer = v_double_pointer\n"`
116			`#gdb_expect {`
117			`# -re "..$gdb_prompt $" {`
118			`# pass "ilegal pointer assignment rejected"`
119			`# }`
120			`# -re ".*$gdb_prompt $" { fail "illegal pointer assignment rejected" }`
121			`# timeout { fail "(timeout) illegal pointer assignment rejected" }`
122			`# }`
123
124
125			`#send_gdb "print v_unsigned_int_pointer = v_unsigned_int\n"`
126			`#gdb_expect {`
127			`# -re "..$gdb_prompt $" {`
128			`# pass "illegal pointer assignment rejected"`
129			`# }`
130			`# -re ".*$gdb_prompt $" { fail "illegal pointer assignment rejected" }`
131			`# timeout { fail "(timeout) illegal pointer assignment rejected" }`
132			`# }`
133
134			`gdb_test "set variable v_int_pointer=&v_int_array\[0\]" "" "set pointer to beginning of array"`
135			`gdb_test "set variable v_int_pointer2=&v_int_array\[1\]" "" "set pointer to end of array"`
136
137
138			`send_gdb "print *v_int_pointer\n"`
139			`gdb_expect {`
140			`-re ".= 6.$gdb_prompt $" {`
141			`pass "print object pointed to"`
142			`}`
143			`-re ".*$gdb_prompt $" { fail "print object pointed to" }`
144			`timeout { fail "(timeout) print object pointed to" }`
145			`}`
146
147			`send_gdb "print *v_int_pointer2\n"`
148			`gdb_expect {`
149			`-re ".= 18.$gdb_prompt $" {`
150			`pass "print object pointed to"`
151			`}`
152			`-re ".*$gdb_prompt $" { fail "print object pointed to" }`
153			`timeout { fail "(timeout) print object pointed to" }`
154			`}`
155
156
157			`send_gdb "print v_int_pointer == v_int_pointer2\n"`
158			`gdb_expect {`
159			`-re ".= $false.$gdb_prompt $" {`
160			`pass "pointer1==pointer2"`
161			`}`
162			`-re ".*$gdb_prompt $" { fail "pointer1==pointer2" }`
163			`timeout { fail "(timeout) pointer1==pointer2" }`
164			`}`
165
166			`send_gdb "print v_int_pointer != v_int_pointer2\n"`
167			`gdb_expect {`
168			`-re ".= $true.$gdb_prompt $" {`
169			`pass "pointer1!=pointer2"`
170			`}`
171			`-re ".*$gdb_prompt $" { fail "pointer1!=pointer2" }`
172			`timeout { fail "(timeout) pointer1!=pointer2" }`
173			`}`
174
175
176			`send_gdb "print v_int_pointer <= v_int_pointer2\n"`
177			`gdb_expect {`
178			`-re ".= $true.$gdb_prompt $" {`
179			`pass "pointer1<=pointer2"`
180			`}`
181			`-re ".*$gdb_prompt $" { fail "pointer1<=pointer2" }`
182			`timeout { fail "(timeout) pointer1<=pointer2" }`
183			`}`
184
185
186			`send_gdb "print v_int_pointer >= v_int_pointer2\n"`
187			`gdb_expect {`
188			`-re ".= $false.$gdb_prompt $" {`
189			`pass "pointer1>=pointer2"`
190			`}`
191			`-re ".*$gdb_prompt $" { fail "pointer1>=pointer2" }`
192			`timeout { fail "(timeout) pointer1>=pointer2" }`
193			`}`
194
195
196			`send_gdb "print v_int_pointer < v_int_pointer2\n"`
197			`gdb_expect {`
198			`-re ".= $true.$gdb_prompt $" {`
199			`pass "pointer1`
200			`}`
201			`-re ".*$gdb_prompt $" { fail "pointer1`
202			`timeout { fail "(timeout) pointer1`
203			`}`
204
205			`send_gdb "print v_int_pointer > v_int_pointer2\n"`
206			`gdb_expect {`
207			`-re ".= $false.$gdb_prompt $" {`
208			`pass "pointer1>pointer2"`
209			`}`
210			`-re ".*$gdb_prompt $" { fail "pointer1>pointer2" }`
211			`timeout { fail "(timeout) pointer1>pointer2" }`
212			`}`
213
214
215			`gdb_test "set variable y = v_int_pointer++" "" "set y = v_int_pointer++"`
216			`send_gdb "print y\n"`
217			`gdb_expect {`
218			`-re ".= 6.$gdb_prompt $" {`
219			`send_gdb "print *v_int_pointer\n"`
220			`gdb_expect {`
221			`-re ".= 18.$gdb_prompt $" {`
222			`pass "pointer assignment and increment"`
223			`}`
224			`-re ".*$gdb_prompt $" { fail "pointer assignment and increment" }`
225			`timeout { fail "(timeout) pointer assignment and increment" }`
226			`}`
227			`}`
228			`-re ".*$gdb_prompt $" { fail "pointer assignment and increment" }`
229			`timeout { fail "(timeout) pointer assignment and increment" }`
230			`}`
231
232
233
234
235			`gdb_test "set variable y = --v_int_pointer2" "" "set y = --v_int_pointer2"`
236			`send_gdb "print y\n"`
237			`gdb_expect {`
238			`-re ".= 6.$gdb_prompt $" {`
239			`send_gdb "print *v_int_pointer2\n"`
240			`gdb_expect {`
241			`-re ".= 6.$gdb_prompt $" {`
242			`pass "pointer decrement and assignment"`
243			`}`
244			`-re ".*$gdb_prompt $" { fail "pointer decrement and assignment" }`
245			`timeout { fail "(timeout) pointer decrement and assignment" }`
246			`}`
247			`}`
248			`-re ".*$gdb_prompt $" { fail "pointer decrement and assignment" }`
249			`timeout { fail "(timeout) pointer decrement and assignment" }`
250			`}`
251
252			`gdb_test "set variable y =v_int_pointer-v_int_pointer2" "" "set y =v_int_pointer-v_int_pointer2"`
253			`send_gdb "print y\n"`
254			`gdb_expect {`
255			`-re ".= 1.$gdb_prompt $" {`
256			`pass "pointer1-pointer2"`
257			`}`
258			`-re ".*$gdb_prompt $" { fail "pointer1-pointer2" }`
259			`timeout { fail "(timeout) pointer1-pointer2" }`
260			`}`
261
262			`gdb_test "set variable v_int_pointer=v_int_array" "" "set v_int_pointer=v_int_array"`
263			`send_gdb "print *v_int_pointer\n"`
264			`gdb_expect {`
265			`-re ".= 6.$gdb_prompt $" {`
266			`pass "print array element through pointer"`
267			`}`
268			`-re ".*$gdb_prompt $" { fail "print array element through pointer" }`
269			`timeout { fail "(timeout) print array element through pointer" }`
270			`}`
271
272
273			`send_gdb "print *(v_int_pointer+1)\n"`
274			`gdb_expect {`
275			`-re ".= 18.$gdb_prompt $" {`
276			`pass "print array element through pointer"`
277			`}`
278			`-re ".*$gdb_prompt $" { fail "print array element through pointer" }`
279			`timeout { fail "(timeout) print array element through pointer" }`
280			`}`
281
282			`# test print elements of array through pointers`
283
284			`send_gdb "print (*rptr)\[0\]\n"`
285			`gdb_expect {`
286			`-re ".= 0.$gdb_prompt $" {`
287			`pass "print array element through pointer"`
288			`}`
289			`-re ".*$gdb_prompt $" { fail "print array element through pointer" }`
290			`timeout { fail "(timeout) print array element through pointer" }`
291			`}`
292
293			`send_gdb "print (*rptr)\[1\]\n"`
294			`gdb_expect {`
295			`-re ".= 1.$gdb_prompt $" {`
296			`pass "print array element through pointer"`
297			`}`
298			`-re ".*$gdb_prompt $" { fail "print array element through pointer" }`
299			`timeout { fail "(timeout) print array element through pointer" }`
300			`}`
301
302
303			`send_gdb "print (*rptr)\[2\]\n"`
304			`gdb_expect {`
305			`-re ".= 2.$gdb_prompt $" {`
306			`pass "print array element through pointer"`
307			`}`
308			`-re ".*$gdb_prompt $" { fail "print array element through pointer" }`
309			`timeout { fail "(timeout) print array element through pointer" }`
310			`}`
311
312			`gdb_test "set variable rptr = rptr+1" "" "increment rptr"`
313
314			`send_gdb "print (*rptr)\[0\]\n"`
315			`gdb_expect {`
316			`-re ".= 3.$gdb_prompt $" {`
317			`pass "print array element through pointer"`
318			`}`
319			`-re ".*$gdb_prompt $" { fail "print array element through pointer" }`
320			`timeout { fail "(timeout) print array element through pointer" }`
321			`}`
322
323
324			`send_gdb "print (*rptr)\[1\]\n"`
325			`gdb_expect {`
326			`-re ".= 4.$gdb_prompt $" {`
327			`pass "print array element through pointer"`
328			`}`
329			`-re ".*$gdb_prompt $" { fail "print array element through pointer" }`
330			`timeout { fail "(timeout) print array element through pointer" }`
331			`}`
332
333
334			`send_gdb "print (*rptr)\[2\]\n"`
335			`gdb_expect {`
336			`-re ".= 5.$gdb_prompt $" {`
337			`pass "print array element through pointer"`
338			`}`
339			`-re ".*$gdb_prompt $" { fail "print array element through pointer" }`
340			`timeout { fail "(timeout) print array element through pointer" }`
341			`}`
342
343
344			`send_gdb "print ( (matrix+1) +2)\n"`
345			`gdb_expect {`
346			`-re ".= 5.$gdb_prompt $" {`
347			`pass "print array element w/ pointer arithmetic"`
348			`}`
349			`-re ".*$gdb_prompt $" { fail "print array element w/ pointer arithemtic" }`
350			`timeout { fail "(timeout) print array element w/ pointer arithmetic" }`
351			`}`
352
353
354			`send_gdb "print **ptr_to_ptr_to_float\n"`
355			`gdb_expect {`
356			`-re ".= 100.$gdb_prompt $" {`
357			`pass "print through ptr to ptr"`
358			`}`
359			`-re ".*$gdb_prompt $" { fail "print through ptr to ptr" }`
360			`timeout { fail "(timeout) print through ptr to ptr" }`
361			`}`
362
363			`# tests for pointers`
364			`# with elementary type variables and pointers.`
365			`#`
366
367			`send_gdb "break marker1\n" ; gdb_expect -re ".*$gdb_prompt $"`
368
369			`send_gdb "cont\n"`
370			`gdb_expect {`
371			`-re "Break.* marker1 \\(\\) at .:$decimal.$gdb_prompt $" {`
372			`send_gdb "up\n"`
373			`gdb_expect {`
374			`-re ".more_code.$gdb_prompt $" {`
375			`pass "up from marker1"`
376			`}`
377			`-re ".*$gdb_prompt $" {`
378			`fail "up from marker1"`
379			`}`
380			`timeout { fail "up from marker1 (timeout)" }`
381			`}`
382			`}`
383			`-re "$gdb_prompt $" { fail "continue to marker1" }`
384			`timeout { fail "(timeout) continue to marker1" }`
385			`}`
386
387
388			`send_gdb "print *pUC\n"`
389			`gdb_expect {`
390			`-re ".\[0-9\]* = 21 \'.025\'.*$gdb_prompt $" {`
391			`pass "print value of *pUC"`
392			`}`
393			`-re ".$gdb_prompt $" { fail "print value of pUC" }`
394			`timeout { fail "(timeout) print value of *pUC" }`
395			`}`
396
397
398			`send_gdb "ptype pUC\n"`
399			`gdb_expect {`
400			`-re "type = unsigned char \\.$gdb_prompt $" { pass "ptype pUC" }`
401			`-re ".*$gdb_prompt $" { fail "ptype pUC" }`
402			`timeout { fail "(timeout) ptype pUC" }`
403			`}`
404
405			`send_gdb "print *pS\n"`
406			`gdb_expect {`
407			`-re ".\[0-9\]* = -14.*$gdb_prompt $" {`
408			`pass "print value of *pS"`
409			`}`
410			`-re ".$gdb_prompt $" { fail "print value of pS" }`
411			`timeout { fail "(timeout) print value of *pS" }`
412			`}`
413
414
415			`send_gdb "ptype pS\n"`
416			`gdb_expect {`
417			`-re "type = short \\.$gdb_prompt $" { pass "ptype pS" }`
418			`-re "type = short int \\.$gdb_prompt $" { pass "ptype pS" }`
419			`-re ".*$gdb_prompt $" { fail "ptype pS" }`
420			`timeout { fail "(timeout) ptype pS" }`
421			`}`
422
423			`send_gdb "print *pUS\n"`
424			`gdb_expect {`
425			`-re ".\[0-9\]* = 7.*$gdb_prompt $" {`
426			`pass "print value of *pUS"`
427			`}`
428			`-re ".$gdb_prompt $" { fail "print value of pUS" }`
429			`timeout { fail "(timeout) print value of *pUS" }`
430			`}`
431
432
433			`send_gdb "ptype pUS\n"`
434			`gdb_expect {`
435			`-re "type = unsigned short \\.$gdb_prompt $" { pass "ptype pUS" }`
436			`-re "type = short unsigned int \\.$gdb_prompt $" { pass "ptype pUS" }`
437			`-re ".*$gdb_prompt $" { fail "ptype pUS" }`
438			`timeout { fail "(timeout) ptype pUS" }`
439			`}`
440
441			`send_gdb "print *pI\n"`
442			`gdb_expect {`
443			`-re ".\[0-9\]* = 102.*$gdb_prompt $" {`
444			`pass "print value of *pI"`
445			`}`
446			`-re ".$gdb_prompt $" { fail "print value of pI" }`
447			`timeout { fail "(timeout) print value of *pI" }`
448			`}`
449
450
451			`send_gdb "ptype pI\n"`
452			`gdb_expect {`
453			`-re "type = int \\.$gdb_prompt $" { pass "ptype pI" }`
454			`-re ".*$gdb_prompt $" { fail "ptype pI" }`
455			`timeout { fail "(timeout) ptype pI" }`
456			`}`
457
458			`send_gdb "print *pUI\n"`
459			`gdb_expect {`
460			`-re ".\[0-9\]* = 1002.*$gdb_prompt $" {`
461			`pass "print value of *pUI"`
462			`}`
463			`-re ".$gdb_prompt $" { fail "print value of pUI" }`
464			`timeout { fail "(timeout) print value of *pUI" }`
465			`}`
466
467
468			`send_gdb "ptype pUI\n"`
469			`gdb_expect {`
470			`-re "type = unsigned int \\.$gdb_prompt $" { pass "ptype pUI" }`
471			`-re ".*$gdb_prompt $" { fail "ptype pUI" }`
472			`timeout { fail "(timeout) ptype pUI" }`
473			`}`
474
475			`send_gdb "print *pL\n"`
476			`gdb_expect {`
477			`-re ".\[0-9\]* = -234.*$gdb_prompt $" {`
478			`pass "print value of *pL"`
479			`}`
480			`-re ".$gdb_prompt $" { fail "print value of pL" }`
481			`timeout { fail "(timeout) print value of *pL" }`
482			`}`
483
484
485			`send_gdb "ptype pL\n"`
486			`gdb_expect {`
487			`-re "type = long \\.$gdb_prompt $" { pass "ptype pL" }`
488			`-re "type = long int \\.$gdb_prompt $" { pass "ptype pL" }`
489			`-re ".*$gdb_prompt $" { fail "ptype pL" }`
490			`timeout { fail "(timeout) ptype pL" }`
491			`}`
492
493			`send_gdb "print *pUL\n"`
494			`gdb_expect {`
495			`-re ".\[0-9\]* = 234.*$gdb_prompt $" {`
496			`pass "print value of *pUL"`
497			`}`
498			`-re ".$gdb_prompt $" { fail "print value of pUL" }`
499			`timeout { fail "(timeout) print value of *pUL" }`
500			`}`
501
502
503			`send_gdb "ptype pUL\n"`
504			`gdb_expect {`
505			`-re "type = unsigned long \\.$gdb_prompt $" { pass "ptype pUL" }`
506			`-re "type = long unsigned int \\.$gdb_prompt $" { pass "ptype pUL" }`
507			`-re ".*$gdb_prompt $" { fail "ptype pUL" }`
508			`timeout { fail "(timeout) ptype pUL" }`
509			`}`
510
511			`send_gdb "print *pF\n"`
512			`gdb_expect {`
513			`-re ".\[0-9\]* = 1.2\[0-9\]e\\+10.$gdb_prompt $" {`
514			`pass "print value of *pF"`
515			`}`
516			`-re ".$gdb_prompt $" { fail "print value of pF" }`
517			`timeout { fail "(timeout) print value of *pF" }`
518			`}`
519
520
521			`send_gdb "ptype pF\n"`
522			`gdb_expect {`
523			`-re "type = float \\.$gdb_prompt $" { pass "ptype pF" }`
524			`-re ".*$gdb_prompt $" { fail "ptype pF" }`
525			`timeout { fail "(timeout) ptype pF" }`
526			`}`
527
528			`send_gdb "print *pD\n"`
529			`gdb_expect {`
530			`-re ".\[0-9\]* = -1.2\[0-9\]e\\-37.$gdb_prompt $" {`
531			`pass "print value of *pD"`
532			`}`
533			`-re ".$gdb_prompt $" { fail "print value of pD" }`
534			`timeout { fail "(timeout) print value of *pD" }`
535			`}`
536
537
538			`send_gdb "ptype pD\n"`
539			`gdb_expect {`
540			`-re "type = double \\.$gdb_prompt $" { pass "ptype pD" }`
541			`-re ".*$gdb_prompt $" { fail "ptype pD" }`
542			`timeout { fail "(timeout) ptype pD" }`
543			`}`
544
545			`send_gdb "print ******ppppppC\n"`
546			`gdb_expect {`
547			`-re ".\[0-9\]* = 65 \'A\'.*$gdb_prompt $" {`
548			`pass "print value of ******ppppppC"`
549			`}`
550			`-re ".$gdb_prompt $" { fail "print value of *****ppppppC" }`
551			`timeout { fail "(timeout) print value of ******ppppppC" }`
552			`}`
553
554
555			`send_gdb "ptype pC\n"`
556			`gdb_expect {`
557			`-re "type = char \\.$gdb_prompt $" { pass "ptype pC" }`
558			`-re ".*$gdb_prompt $" { fail "ptype pC" }`
559			`timeout { fail "(timeout) ptype pC" }`
560			`}`
561
562			`send_gdb "ptype ppC\n"`
563			`gdb_expect {`
564			`-re "type = char \\\\.*$gdb_prompt $" { pass "ptype ppC" }`
565			`-re ".*$gdb_prompt $" { fail "ptype ppC" }`
566			`timeout { fail "(timeout) ptype ppC" }`
567			`}`
568
569			`send_gdb "ptype pppC\n"`
570			`gdb_expect {`
571			`-re "type = char \\\\\\.$gdb_prompt $" { pass "ptype pppC" }`
572			`-re ".*$gdb_prompt $" { fail "ptype pppC" }`
573			`timeout { fail "(timeout) ptype pppC" }`
574			`}`
575
576			`send_gdb "ptype ppppC\n"`
577			`gdb_expect {`
578			`-re "type = char \\\\\\\\.*$gdb_prompt $" { pass "ptype ppppC" }`
579			`-re ".*$gdb_prompt $" { fail "ptype ppppC" }`
580			`timeout { fail "(timeout) ptype ppppC" }`
581			`}`
582
583			`send_gdb "ptype pppppC\n"`
584			`gdb_expect {`
585			`-re "type = char \\\\\\\\\\.$gdb_prompt $" { pass "ptype pppppC" }`
586			`-re ".*$gdb_prompt $" { fail "ptype pppppC" }`
587			`timeout { fail "(timeout) ptype pppppC" }`
588			`}`
589
590			`send_gdb "ptype ppppppC\n"`
591			`gdb_expect {`
592			`-re "type = char \\\\\\\\\\\\.*$gdb_prompt $" { pass "ptype ppppppC" }`
593			`-re ".*$gdb_prompt $" { fail "ptype ppppppC" }`
594			`timeout { fail "(timeout) ptype ppppppC" }`
595			`}`
596