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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [testsuite/] [gdb.base/] [pointers.exp] - Blame information for rev 321

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


# Copyright 1998, 1999, 2000, 2007, 2008 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 3 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, see .
 
# 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 nowarnings}] != "" } {
     untested pointers.exp
     return -1
    }
 
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 $" {
        pass "continue to marker1"
        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 "continue to marker1 (timeout)"
    }
}
 
 
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 openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [testsuite/] [gdb.base/] [pointers.exp] - Blame information for rev 321

Line No.	Rev	Author	Line
1	24	jeremybenn	`# Copyright 1998, 1999, 2000, 2007, 2008 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 3 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, see .`
15
16			`# Please email any bugs, comments, and/or additions to this file to:`
17			`# bug-gdb@prep.ai.mit.edu`
18
19			`# This file was written by Elena Zannoni (ezannoni@cygnus.com)`
20
21			`# This file is part of the gdb testsuite`
22			`#`
23			`# tests for pointer arithmetic and pointer dereferencing`
24			`# with integer type variables and pointers to integers`
25			`#`
26
27			`if $tracelevel then {`
28			`strace $tracelevel`
29			`}`
30
31			`#`
32			`# test running programs`
33			`#`
34			`set prms_id 0`
35			`set bug_id 0`
36
37			`set testfile "pointers"`
38			`set srcfile ${testfile}.c`
39			`set binfile ${objdir}/${subdir}/${testfile}`
40
41			`if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug nowarnings}] != "" } {`
42			`untested pointers.exp`
43			`return -1`
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			`pass "continue to marker1"`
373			`send_gdb "up\n"`
374			`gdb_expect {`
375			`-re ".more_code.$gdb_prompt $" {`
376			`pass "up from marker1"`
377			`}`
378			`-re ".*$gdb_prompt $" {`
379			`fail "up from marker1"`
380			`}`
381			`timeout { fail "up from marker1 (timeout)" }`
382			`}`
383			`}`
384			`-re "$gdb_prompt $" {`
385			`fail "continue to marker1"`
386			`}`
387			`timeout {`
388			`fail "continue to marker1 (timeout)"`
389			`}`
390			`}`
391
392
393			`send_gdb "print *pUC\n"`
394			`gdb_expect {`
395			`-re ".\[0-9\]* = 21 \'.025\'.*$gdb_prompt $" {`
396			`pass "print value of *pUC"`
397			`}`
398			`-re ".$gdb_prompt $" { fail "print value of pUC" }`
399			`timeout { fail "(timeout) print value of *pUC" }`
400			`}`
401
402
403			`send_gdb "ptype pUC\n"`
404			`gdb_expect {`
405			`-re "type = unsigned char \\.$gdb_prompt $" { pass "ptype pUC" }`
406			`-re ".*$gdb_prompt $" { fail "ptype pUC" }`
407			`timeout { fail "(timeout) ptype pUC" }`
408			`}`
409
410			`send_gdb "print *pS\n"`
411			`gdb_expect {`
412			`-re ".\[0-9\]* = -14.*$gdb_prompt $" {`
413			`pass "print value of *pS"`
414			`}`
415			`-re ".$gdb_prompt $" { fail "print value of pS" }`
416			`timeout { fail "(timeout) print value of *pS" }`
417			`}`
418
419
420			`send_gdb "ptype pS\n"`
421			`gdb_expect {`
422			`-re "type = short \\.$gdb_prompt $" { pass "ptype pS" }`
423			`-re "type = short int \\.$gdb_prompt $" { pass "ptype pS" }`
424			`-re ".*$gdb_prompt $" { fail "ptype pS" }`
425			`timeout { fail "(timeout) ptype pS" }`
426			`}`
427
428			`send_gdb "print *pUS\n"`
429			`gdb_expect {`
430			`-re ".\[0-9\]* = 7.*$gdb_prompt $" {`
431			`pass "print value of *pUS"`
432			`}`
433			`-re ".$gdb_prompt $" { fail "print value of pUS" }`
434			`timeout { fail "(timeout) print value of *pUS" }`
435			`}`
436
437
438			`send_gdb "ptype pUS\n"`
439			`gdb_expect {`
440			`-re "type = unsigned short \\.$gdb_prompt $" { pass "ptype pUS" }`
441			`-re "type = short unsigned int \\.$gdb_prompt $" { pass "ptype pUS" }`
442			`-re ".*$gdb_prompt $" { fail "ptype pUS" }`
443			`timeout { fail "(timeout) ptype pUS" }`
444			`}`
445
446			`send_gdb "print *pI\n"`
447			`gdb_expect {`
448			`-re ".\[0-9\]* = 102.*$gdb_prompt $" {`
449			`pass "print value of *pI"`
450			`}`
451			`-re ".$gdb_prompt $" { fail "print value of pI" }`
452			`timeout { fail "(timeout) print value of *pI" }`
453			`}`
454
455
456			`send_gdb "ptype pI\n"`
457			`gdb_expect {`
458			`-re "type = int \\.$gdb_prompt $" { pass "ptype pI" }`
459			`-re ".*$gdb_prompt $" { fail "ptype pI" }`
460			`timeout { fail "(timeout) ptype pI" }`
461			`}`
462
463			`send_gdb "print *pUI\n"`
464			`gdb_expect {`
465			`-re ".\[0-9\]* = 1002.*$gdb_prompt $" {`
466			`pass "print value of *pUI"`
467			`}`
468			`-re ".$gdb_prompt $" { fail "print value of pUI" }`
469			`timeout { fail "(timeout) print value of *pUI" }`
470			`}`
471
472
473			`send_gdb "ptype pUI\n"`
474			`gdb_expect {`
475			`-re "type = unsigned int \\.$gdb_prompt $" { pass "ptype pUI" }`
476			`-re ".*$gdb_prompt $" { fail "ptype pUI" }`
477			`timeout { fail "(timeout) ptype pUI" }`
478			`}`
479
480			`send_gdb "print *pL\n"`
481			`gdb_expect {`
482			`-re ".\[0-9\]* = -234.*$gdb_prompt $" {`
483			`pass "print value of *pL"`
484			`}`
485			`-re ".$gdb_prompt $" { fail "print value of pL" }`
486			`timeout { fail "(timeout) print value of *pL" }`
487			`}`
488
489
490			`send_gdb "ptype pL\n"`
491			`gdb_expect {`
492			`-re "type = long \\.$gdb_prompt $" { pass "ptype pL" }`
493			`-re "type = long int \\.$gdb_prompt $" { pass "ptype pL" }`
494			`-re ".*$gdb_prompt $" { fail "ptype pL" }`
495			`timeout { fail "(timeout) ptype pL" }`
496			`}`
497
498			`send_gdb "print *pUL\n"`
499			`gdb_expect {`
500			`-re ".\[0-9\]* = 234.*$gdb_prompt $" {`
501			`pass "print value of *pUL"`
502			`}`
503			`-re ".$gdb_prompt $" { fail "print value of pUL" }`
504			`timeout { fail "(timeout) print value of *pUL" }`
505			`}`
506
507
508			`send_gdb "ptype pUL\n"`
509			`gdb_expect {`
510			`-re "type = unsigned long \\.$gdb_prompt $" { pass "ptype pUL" }`
511			`-re "type = long unsigned int \\.$gdb_prompt $" { pass "ptype pUL" }`
512			`-re ".*$gdb_prompt $" { fail "ptype pUL" }`
513			`timeout { fail "(timeout) ptype pUL" }`
514			`}`
515
516			`send_gdb "print *pF\n"`
517			`gdb_expect {`
518			`-re ".\[0-9\]* = 1.2\[0-9\]e\\+10.$gdb_prompt $" {`
519			`pass "print value of *pF"`
520			`}`
521			`-re ".$gdb_prompt $" { fail "print value of pF" }`
522			`timeout { fail "(timeout) print value of *pF" }`
523			`}`
524
525
526			`send_gdb "ptype pF\n"`
527			`gdb_expect {`
528			`-re "type = float \\.$gdb_prompt $" { pass "ptype pF" }`
529			`-re ".*$gdb_prompt $" { fail "ptype pF" }`
530			`timeout { fail "(timeout) ptype pF" }`
531			`}`
532
533			`send_gdb "print *pD\n"`
534			`gdb_expect {`
535			`-re ".\[0-9\]* = -1.2\[0-9\]e\\-37.$gdb_prompt $" {`
536			`pass "print value of *pD"`
537			`}`
538			`-re ".$gdb_prompt $" { fail "print value of pD" }`
539			`timeout { fail "(timeout) print value of *pD" }`
540			`}`
541
542
543			`send_gdb "ptype pD\n"`
544			`gdb_expect {`
545			`-re "type = double \\.$gdb_prompt $" { pass "ptype pD" }`
546			`-re ".*$gdb_prompt $" { fail "ptype pD" }`
547			`timeout { fail "(timeout) ptype pD" }`
548			`}`
549
550			`send_gdb "print ******ppppppC\n"`
551			`gdb_expect {`
552			`-re ".\[0-9\]* = 65 \'A\'.*$gdb_prompt $" {`
553			`pass "print value of ******ppppppC"`
554			`}`
555			`-re ".$gdb_prompt $" { fail "print value of *****ppppppC" }`
556			`timeout { fail "(timeout) print value of ******ppppppC" }`
557			`}`
558
559
560			`send_gdb "ptype pC\n"`
561			`gdb_expect {`
562			`-re "type = char \\.$gdb_prompt $" { pass "ptype pC" }`
563			`-re ".*$gdb_prompt $" { fail "ptype pC" }`
564			`timeout { fail "(timeout) ptype pC" }`
565			`}`
566
567			`send_gdb "ptype ppC\n"`
568			`gdb_expect {`
569			`-re "type = char \\\\.*$gdb_prompt $" { pass "ptype ppC" }`
570			`-re ".*$gdb_prompt $" { fail "ptype ppC" }`
571			`timeout { fail "(timeout) ptype ppC" }`
572			`}`
573
574			`send_gdb "ptype pppC\n"`
575			`gdb_expect {`
576			`-re "type = char \\\\\\.$gdb_prompt $" { pass "ptype pppC" }`
577			`-re ".*$gdb_prompt $" { fail "ptype pppC" }`
578			`timeout { fail "(timeout) ptype pppC" }`
579			`}`
580
581			`send_gdb "ptype ppppC\n"`
582			`gdb_expect {`
583			`-re "type = char \\\\\\\\.*$gdb_prompt $" { pass "ptype ppppC" }`
584			`-re ".*$gdb_prompt $" { fail "ptype ppppC" }`
585			`timeout { fail "(timeout) ptype ppppC" }`
586			`}`
587
588			`send_gdb "ptype pppppC\n"`
589			`gdb_expect {`
590			`-re "type = char \\\\\\\\\\.$gdb_prompt $" { pass "ptype pppppC" }`
591			`-re ".*$gdb_prompt $" { fail "ptype pppppC" }`
592			`timeout { fail "(timeout) ptype pppppC" }`
593			`}`
594
595			`send_gdb "ptype ppppppC\n"`
596			`gdb_expect {`
597			`-re "type = char \\\\\\\\\\\\.*$gdb_prompt $" { pass "ptype ppppppC" }`
598			`-re ".*$gdb_prompt $" { fail "ptype ppppppC" }`
599			`timeout { fail "(timeout) ptype ppppppC" }`
600			`}`
601