home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / gnu / gdb-4.9 / gdb / testsuite / lib / gdb.exp next >
Encoding:
Text File  |  1993-05-12  |  6.6 KB  |  257 lines
  1. # Copyright (C) 1992 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., 675 Mass Ave, Cambridge, MA 02139, 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 Fred Fish. (fnf@cygnus.com)
  21.  
  22. # Generic gdb subroutines that should work for any target.  If these
  23. # need to be modified for any target, it can be done with a variable
  24. # or by passing arguments.
  25.  
  26. #
  27. # gdb_unload -- unload a file if one is loaded
  28. #
  29.  
  30. proc gdb_unload {} {
  31.     global verbose
  32.     global GDB
  33.     global prompt
  34.     send "file\n"
  35.     expect {
  36.     -re "No exec file now\.\r" { continue -expect }
  37.     -re "No symbol file now\.\r" { continue -expect }
  38.     -re "A program is being debugged already..*Kill it\? \(y or n\) $"\
  39.         { send "y\n"
  40.         if $verbose>1 then {
  41.             send_user "\t\tKilling previous program being debugged\n"
  42.         }
  43.         continue -expect
  44.     }
  45.     -re "Discard symbol table from .*\? \(y or n\) $" {
  46.         send "y\n"
  47.         continue -expect
  48.     }
  49.     -re "$prompt $" {}
  50.     timeout {
  51.         error "couldn't unload file in $GDB (timed out)."
  52.         return -1
  53.     }
  54.     }
  55. }
  56.  
  57. # Many of the tests depend on setting breakpoints at various places and
  58. # running until that breakpoint is reached.  At times, we want to start
  59. # with a clean-slate with respect to breakpoints, so this utility proc 
  60. # lets us do this without duplicating this code everywhere.
  61. #
  62.  
  63. proc delete_breakpoints {} {
  64.     global prompt
  65.  
  66.     send "delete breakpoints\n"
  67.     expect {
  68.     -re "Delete all breakpoints\? \(y or n\) $" {
  69.         send "y\n"
  70.         continue -expect
  71.     }
  72.     -re "y\r\n$prompt $" {}
  73.     -re ".*$prompt $" { fail "Delete all breakpoints" ; return }
  74.     timeout { fail "Delete all breakpoints (timeout)" ; return }
  75.     }
  76.     send "info breakpoints\n"
  77.     expect {
  78.     -re "No breakpoints or watchpoints..*$prompt $" {}
  79.     -re ".*$prompt $" { fail "breakpoints not deleted" ; return }
  80.     timeout { fail "info breakpoints (timeout)" ; return }
  81.     }
  82. }
  83.  
  84.  
  85. #
  86. # Set breakpoint at function and run gdb until it breaks there.
  87. # Since this is the only breakpoint that will be set, if it stops
  88. # at a breakpoint, we will assume it is the one we want.  We can't
  89. # just compare to "function" because it might be a fully qualified,
  90. # single quoted C++ function specifier.
  91. #
  92.  
  93. proc runto { function } {
  94.     global prompt
  95.     global decimal
  96.  
  97.     send "delete\n"
  98.     expect {
  99.     -re "Delete all breakpoints\? \(y or n\) $" {
  100.         send "y\n"
  101.         expect {
  102.         -re "$prompt $" {}
  103.         timeout { fail "deleting breakpoints (timeout)" ; return 0 }
  104.         }
  105.     }
  106.     -re ".*$prompt $" {}
  107.     timeout { fail "deleting breakpoints (timeout)" ; return 0 }
  108.     }
  109.  
  110.     send "break $function\n"
  111.     expect {
  112.     -re "Break.* at .*: file .*, line $decimal.\r\n$prompt $" {}
  113.     -re "$prompt $" { fail "setting breakpoint at $function" ; return 0 }
  114.     timeout { fail "setting breakpoint at $function (timeout)" ; return 0 }
  115.     }
  116.  
  117.     send "run\n"
  118.     expect {
  119.     -re "The program .* has been started already.* \(y or n\) $" {
  120.         send "y\n"
  121.         continue -expect
  122.     }
  123.     -re "Starting.*Break.* at .*:$decimal.*$prompt $" { return 1 }
  124.     -re "$prompt $" { fail "running to $function" ; return 0 }
  125.     timeout { fail "running to $function (timeout)" ; return 0 }
  126.     }
  127. }
  128.  
  129. #
  130. # gdb_test -- send a command to gdb and test the result.
  131. #             Takes three parameters.
  132. #             Parameters:
  133. #                First one is the command to execute,
  134. #                Second one is the pattern to match for a PASS,
  135. #                Third one is an optional message to be printed. If this
  136. #                  a null string "", then the pass/fail messages are not printed.
  137. #             Returns:
  138. #                1 if the test failed,
  139. #                0 if the test passes,
  140. #               -1 if there was an internal error.
  141. #
  142. proc gdb_test { args } {
  143.     global verbose
  144.     global prompt
  145.     global GDB
  146.     global spawn_id
  147.  
  148.     if [llength $args]==3 then {
  149.     set message [lindex $args 2]
  150.     } else {
  151.     set message [lindex $args 0]
  152.     }
  153.     set command [lindex $args 0]
  154.     set pattern [lindex $args 1]
  155.  
  156.     if $verbose>2 then {
  157.     send_user "Sending \"$command\" to gdb\n"
  158.     send_user "Looking to match \"$pattern\"\n"
  159.     send_user "Message is \"$message\"\n"
  160.     }
  161.  
  162.     set result -1
  163.     set errmess ""
  164.     # trap the send so any problems don't crash things
  165.     catch "send \"$command\n\"" errmess
  166.     if [string match "write\(spawn_id=\[0-9\]+\):" $errmess] then {
  167.     error "sent \"$command\" got expect error \"$errmess\""
  168.     catch "close"
  169.     gdb_start
  170.     return -1
  171.     }
  172.  
  173.     expect {
  174.     -re ".*Ending remote debugging.*$prompt$" {
  175.         if ![isnative] then {
  176.         warning "Can`t communicate to remote target."
  177.         }
  178.         gdb_exit
  179.         gdb_start
  180.         set result -1
  181.     }
  182.     -re "$pattern.*$prompt $" {
  183.         if ![string match "" $message] then {
  184.         pass "$message"
  185.         }
  186.         set result 0
  187.     }
  188.     -re "Undefined command:.*$prompt" {
  189.         error "Undefined command \"$command\"."
  190.         set result 1
  191.     }
  192.     -re "Ambiguous command.*$prompt $" {
  193.         error "\"$command\" is not a unique command name."
  194.         set result 1
  195.     }
  196.     -re ".*$prompt $" {
  197.         if ![string match "" $message] then {
  198.         fail "$message"
  199.         }
  200.         set result 1
  201.     }
  202.     "<return>" {
  203.         send "\n"
  204.         error "Window too small."
  205.     }
  206.     -re "\(y or n\) " {
  207.         send "n\n"
  208.         error "Got interactive prompt."
  209.     }
  210.     eof {
  211.         error "Process no longer exists"
  212.         return -1
  213.     }
  214.     buffer_full {
  215.         error "internal buffer is full."
  216.     }
  217.     timeout    {
  218.         fail "(timeout) $message"
  219.         set result 1
  220.     }
  221.     }
  222.     return $result
  223. }
  224.  
  225. proc gdb_reinitialize_dir { subdir } {
  226.     global prompt
  227.     global verbose
  228.  
  229.     send "dir\n"
  230.     expect {
  231.     -re "Reinitialize source path to empty.*" {
  232.         send "y\n"
  233.         expect {
  234.         -re "Source directories searched.*$prompt $" {
  235.             send "dir $subdir\n"
  236.             expect {
  237.             -re "Source directories searched.*$prompt $" {
  238.                 if $verbose>1 then {
  239.                 send_user "Dir set to $subdir\n"
  240.                 }
  241.             }
  242.             -re ".*$prompt $" {
  243.                 error "Dir \"$subdir\" failed."
  244.             }
  245.             }
  246.         }
  247.         -re ".*$prompt $" {
  248.             error "Dir \"$subdir\" failed."
  249.         }
  250.         }
  251.     }
  252.     -re ".*$prompt $" {
  253.         error "Dir \"$subdir\" failed."
  254.     }
  255.     }
  256. }
  257.