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

Subversion Repositories or1k

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

Go to most recent revision | Details | Compare with Previous | View Log


# Copyright (C) 1998 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 ".*$gdb_prompt $" {}
                timeout { fail "up from marker1" }
            }
        }
        -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.375e-123.*$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/] [gdb-5.0/] [gdb/] [testsuite/] [gdb.base/] [pointers.exp] - Blame information for rev 1774

Line No.	Rev	Author	Line
1	106	markom	`# Copyright (C) 1998 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 ".*$gdb_prompt $" {}`
375			`timeout { fail "up from marker1" }`
376			`}`
377			`}`
378			`-re "$gdb_prompt $" { fail "continue to marker1" }`
379			`timeout { fail "(timeout) continue to marker1" }`
380			`}`
381
382
383			`send_gdb "print *pUC\n"`
384			`gdb_expect {`
385			`-re ".\[0-9\]* = 21 \'.025\'.*$gdb_prompt $" {`
386			`pass "print value of *pUC"`
387			`}`
388			`-re ".$gdb_prompt $" { fail "print value of pUC" }`
389			`timeout { fail "(timeout) print value of *pUC" }`
390			`}`
391
392
393			`send_gdb "ptype pUC\n"`
394			`gdb_expect {`
395			`-re "type = unsigned char \\.$gdb_prompt $" { pass "ptype pUC" }`
396			`-re ".*$gdb_prompt $" { fail "ptype pUC" }`
397			`timeout { fail "(timeout) ptype pUC" }`
398			`}`
399
400			`send_gdb "print *pS\n"`
401			`gdb_expect {`
402			`-re ".\[0-9\]* = -14.*$gdb_prompt $" {`
403			`pass "print value of *pS"`
404			`}`
405			`-re ".$gdb_prompt $" { fail "print value of pS" }`
406			`timeout { fail "(timeout) print value of *pS" }`
407			`}`
408
409
410			`send_gdb "ptype pS\n"`
411			`gdb_expect {`
412			`-re "type = short \\.$gdb_prompt $" { pass "ptype pS" }`
413			`-re "type = short int \\.$gdb_prompt $" { pass "ptype pS" }`
414			`-re ".*$gdb_prompt $" { fail "ptype pS" }`
415			`timeout { fail "(timeout) ptype pS" }`
416			`}`
417
418			`send_gdb "print *pUS\n"`
419			`gdb_expect {`
420			`-re ".\[0-9\]* = 7.*$gdb_prompt $" {`
421			`pass "print value of *pUS"`
422			`}`
423			`-re ".$gdb_prompt $" { fail "print value of pUS" }`
424			`timeout { fail "(timeout) print value of *pUS" }`
425			`}`
426
427
428			`send_gdb "ptype pUS\n"`
429			`gdb_expect {`
430			`-re "type = unsigned short \\.$gdb_prompt $" { pass "ptype pUS" }`
431			`-re "type = short unsigned int \\.$gdb_prompt $" { pass "ptype pUS" }`
432			`-re ".*$gdb_prompt $" { fail "ptype pUS" }`
433			`timeout { fail "(timeout) ptype pUS" }`
434			`}`
435
436			`send_gdb "print *pI\n"`
437			`gdb_expect {`
438			`-re ".\[0-9\]* = 102.*$gdb_prompt $" {`
439			`pass "print value of *pI"`
440			`}`
441			`-re ".$gdb_prompt $" { fail "print value of pI" }`
442			`timeout { fail "(timeout) print value of *pI" }`
443			`}`
444
445
446			`send_gdb "ptype pI\n"`
447			`gdb_expect {`
448			`-re "type = int \\.$gdb_prompt $" { pass "ptype pI" }`
449			`-re ".*$gdb_prompt $" { fail "ptype pI" }`
450			`timeout { fail "(timeout) ptype pI" }`
451			`}`
452
453			`send_gdb "print *pUI\n"`
454			`gdb_expect {`
455			`-re ".\[0-9\]* = 1002.*$gdb_prompt $" {`
456			`pass "print value of *pUI"`
457			`}`
458			`-re ".$gdb_prompt $" { fail "print value of pUI" }`
459			`timeout { fail "(timeout) print value of *pUI" }`
460			`}`
461
462
463			`send_gdb "ptype pUI\n"`
464			`gdb_expect {`
465			`-re "type = unsigned int \\.$gdb_prompt $" { pass "ptype pUI" }`
466			`-re ".*$gdb_prompt $" { fail "ptype pUI" }`
467			`timeout { fail "(timeout) ptype pUI" }`
468			`}`
469
470			`send_gdb "print *pL\n"`
471			`gdb_expect {`
472			`-re ".\[0-9\]* = -234.*$gdb_prompt $" {`
473			`pass "print value of *pL"`
474			`}`
475			`-re ".$gdb_prompt $" { fail "print value of pL" }`
476			`timeout { fail "(timeout) print value of *pL" }`
477			`}`
478
479
480			`send_gdb "ptype pL\n"`
481			`gdb_expect {`
482			`-re "type = long \\.$gdb_prompt $" { pass "ptype pL" }`
483			`-re "type = long int \\.$gdb_prompt $" { pass "ptype pL" }`
484			`-re ".*$gdb_prompt $" { fail "ptype pL" }`
485			`timeout { fail "(timeout) ptype pL" }`
486			`}`
487
488			`send_gdb "print *pUL\n"`
489			`gdb_expect {`
490			`-re ".\[0-9\]* = 234.*$gdb_prompt $" {`
491			`pass "print value of *pUL"`
492			`}`
493			`-re ".$gdb_prompt $" { fail "print value of pUL" }`
494			`timeout { fail "(timeout) print value of *pUL" }`
495			`}`
496
497
498			`send_gdb "ptype pUL\n"`
499			`gdb_expect {`
500			`-re "type = unsigned long \\.$gdb_prompt $" { pass "ptype pUL" }`
501			`-re "type = long unsigned int \\.$gdb_prompt $" { pass "ptype pUL" }`
502			`-re ".*$gdb_prompt $" { fail "ptype pUL" }`
503			`timeout { fail "(timeout) ptype pUL" }`
504			`}`
505
506			`send_gdb "print *pF\n"`
507			`gdb_expect {`
508			`-re ".\[0-9\]* = 1.2\[0-9\]e\\+10.$gdb_prompt $" {`
509			`pass "print value of *pF"`
510			`}`
511			`-re ".$gdb_prompt $" { fail "print value of pF" }`
512			`timeout { fail "(timeout) print value of *pF" }`
513			`}`
514
515
516			`send_gdb "ptype pF\n"`
517			`gdb_expect {`
518			`-re "type = float \\.$gdb_prompt $" { pass "ptype pF" }`
519			`-re ".*$gdb_prompt $" { fail "ptype pF" }`
520			`timeout { fail "(timeout) ptype pF" }`
521			`}`
522
523			`send_gdb "print *pD\n"`
524			`gdb_expect {`
525			`-re ".\[0-9\]* = -1.375e-123.*$gdb_prompt $" {`
526			`pass "print value of *pD"`
527			`}`
528			`-re ".$gdb_prompt $" { fail "print value of pD" }`
529			`timeout { fail "(timeout) print value of *pD" }`
530			`}`
531
532
533			`send_gdb "ptype pD\n"`
534			`gdb_expect {`
535			`-re "type = double \\.$gdb_prompt $" { pass "ptype pD" }`
536			`-re ".*$gdb_prompt $" { fail "ptype pD" }`
537			`timeout { fail "(timeout) ptype pD" }`
538			`}`
539
540			`send_gdb "print ******ppppppC\n"`
541			`gdb_expect {`
542			`-re ".\[0-9\]* = 65 \'A\'.*$gdb_prompt $" {`
543			`pass "print value of ******ppppppC"`
544			`}`
545			`-re ".$gdb_prompt $" { fail "print value of *****ppppppC" }`
546			`timeout { fail "(timeout) print value of ******ppppppC" }`
547			`}`
548
549
550			`send_gdb "ptype pC\n"`
551			`gdb_expect {`
552			`-re "type = char \\.$gdb_prompt $" { pass "ptype pC" }`
553			`-re ".*$gdb_prompt $" { fail "ptype pC" }`
554			`timeout { fail "(timeout) ptype pC" }`
555			`}`
556
557			`send_gdb "ptype ppC\n"`
558			`gdb_expect {`
559			`-re "type = char \\\\.*$gdb_prompt $" { pass "ptype ppC" }`
560			`-re ".*$gdb_prompt $" { fail "ptype ppC" }`
561			`timeout { fail "(timeout) ptype ppC" }`
562			`}`
563
564			`send_gdb "ptype pppC\n"`
565			`gdb_expect {`
566			`-re "type = char \\\\\\.$gdb_prompt $" { pass "ptype pppC" }`
567			`-re ".*$gdb_prompt $" { fail "ptype pppC" }`
568			`timeout { fail "(timeout) ptype pppC" }`
569			`}`
570
571			`send_gdb "ptype ppppC\n"`
572			`gdb_expect {`
573			`-re "type = char \\\\\\\\.*$gdb_prompt $" { pass "ptype ppppC" }`
574			`-re ".*$gdb_prompt $" { fail "ptype ppppC" }`
575			`timeout { fail "(timeout) ptype ppppC" }`
576			`}`
577
578			`send_gdb "ptype pppppC\n"`
579			`gdb_expect {`
580			`-re "type = char \\\\\\\\\\.$gdb_prompt $" { pass "ptype pppppC" }`
581			`-re ".*$gdb_prompt $" { fail "ptype pppppC" }`
582			`timeout { fail "(timeout) ptype pppppC" }`
583			`}`
584
585			`send_gdb "ptype ppppppC\n"`
586			`gdb_expect {`
587			`-re "type = char \\\\\\\\\\\\.*$gdb_prompt $" { pass "ptype ppppppC" }`
588			`-re ".*$gdb_prompt $" { fail "ptype ppppppC" }`
589			`timeout { fail "(timeout) ptype ppppppC" }`
590			`}`
591