bug-ddd
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

ddd 3.3 - some toolchest buttons not working


From: Zdenek Sekera
Subject: ddd 3.3 - some toolchest buttons not working
Date: Tue, 20 Feb 2001 16:50:03 +0100

This is ddd 3.3 running on IRIX 6.5 (SGI) using SGI dbx.

When I startup ddd and open the program, the toolchest
(the little box with buttons that appears by default in the
source window) has 3 buttons grayed out: until, undo, redo.

I can't check anymore but I am pretty sure at least 'until'
worked on some previous ddd version (maybe 3.2.91).

I tried to find out from the log (attached) what could be the
reason for refusing the 'until' button, however, the dialog
in the log seems sensible to me.

What could be the reason? How to fix it?

Thanks and best regards,

---Zdenek
-- 
=========================================================
Zdenek Sekera / address@hidden       Scalable Platforms Group
VNET: 557-4844                      Silicon Graphics SA
Tel : +41-22-710.4844       18, Ave. Louis Casai, 1209 Geneva
Fax : +41-22-710.4860                   Switzerland
GNU DDD 3.2.1 (mips-sgi-irix6.5)
Copyright (C) 1995-1999 Technische Universitaet Braunschweig, Germany.
Copyright (C) 1999-2000 Universitaet Passau, Germany.
Compiled with CC
Requires X11R6, Xt11R6, Motif 1.2.4 (OSF/Motif Version 1.2.4)
Includes DDD core, Manual, App defaults, XPM 3.4.6, Athena Panner
Built 2000-02-17 by Zdenek Sekera <address@hidden>.
$  ./ddd cxxtest
+  /bin/sh -c 'exec dbx '\''cxxtest'\'''
#  Hello, world!
#  Starting DBX...
#  Running DBX (pid 28828, tty /dev/ttyq5)...
#  Current language: c/c++
<- "dbx version 7.3 MR 55458_Apr30_MR Apr 30 1999 13:44:41"
<- "Executable /usr/people/zs/src/ddd-3.2.1/ddd/cxxtest"
<- "(dbx) "
-> "sh stty -echo -onlcr"
<- "(dbx) "
-> "set $page = 1"
<- "(dbx) "
-> "frame"
<- ""
<- "\"frame\" is not a valid command name."
<- "error: frame"
<- "            ^ Apparent syntax error in examine command. expected / ?"
<- "(dbx) "
-> "func"
<- "::main"
<- "(dbx) "
-> "dbxenv run_io"
<- ""
<- "\"dbxenv\" is not a valid command name."
<- "error: dbxenv run_io"
<- "              ^ Apparent syntax error in examine command. expected / ?"
<- "(dbx) "
-> "print -r 4711"
<- ""
<- "Found  4711"
<- "error: print -r 4711"
<- "                ^ Expected end of print statement"
<- "(dbx) "
-> "where -h"
<- "error: where -h"
<- "             ^ syntax error: Unparseable characters after command!"
<- "(dbx) "
-> "display"
<- ""
<- "\"display\" is not a valid command name."
<- "error: display"
<- "              ^ Apparent syntax error in examine command. expected / ?"
<- "(dbx) "
-> "clear"
<- ""
<- "\"clear\" is not a valid command name."
<- "error: clear"
<- "            ^ Apparent syntax error in examine command. expected / ?"
<- "(dbx) "
-> "help handler"
<- "Invalid keyword handler"
<- "(dbx) "
-> "pwd"
<- ""
<- "\"pwd\" is not a valid command name."
<- "error: pwd"
<- "          ^ Apparent syntax error in examine command. expected / ?"
<- "(dbx) "
-> "help setenv"
<- "These are for modifying/seeing the environment variable list in dbx."
<- "They take effect on the givenfile when the victim program is"
<- "run or rerun.     This way one can have a set of environment"
<- "variable in effect in the program being debugged without changing"
<- "the environment in the shell used to start dbx."
<- "These commands have no effect whatever on the shell which was used"
<- "to start dbx."
<- ""
<- "The general approach is like that in csh(1), as is the output format."
<- ""
<- "printenv                       - print environment variable list."
<- "unsetenv   x                   - remove x from the environment"
<- "setenv                         - like printenv"
<- "setenv     x                   - set x to an empty value"
<- "setenv     x y                 - set x to y  (y not a dbx variable)"
<- "setenv     x $y                - set x to be the value of the dbx variable 
$y"
<- "setenv     x \"anything at all\" - set x to be the string. The quotes are "
<- "                                 stripped off."
<- ""
<- "If environment variables variables PAGER or EDITOR are changed the effect"
<- "on the running dbx is undefined (in other words, the new values may"
<- "More (n if no)?"
-> ""
<- "or may not affect the running dbx)."
<- "(dbx) "
-> "help edit"
<- "edit                           - invoke editor on current file"
<- "edit <file>                    - invoke editor on file"
<- "edit <func>                    - invoke editor on file <func> is in"
<- " "
<- " There is a minor limitation on <func> since the command parsing uses"
<- " shell-like parsing.  multi-part names using back-quotes around the"
<- " first part of the name (example:  \'a.b`.foo ) will not work correctly"
<- " to access function foo in module  `a.b` (with a Fortran"
<- " source file a.b.f for example)."
<- ""
<- "(dbx) "
-> "help make"
<- "Invalid keyword make"
<- "(dbx) "
-> "help regs"
<- "Invalid keyword regs"
<- "(dbx) "
-> "print \"DDD\""
<- "DDD "
<- "(dbx) "
-> "help when"
<- "\'when\' is just like `stop\'  except that instead of  stopping when the"
<- "conditions are met, the command_list (semicolon-separated dbx commands )"
<- "is executed.  If one of the commands in the list is `stop\' (with no 
operands)"
<- "then the process will stop when the command_list is executed."
<- ""
<- "when if <exp> {command_list} -"
<- "                          execute command_list on every line executed for 
which"
<- "                          <exp> is true."
<- "when  at <line> [if <exp>] {command_list} -"
<- "                          execute the specified command list when the"
<- "                          conditions are met at line <line>."
<- "when in <proc> [if <exp>] {command_list}  -"
<- "                          execute the specified command list when the"
<- "                          conditions are met in procedure <proc>."
<- "when <var> [at <line>] [if <exp>] {command_list} -"
<- "                          execute the specified command list when the"
<- "                          conditions are met."
<- "when <var> [in procedure] [if <exp>] {command_list} -"
<- "                          execute the specified command list when the"
<- "                          conditions are met."
<- "(dbx) "
-> "delete 4711 4711"
<- ""
<- "Found  4711"
<- "error: delete 4711 4711"
<- "                   ^ Expected end of delete statement"
<- "(dbx) "
-> "help run"
<- "run   arg1 arg2 ...            - begin execution of the program"
<- "rerun arg1 arg2 ...            - begin execution of the program"
<- "rerun                          - restart execution of the program"
<- "                                 with same arguments last used on run or 
rerun"
<- ""
<- "The run and rerun commands use the command interpreter indicated by the"
<- "environment variable SHELL to expand and interpret"
<- "the arguments and redirections.  dbx has built in knowledge of the"
<- "Bourne shell (sh) the C shell (csh) and the Korn shell (ksh).  If a user is"
<- "using a different shell, the run command will not be able to disable 
invocation"
<- "of the shell\'s initialization file (.cshrc, .kshrc, etc.)  This may cause 
the"
<- "run command to fail if the user\'s initialization file spawns off a program 
or a"
<- "sub shell.  If a non standard shell is used, the dbx variable 
$shellparameters"
<- "may be set to a string that will instruct the shell to skip loading of the"
<- "initialization file (for csh one would use \"-f\", for example.)  See the"
<- "description of $shellparameters in the $variables section for more 
information."
<- "To verify exactly how your application is being started by the"
<- "run/rerun command, start dbx with the -d option (there is no way"
<- "to check how your application is started except by adding -d on"
<- "the command line, for example:  \"dbx -d a.out\"."
<- "This will show other data which you should ignore, but run might show, for"
<- "example, with /bin/csh as the SHELL:"
<- "More (n if no)?"
-> ""
<- "(gnome) r"
<- "Now execute givenfile with the following call:"
<- "execvp(\"/bin/csh\", "
<- "        \"/bin/csh,"
<- "        \"-f,"
<- "        \"-c,"
<- "        \"exec ./a.out,"
<- "        (char *)0);"
<- "Process 21473 (a.out) started"
<- ""
<- "If one wishes to debug a program with file-descriptors other than"
<- "the default 0,1,2 open, then care is required, since if $SHELL is"
<- "set to a C-shell, the extra file descriptors will be closed by"
<- "csh(1).  Instead, setenv SHELL /bin/sh (which means one can only use"
<- "sh-style redirections) for example, as sh(1) does not close the"
<- "extra file-descriptors."
<- ""
<- "(dbx) "
-> "help givenfile"
<- "givenfile                      - displays the name of the program being 
dbx\'d"
<- "givenfile <name>               - sets program to debug, like \'dbx name\'."
<- "                                 Kills the current running processes and"
<- "                                 reads in <name>\'s symbol table."
<- "corefile                       - displays the name of the core file. Says"
<- "                                 if the corefile is currently used by dbx"
<- "                                 to display program data."
<- "corefile   <core>              - identifies corefile name, like"
<- "                                 \'dbx name core\'. Makes dbx use that core 
file"
<- "                                 for program data"
<- "(dbx) "
-> "help cont"
<- "cont                           - continue execution and wait until event"
<- "                                 see $promptonfork $mp_program and"
<- "                                 MULTIPLE PROCESS DEBUGGING for the"
<- "                                 behavior of this command with 
fork/exec/sproc"
<- "                                 If the program has a signal handler for"
<- "                                 a signal and the program stopped last on"
<- "                                 that signal, this passes the signal to"
<- "                                 the process on continuing."
<- "cont <signal>                  - continue with signal and wait until event"
<- "                                 You must use the signal number or name"
<- "                                 unless the last stop for this process was"
<- "                                 via the desired signal.  Since it is 
difficult"
<- "                                 to be sure of this, it is simplest to"
<- "                                 use the <signal> clause."
<- "cont at <line>                 - continue until <line> is reached"
<- "                                  (temporary breakpoint)"
<- "cont to <line>                 - same as \'continue at <line>\'"
<- "cont in <proc>                 - continue until <proc> is reached  (see 
above)"
<- "cont <signal> at <line>        - continue with signal until <line> (see 
above)"
<- "cont <signal> to <line>        - same as \'cont <signal> at <line>\'"
<- "cont <signal> in <proc>        - continue with signal until <proc> (see 
above)"
<- "(dbx) "
-> "help examine"
<- "<exp>/<count><format>          - display <count> formatted memory items, in"
<- "                                 increasing address (see ASSEMBLY DEBUGGING"
<- "                                 below)(examine memory)"
<- "<exp>?<count><format>          - display <count> formatted memory items, in"
<- "                                 decreasing address (see ASSEMBLY DEBUGGING"
<- "                                 below)(examine memory)"
<- ""
<- "For additional options and the format letters, try"
<- "        help examineformat"
<- "(dbx) "
-> "help rerun"
<- "run   arg1 arg2 ...            - begin execution of the program"
<- "rerun arg1 arg2 ...            - begin execution of the program"
<- "rerun                          - restart execution of the program"
<- "                                 with same arguments last used on run or 
rerun"
<- ""
<- "The run and rerun commands use the command interpreter indicated by the"
<- "environment variable SHELL to expand and interpret"
<- "the arguments and redirections.  dbx has built in knowledge of the"
<- "Bourne shell (sh) the C shell (csh) and the Korn shell (ksh).  If a user is"
<- "using a different shell, the run command will not be able to disable 
invocation"
<- "of the shell\'s initialization file (.cshrc, .kshrc, etc.)  This may cause 
the"
<- "run command to fail if the user\'s initialization file spawns off a program 
or a"
<- "sub shell.  If a non standard shell is used, the dbx variable 
$shellparameters"
<- "may be set to a string that will instruct the shell to skip loading of the"
<- "initialization file (for csh one would use \"-f\", for example.)  See the"
<- "description of $shellparameters in the $variables section for more 
information."
<- "To verify exactly how your application is being started by the"
<- "run/rerun command, start dbx with the -d option (there is no way"
<- "to check how your application is started except by adding -d on"
<- "the command line, for example:  \"dbx -d a.out\"."
<- "This will show other data which you should ignore, but run might show, for"
<- "example, with /bin/csh as the SHELL:"
<- "More (n if no)?"
-> ""
<- "(gnome) r"
<- "Now execute givenfile with the following call:"
<- "execvp(\"/bin/csh\", "
<- "        \"/bin/csh,"
<- "        \"-f,"
<- "        \"-c,"
<- "        \"exec ./a.out,"
<- "        (char *)0);"
<- "Process 21473 (a.out) started"
<- ""
<- "If one wishes to debug a program with file-descriptors other than"
<- "the default 0,1,2 open, then care is required, since if $SHELL is"
<- "set to a C-shell, the extra file descriptors will be closed by"
<- "csh(1).  Instead, setenv SHELL /bin/sh (which means one can only use"
<- "sh-style redirections) for example, as sh(1) does not close the"
<- "extra file-descriptors."
<- ""
<- "(dbx) "
-> "language"
<- ""
<- "\"language\" is not a valid command name."
<- "error: language"
<- "               ^ Apparent syntax error in examine command. expected / ?"
<- "(dbx) "
-> "sh pwd"
<- "/usr/people/zs/src/ddd-3.2.1/ddd"
<- "(dbx) "
-> "file"
<- "/usr/people/zs/src/ddd-3.2.1/ddd/cxxtest.C"
<- "(dbx) "
-> "list"
<- ">* 508  {"
<- "   509      int i = 42;"
<- "   510      tree_test();"
<- "   511      i++;"
<- "   512      list_test(i);"
<- "   513      i++;"
<- "   514      array_test();"
<- "   515      i++;"
<- "   516      string_test();"
<- "   517      i++;"
<- "(dbx) "
-> "status"
<- "(dbx) "
#  Reading file "/usr/people/zs/src/ddd-3.2.1/ddd/cxxtest.C"...
#  Reading file "/usr/people/zs/src/ddd-3.2.1/ddd/cxxtest.C"...done.
#  File "/usr/people/zs/src/ddd-3.2.1/ddd/cxxtest.C" 524 lines, 14166 characters
#  Setting buttons...
#  Setting buttons...done.
-> "list main"
<- " * 508  {"
<- "   509      int i = 42;"
<- "   510      tree_test();"
<- "   511      i++;"
<- "   512      list_test(i);"
<- ">  513      i++;"
<- "   514      array_test();"
<- "   515      i++;"
<- "   516      string_test();"
<- "   517      i++;"
<- "(dbx) "
-> "list main"
<- " * 508  {"
<- "  "
<- " 509      int i = 42;"
<- "   510      tree_test();"
<- "   511      i++;"
<- "   512      list_test(i);"
<- ">  513      i++;"
<- "   514      array_test();"
<- "   515      i++;"
<- "   516      string_test();"
<- "   517      i++;"
<- "(dbx) "
-> "file"
<- "/usr/people/zs/src/ddd-3.2.1/ddd/cxxtest.C"
<- "(dbx) "
-> "set $assignverify = 1"
<- "(dbx) "
-> "set $ctypenames = 1"
<- "(dbx) "
-> "set $fp_precise = 0"
<- "(dbx) "
-> "set $framereg = 1"
<- "(dbx) "
-> "set $groupforktoo = 0"
<- "(dbx) "
-> "set $hexchars = 0"
<- "(dbx) "
-> "set $hexdoubles = 0"
<- "(dbx) "
-> "set $hexin = 1"
<- "(dbx) "
-> "set $hexints = 1"
<- "(dbx) "
-> "set $hexstrings = 0"
<- "(dbx) "
-> "set $mp_program = 1"
<- "(dbx) "
-> "set $nonstop = 0"
<- "(dbx) "
-> "set $octin = 0"
<- "(dbx) "
-> "set $octints = 0"
<- "(dbx) "
-> "set $page = 1"
<- "(dbx) "
-> "set $pendingtraps = 0"
<- "(dbx) "
-> "set $piaddtohist = 1"
<- "(dbx) "
-> "set $pimode = 0"
<- "(dbx) "
-> "set $print_exception_frame = 0"
<- "(dbx) "
-> "set $printdata = 0"
<- "(dbx) "
-> "set $printwhilestep = 0"
<- "(dbx) "
-> "set $printwide = 0"
<- "(dbx) "
-> "set $regstyle = 1"
<- "(dbx) "
-> "set $repeatmode = 1"
<- "(dbx) "
-> "set $rimode = 0"
<- "(dbx) "
-> "set $searchstatics = 1"
<- "(dbx) "
-> "set $stdc = 0"
<- "(dbx) "
-> "set $stopformat = 1"
<- "(dbx) "
-> "set $addrfmt = \"0x%x\""
<- "(dbx) "
-> "set $addrfmt64 = \"0x%llx\""
<- "(dbx) "
-> "set $casesense = 2"
<- "(dbx) "
-> "set $editor = \"vim\""
<- "(dbx) "
-> "set $lastchild = 0"
<- "(dbx) "
-> "set $lines = 32"
<- "(dbx) "
-> "set $listwindow = 16"
<- "(dbx) "
-> "set $maxstrlen = 296"
<- "(dbx) "
-> "set $pager = \"more\""
<- "(dbx) "
-> "set $pagewidth = 128"
<- "(dbx) "
-> "set $pagewindow = 34"
<- "(dbx) "
-> "set $prompt = \"(dbx) \""
<- "(dbx) "
-> "set $promptonfork = 0"
<- "(dbx) "
-> "set $shellparameters = \"\""
<- "(dbx) "
-> "set $showbreakaddrs = 0"
<- "(dbx) "
-> "set $showfilename = 0"
<- "(dbx) "
-> "set $sourcepathrule = 0"
<- "(dbx) "
-> "set $stacktracelimit = 256"
<- "(dbx) "
-> "set $stepintoall = 0"
<- "(dbx) "
-> "set $tagfile = \"tags\""
<- "(dbx) "
-> "set $whereisdsolimit = 1"
<- "(dbx) "
-> "# reset"
<- ""
<- "Syntax error: unrecognized command #"
<- "(dbx) "
-> "file"
<- "/usr/people/zs/src/ddd-3.2.1/ddd/cxxtest.C"
<- "(dbx) "
-> "list"
<- "   518      plot_test();"
<- "   519      i++;"
<- "   520      type_test();"
<- "   521      --i;"
<- "   522      cin_cout_test();"
<- "   523      return 0;"
<- "   524  }"
<- "(dbx) "
-> "status"
<- "(dbx) "
-> "setenv TERM dumb"
<- "(dbx) "
-> "givenfile "
<- "Current givenfile is cxxtest"
<- "(dbx) "
-> "help detach"
<- "Invalid keyword detach"
<- "(dbx) "
#  Starting DBX...done.
#  Welcome to DDD 3.2.1 "Liftoff" (mips-sgi-irix6.5)
-> "help run"
<- "run   arg1 arg2 ...            - begin execution of the program"
<- "rerun arg1 arg2 ...            - begin execution of the program"
<- "rerun                          - restart execution of the program"
<- "                                 with same arguments last used on run or 
rerun"
<- ""
<- "The run and rerun commands use the command interpreter indicated by the"
<- "environment variable SHELL to expand and interpret"
<- "the arguments and redirections.  dbx has built in knowledge of the"
<- "Bourne shell (sh) the C shell (csh) and the Korn shell (ksh).  If a user is"
<- "using a different shell, the run command will not be able to disable 
invocation"
<- "of the shell\'s initialization file (.cshrc, .kshrc, etc.)  This may cause 
the"
<- "run command to fail if the user\'s initialization file spawns off a program 
or a"
<- "sub shell.  If a non standard shell is used, the dbx variable 
$shellparameters"
<- "may be set to a string that will instruct the shell to skip loading of the"
<- "initialization file (for csh one would use \"-f\", for example.)  See the"
<- "description of $shellparameters in the $variables section for more 
information."
<- "To verify exactly how your application is being started by the"
<- "run/rerun command, start dbx with the -d option (there is no way"
<- "to check how your application is started except by adding -d on"
<- "the command line, for example:  \"dbx -d a.out\"."
<- "This will show other data which you should ignore, but run might show, for"
<- "example, with /bin/csh as the SHELL:"
<- "(gnome) r"
<- "Now execute givenfile with the following call:"
<- "execvp(\"/bin/csh\", "
<- "        \"/bin/csh,"
<- "        \"-f,"
<- "        \"-c,"
<- "        \"exec ./a.out,"
<- "        (char *)0);"
<- "Process 21473 (a.out) started"
<- ""
<- "If one wishes to debug a program with file-descriptors other than"
<- "the default 0,1,2 open, then care is required, since if $SHELL is"
<- "set to a C-shell, the extra file descriptors will be closed by"
<- "csh(1).  Instead, setenv SHELL /bin/sh (which means one can only use"
<- "sh-style redirections) for example, as sh(1) does not close the"
<- "extra file-descriptors."
<- ""
<- "(dbx) "
-> "help step"
<- "step                           - single step 1 time."
<- "step <int>                     - single step <int> times."
<- "                                 \'step\' steps over procedures compiled 
without"
<- "                                 symbols by default."
<- "                                 Breakpoints in procedures stepped over"
<- "                                 are honored."
<- "                                 Functions coded entirely on one line cause"
<- "                                 step to act like stepi, since the actual"
<- "                                 code is all assigned one source line."
<- "                                 Outstanding signals are ignored."
<- ""
<- "  A step into a dso will fail (will result effectively in a \'next\')"
<- "  if rld(1) has not yet lazily evaluated the address of the function."
<- "  Before rerunning the application, setenv LD_BIND_NOW 1"
<- "  will force rld to do immediate address resolution and will avoid"
<- "  the problem. "
<- ""
<- "(dbx) "
-> "help stepi"
<- "stepi                          - single step 1 assembly instruction"
<- "stepi <exp>                    - single step <exp> assembly instructions."
<- "                                 See  $printwhilestep"
<- ""
<- "   A stepi into a dso will get into strange territory"
<- "   (rld(1) specifically)  and stack traces will not work"
<- "   well if rld(1) has not yet lazily evaluated the address"
<- "   of the function.  Before rerunning the application,"
<- "   setenv LD_BIND_NOW 1 will force rld to do immediate"
<- "   address resolution and will avoid the problem."
<- ""
<- "nexti                          - like stepi, but step over subroutine calls"
<- "nexti <exp>                    - like stepi <exp>, but step over"
<- "                                 subroutine calls"
<- "$printwhilestep - if != 0, acts as if \'step[i] n\' was \'step[i]\' n times"
<- "(dbx) "
-> "help next"
<- "next                           - single step 1 time.      steps over 
procedures"
<- "next <int>                     - single step <int> times. steps over 
procedures"
<- "                                 \'next\' honors breakpoints in procedures"
<- "                                 stepped over."
<- "                                 A consequence of this is that"
<- "                                 a ``stop if\'\' condition which is true 
will"
<- "                                 continue to be true -- making dbx stop 
after"
<- "                                 every statement in procedures one wanted 
to"
<- "                                 step over. Delete the ``stop if\'\'"
<- "                                 which has already become true to avoid the"
<- "                                 stops."
<- "                                 Outstanding signals are ignored."
<- ""
<- "(dbx) "
-> "help nexti"
<- "stepi                          - single step 1 assembly instruction"
<- "stepi <exp>                    - single step <exp> assembly instructions."
<- "                                 See  $printwhilestep"
<- ""
<- "   A stepi into a dso will get into strange territory"
<- "   (rld(1) specifically)  and stack traces will not work"
<- "   well if rld(1) has not yet lazily evaluated the address"
<- "   of the function.  Before rerunning the application,"
<- "   setenv LD_BIND_NOW 1 will force rld to do immediate"
<- "   address resolution and will avoid the problem."
<- ""
<- "nexti                          - like stepi, but step over subroutine calls"
<- "nexti <exp>                    - like stepi <exp>, but step over"
<- "                                 subroutine calls"
<- "$printwhilestep - if != 0, acts as if \'step[i] n\' was \'step[i]\' n times"
<- "(dbx) "
-> "help until"
<- "Invalid keyword until"
<- "(dbx) "
-> "help cont"
<- "cont                           - continue execution and wait until event"
<- "                                 see $promptonfork $mp_program and"
<- "                                 MULTIPLE PROCESS DEBUGGING for the"
<- "                                 behavior of this command with 
fork/exec/sproc"
<- "                                 If the program has a signal handler for"
<- "                                 a signal and the program stopped last on"
<- "                                 that signal, this passes the signal to"
<- "                                 the process on continuing."
<- "cont <signal>                  - continue with signal and wait until event"
<- "                                 You must use the signal number or name"
<- "                                 unless the last stop for this process was"
<- "                                 via the desired signal.  Since it is 
difficult"
<- "                                 to be sure of this, it is simplest to"
<- "                                 use the <signal> clause."
<- "cont at <line>                 - continue until <line> is reached"
<- "                                  (temporary breakpoint)"
<- "cont to <line>                 - same as \'continue at <line>\'"
<- "cont in <proc>                 - continue until <proc> is reached  (see 
above)"
<- "cont <signal> at <line>        - continue with signal until <line> (see 
above)"
<- "cont <signal> to <line>        - same as \'cont <signal> at <line>\'"
<- "cont <signal> in <proc>        - continue with signal until <proc> (see 
above)"
<- "(dbx) "
-> "help signal"
<- "Invalid keyword signal"
<- "(dbx) "
-> "help kill"
<- "kill                           - kill active process"
<- "kill <pid> ...                 - kill process (list) specified"
<- "(dbx) "
-> "help up"
<- "up                             - move up one activation level in the stack"
<- "up <exp>                       - move up <exp> activation levels in the 
stack"
<- "down                           - move down one activation level in stack"
<- "down <exp>                     - move down <exp> activation levels in stack"
<- "(dbx) "
-> "help down"
<- "up                             - move up one activation level in the stack"
<- "up <exp>                       - move up <exp> activation levels in the 
stack"
<- "down                           - move down one activation level in stack"
<- "down <exp>                     - move down <exp> activation levels in stack"
<- "(dbx) "
-> "givenfile "
<- "Current givenfile is cxxtest"
<- "(dbx) "
#  Saving options in "/usr/people/zs/.ddd/init"...
#  Saving options in "/usr/people/zs/.ddd/init"...done.
-> "print plot_test"
<- "0x10002fe0"
<- " "
<- ""
<- "(dbx) "
-> "print i"
<- "Appropriate symbol not found for: i"
<- "<symbol not found>"
<- " "
<- ""
<- "(dbx) "
-> "file cxxtest.C"
<- "(dbx) "
-> "status"
<- "(dbx) "
-> "stop at 516"
<- "no executable code found at line \"cxxtest.C\":1302"
<- "(dbx) "
-> "status"
<- "(dbx) "
-> "print string_test"
<- "0x100028b0"
<- " "
<- ""
<- "(dbx) "
-> "quit"
#  Running DBX (pid 28828, tty /dev/ttyq5)...Exit 0.
#  Saving history in "/usr/people/zs/.ddd/history"...
#  Saving history in "/usr/people/zs/.ddd/history"...done.
#  Thanks for using DDD 3.2.1!

reply via email to

[Prev in Thread] Current Thread [Next in Thread]