bug-ddd
[Top][All Lists]
Advanced

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

[Add]: ddd 3.3 - source sometimes not appearing]


From: Zdenek Sekera
Subject: [Add]: ddd 3.3 - source sometimes not appearing]
Date: Tue, 20 Feb 2001 18:53:14 +0100

Sorry, forgot to attach the log file to my previous bug report.
It's attached now.

I have tested it more: the source always appears after restart,
but never whe I start ddd.

By the way (and I didn't notice it before) the log file also
shows my problem with the

#  VSL: ../vsllib/builtin.vsl:110: 'font(box, font)' already defined
#  VSL: ../vsllib/fonts.vsl:38: font(box, font): (this is the previous
definition)

that I've reported some time ago...

---Zdenek

-------- Original Message --------
Subject: ddd 3.3 - source sometimes not appearing
Date: Tue, 20 Feb 2001 18:20:20 +0100
From: Zdenek Sekera <address@hidden>
Organization: Silicon Graphics
To: bug-ddd <address@hidden>

ddd 3.3 on IRIX with dbx, SHELL=/sbin/ksh

I have observed this:

Sometimes (probably 1 of 2) tries when I bring ddd up, open the
program, the source doesn't appear in the source window.
I just discovered when I do 'restart' at that time, ddd restarts
and the source appears. I can't figure out a pattern to that
source not-appearing after the 'open the program', though I have
a feeling it's somehow related to playing with preferences. It
often happens after I have changed and saved the preferences
(I am playing with dbx preferences) but I am not really sure
if that's related.

---Zdenek

_______________________________________________
Bug-ddd mailing list
address@hidden
http://mail.gnu.org/mailman/listinfo/bug-ddd
GNU DDD 3.3 (mips-sgi-irix6.5)
Copyright (C) 1995-1999 Technische Universit├Ąt Braunschweig, Germany.
Copyright (C) 1999-2001 Universit├Ąt Passau, Germany.

Compiled with MIPSPro CC 730
Requires X11R6, Xt11R6, Motif 1.2.4 (OSF/Motif Version 1.2.4)
Includes XPM 3.4.6, Athena Panner, VSL library, Manual, DDD core
Built 2001-02-05 by Zdenek Sekera <address@hidden>.
$  ddd
+  /bin/sh -c 'exec dbx'
#  Hello, world!
#  Opening session ".ddd"...
#  Running DBX (pid 153297, tty /dev/ttyq10)...
#  Current language: C/C++
#  Givenfile: waiting until DBX gets ready
#  VSL: ../vsllib/builtin.vsl:110: 'font(box, font)' already defined
#  VSL: ../vsllib/fonts.vsl:38: font(box, font): (this is the previous 
definition)
<- "dbx version 7.3 MR 55458_Apr30_MR Apr 30 1999 13:44:41\n"
<- "(dbx) "
-> "sh stty -echo -onlcr\n"
<- "(dbx) "
-> "set $page = 1\n"
<- "(dbx) "
-> "frame\n"
<- "\n"
<- "\"frame\" is not a valid command name.\n"
<- "error: frame\n"
<- "       "
<- "     ^ Apparent syntax error in examine command. expected / ?\n"
<- "(dbx) "
-> "func\n"
<- "\n"
<- "no active process\n"
<- "(dbx) "
-> "dbxenv run_io\n"
<- "\n"
<- "\"dbxenv\" is not a valid command name.\n"
<- "error: dbxenv run_io\n"
<- "              ^ Apparent syntax error in examine command. expected / ?\n"
<- "(dbx) "
-> "print -r 4711\n"
<- "\n"
<- "Found  4711\n"
<- "error: print -r 4711\n"
<- "                ^ Expected end of print statement\n"
<- "(dbx) "
-> "where -h\n"
<- "error: where -h\n"
<- "             ^ syntax error: Unparseable characters after command!\n"
<- "(dbx) "
-> "display\n"
<- "\n"
<- "\"display\" is not a valid command name.\n"
<- "error: display\n"
<- "              ^ Apparent syntax error in examine command. expected / ?\n"
<- "(dbx) "
-> "clear\n"
<- "\n"
<- "\"clear\" is not a valid command name.\n"
<- "error: clear\n"
<- "            ^ Apparent syntax error in examine command. expected / ?\n"
<- "(dbx) "
-> "help handler\n"
<- "Invalid keyword handler\n"
<- "(dbx) "
-> "help attach\n"
<- "Invalid keyword attach\n"
<- "(dbx) "
-> "help addproc\n"
<- "Invalid keyword addproc\n"
<- "(dbx) "
-> "pwd\n"
<- "\n"
<- "\"pwd\" is not a valid command name.\n"
<- "error: pwd\n"
<- "          ^ Apparent syntax error in examine command. expected / ?\n"
<- "(dbx) "
-> "help setenv\n"
<- "These are for modifying/seeing the environment variable list in dbx.\n"
<- "They take effect on the givenfile when the victim program is\n"
<- "run or rerun.     This way one can have a set of environment\n"
<- "variable in effect in the program being debugged without changing\n"
<- "the environment in the shell used to start dbx.\n"
<- "These commands have no effect whatever on the shell which was used\n"
<- "to start dbx.\n"
<- "\n"
<- "The general approach is like that in csh(1), as is the output format.\n"
<- "\n"
<- "printenv                       - print environment variable list.\n"
<- "unsetenv   x                   - remove x from the environment\n"
<- "setenv                         - like printenv\n"
<- "setenv     x                   - set x to an empty value\n"
<- "setenv     x y                 - set x to y  (y not a dbx variable)\n"
<- "setenv     x $y                - set x to be the value of the dbx variable 
$y\n"
<- "setenv     x \"anything at all\" - set x to be the string. The quotes are 
\n"
<- "                                 stripped off.\n"
<- "\n"
<- "If environment variables variables PAGER or EDITOR are changed the effect\n"
<- "on the running dbx is undefined (in other words, the new values may\n"
<- "or may not affect the running dbx).\n"
<- "More (n if no)?"
-> "\n"
<- "(dbx) "
-> "help edit\n"
<- "edit                           - invoke editor on current file\n"
<- "edit <file>                    - invoke editor on file\n"
<- "edit <func>                    - invoke editor on file <func> is in\n"
<- " \n"
<- " There is a minor limitation on <func> since the command parsing uses\n"
<- " shell-like parsing.  multi-part names using back-quotes around the\n"
<- " first part of the name (example:  \'a.b`.foo ) will not work correctly\n"
<- " to access function foo in module  `a.b` (with a Fortran\n"
<- " source file a.b.f for example).\n"
<- "\n"
<- "(dbx) "
-> "help make\n"
<- "Invalid keyword make\n"
<- "(dbx) "
-> "help regs\n"
<- "Invalid keyword regs\n"
<- "(dbx) "
-> "print \"DDD\"\n"
<- "DDD \n"
<- "(dbx) "
-> "help when\n"
<- "\'when\' is just like `stop\'  except that instead of  stopping when the\n"
<- "conditions are met, the command_list (semicolon-separated dbx commands )\n"
<- "is executed.  If one of the commands in the list is `stop\' (with no 
operands)\n"
<- "then the process will stop when the command_list is executed.\n"
<- "\n"
<- "when if <exp> {command_list} -\n"
<- "                          execute command_list on every line executed for 
which\n"
<- "                          <exp> is true.\n"
<- "when  at <line> [if <exp>] {command_list} -\n"
<- "                          execute the specified command list when the\n"
<- "                          conditions are met at line <line>.\n"
<- "when in <proc> [if <exp>] {command_list}  -\n"
<- "                          execute the specified command list when the\n"
<- "                          conditions are met in procedure <proc>.\n"
<- "when <var> [at <line>] [if <exp>] {command_list} -\n"
<- "                          execute the specified command list when the\n"
<- "                          conditions are met.\n"
<- "when <var> [in procedure] [if <exp>] {command_list} -\n"
<- "                          execute the specified command list when the\n"
<- "                          conditions are met.\n"
<- "(dbx) "
-> "delete 4711 4711\n"
<- "\n"
<- "Found  4711\n"
<- "error: delete 4711 4711\n"
<- "                   ^ Expected end of delete statement\n"
<- "(dbx) "
-> "help run\n"
<- "run   arg1 arg2 ...            - begin execution of the program\n"
<- "rerun arg1 arg2 ...            - begin execution of the program\n"
<- "rerun                          - restart execution of the program\n"
<- "                                 with same arguments last used on run or 
rerun\n"
<- "\n"
<- "The run and rerun commands use the command interpreter indicated by the\n"
<- "environment variable SHELL to expand and interpret\n"
<- "the arguments and redirections.  dbx has built in knowledge of the\n"
<- "Bourne shell (sh) the C shell (csh) and the Korn shell (ksh).  If a user 
is\n"
<- "using a different shell, the run command will not be able to disable 
invocation\n"
<- "of the shell\'s initialization file (.cshrc, .kshrc, etc.)  This may cause 
the\n"
<- "run command to fail if the user\'s initialization file spawns off a program 
or a\n"
<- "sub shell.  If a non standard shell is used, the dbx variable 
$shellparameters\n"
<- "may be set to a string that will instruct the shell to skip loading of 
the\n"
<- "initialization file (for csh one would use \"-f\", for example.)  See the\n"
<- "description of $shellparameters in the $variables section for more 
information.\n"
<- "To verify exactly how your application is being started by the\n"
<- "run/rerun command, start dbx with the -d option (there is no way\n"
<- "to check how your application is started except by adding -d on\n"
<- "the command line, for example:  \"dbx -d a.out\".\n"
<- "This will show other data which you should ignore, but run might show, 
for\n"
<- "example, with /bin/csh as the SHELL:\n"
<- "More (n if no)?"
-> "\n"
<- "(gnome) r\n"
<- "Now execute givenfile with the following call:\n"
<- "execvp(\"/bin/csh\", \n"
<- "        \"/bin/csh,\n"
<- "        \"-f,\n"
<- "        \"-c,\n"
<- "        \"exec ./a.out,\n"
<- "        (char *)0);\n"
<- "Process 21473 (a.out) started\n"
<- "\n"
<- "If one wishes to debug a program with file-descriptors other than\n"
<- "the default 0,1,2 open, then care is required, since if $SHELL is\n"
<- "set to a C-shell, the extra file descriptors will be closed by\n"
<- "csh(1).  Instead, setenv SHELL /bin/sh (which means one can only use\n"
<- "sh-style redirections) for example, as sh(1) does not close the\n"
<- "extra file-descriptors.\n"
<- "\n"
<- "(dbx) "
-> "help givenfile\n"
<- "givenfile                      - displays the name of the program being 
dbx\'d\n"
<- "givenfile <name>               - sets program to debug, like \'dbx 
name\'.\n"
<- "                                 Kills the current running processes and\n"
<- "                                 reads in <name>\'s symbol table.\n"
<- "corefile                       - displays the name of the core file. Says\n"
<- "                                 if the corefile is currently used by dbx\n"
<- "                                 to display program data.\n"
<- "corefile   <core>              - identifies corefile name, like\n"
<- "                                 \'dbx name core\'. Makes dbx use that core 
file\n"
<- "                                 for program data\n"
<- "(dbx) "
-> "help cont\n"
<- "cont                           - continue execution and wait until event\n"
<- "                                 see $promptonfork $mp_program and\n"
<- "                                 MULTIPLE PROCESS DEBUGGING for the\n"
<- "                                 behavior of this command with 
fork/exec/sproc\n"
<- "                                 If the program has a signal handler for\n"
<- "                                 a signal and the program stopped last on\n"
<- "                                 that signal, this passes the signal to\n"
<- "                                 the process on continuing.\n"
<- "cont <signal>                  - continue with signal and wait until 
event\n"
<- "                                 You must use the signal number or name\n"
<- "                                 unless the last stop for this process 
was\n"
<- "                                 via the desired signal.  Since it is 
difficult\n"
<- "                                 to be sure of this, it is simplest to\n"
<- "                                 use the <signal> clause.\n"
<- "cont at <line>                 - continue until <line> is reached\n"
<- "                                  (temporary breakpoint)\n"
<- "cont to <line>                 - same as \'continue at <line>\'\n"
<- "cont in <proc>                 - continue until <proc> is reached  (see 
above)\n"
<- "cont <signal> at <line>        - continue with signal until <line> (see 
above)\n"
<- "cont <signal> to <line>        - same as \'cont <signal> at <line>\'\n"
<- "cont <signal> in <proc>        - continue with signal until <proc> (see 
above)\n"
<- "(dbx) "
-> "help examine\n"
<- "<exp>/<count><format>          - display <count> formatted memory items, 
in\n"
<- "                                 increasing address (see ASSEMBLY 
DEBUGGING\n"
<- "                                 below)(examine memory)\n"
<- "<exp>?<count><format>          - display <count> formatted memory items, 
in\n"
<- "                                 decreasing address (see ASSEMBLY 
DEBUGGING\n"
<- "                                 below)(examine memory)\n"
<- "\n"
<- "For additional options and the format letters, try\n"
<- "        help examineformat\n"
<- "(dbx) "
-> "help rerun\n"
<- "run   arg1 arg2 ...            - begin execution of the program\n"
<- "rerun arg1 arg2 ...            - begin execution of the program\n"
<- "rerun                          - restart execution of the program\n"
<- "                                 with same arguments last used on run or 
rerun\n"
<- "\n"
<- "The run and rerun commands use the command interpreter indicated by the\n"
<- "environment variable SHELL to expand and interpret\n"
<- "the arguments and redirections.  dbx has built in knowledge of the\n"
<- "Bourne shell (sh) the C shell (csh) and the Korn shell (ksh).  If a user 
is\n"
<- "using a different shell, the run command will not be able to disable 
invocation\n"
<- "of the shell\'s initialization file (.cshrc, .kshrc, etc.)  This may cause 
the\n"
<- "run command to fail if the user\'s initialization file spawns off a program 
or a\n"
<- "sub shell.  If a non standard shell is used, the dbx variable 
$shellparameters\n"
<- "may be set to a string that will instruct the shell to skip loading of 
the\n"
<- "initialization file (for csh one would use \"-f\", for example.)  See the\n"
<- "description of $shellparameters in the $variables section for more 
information.\n"
<- "To verify exactly how your application is being started by the\n"
<- "run/rerun command, start dbx with the -d option (there is no way\n"
<- "to check how your application is started except by adding -d on\n"
<- "the command line, for example:  \"dbx -d a.out\".\n"
<- "This will show other data which you should ignore, but run might show, 
for\n"
<- "example, with /bin/csh as the SHELL:\n"
<- "More (n if no)?"
-> "\n"
<- "(gnome) r\n"
<- "Now execute givenfile with the following call:\n"
<- "execvp(\"/bin/csh\", \n"
<- "        \"/bin/csh,\n"
<- "        \"-f,\n"
<- "        \"-c,\n"
<- "        \"exec ./a.out,\n"
<- "        (char *)0);\n"
<- "Process 21473 (a.out) started\n"
<- "\n"
<- "If one wishes to debug a program with file-descriptors other than\n"
<- "the default 0,1,2 open, then care is required, since if $SHELL is\n"
<- "set to a C-shell, the extra file descriptors will be closed by\n"
<- "csh(1).  Instead, setenv SHELL /bin/sh (which means one can only use\n"
<- "sh-style redirections) for example, as sh(1) does not close the\n"
<- "extra file-descriptors.\n"
<- "\n"
<- "(dbx) "
-> "language\n"
<- "\n"
<- "\"language\" is not a valid command name.\n"
<- "error: language\n"
<- "               ^ Apparent syntax error in examine command. expected / ?\n"
<- "(dbx) "
-> "sh pwd\n"
<- "/build/zs/irix6.5m/work/irix/cmd/icrash/brut\n"
<- "(dbx) "
-> "file\n"
<- "no current file\n"
<- "(dbx) "
-> "list\n"
<- "no current file\n"
<- "(dbx) "
-> "status\n"
<- "(dbx) "
-> "givenfile \n"
<- "No current givenfile\n"
<- "(dbx) "
-> "givenfile /build/zs/irix6.5m/work/irix/cmd/icrash/brut/icrash\n"
<- "Executable /build/zs/irix6.5m/work/irix/cmd/icrash/brut/icrash\n"
<- "(dbx) "
-> "file\n"
<- "/build/zs/irix6.5m/work/irix/cmd/icrash/main.c\n"
<- "(dbx) "
-> "list\n"
<- ">*  76  {\n"
<- "    77  \tint i, c, errflg = 0;\n"
<- "    78  \tcommand_t cb;\n"
<- "    79  \n"
<- "    80  \t/* getopt() variables.\n"
<- "    81  \t */\n"
<- "    82  \textern char *optarg;\n"
<- "    83  \textern int optind;\n"
<- "    84  \textern int opterr;\n"
<- "    85  \n"
<- "(dbx) "
-> "status\n"
<- "(dbx) "
#  Reading file "/build/zs/irix6.5m/work/irix/cmd/icrash/main.c"...
#  Reading file "/build/zs/irix6.5m/work/irix/cmd/icrash/main.c"...done.
#  File "/build/zs/irix6.5m/work/irix/cmd/icrash/main.c" 561 lines, 20354 
characters
#  Setting buttons...
#  Setting buttons...done.
-> "givenfile \n"
<- "Current givenfile is /build/zs/irix6.5m/work/irix/cmd/icrash/brut/icrash\n"
<- "(dbx) "
-> "set $assignverify = 1\n"
<- "(dbx) "
-> "set $ctypenames = 1\n"
<- "(dbx) "
-> "set $fp_precise = 0\n"
<- "(dbx) "
-> "set $framereg = 1\n"
<- "(dbx) "
-> "set $groupforktoo = 0\n"
<- "(dbx) "
-> "set $hexchars = 0\n"
<- "(dbx) "
-> "set $hexdoubles = 0\n"
<- "(dbx) "
-> "set $hexin = 0\n"
<- "(dbx) "
-> "set $hexints = 1\n"
<- "(dbx) "
-> "set $hexstrings = 0\n"
<- "(dbx) "
-> "set $mp_program = 1\n"
<- "(dbx) "
-> "set $nonstop = 0\n"
<- "(dbx) "
-> "set $octin = 0\n"
<- "(dbx) "
-> "set $octints = 0\n"
<- "(dbx) "
-> "set $page = 1\n"
<- "(dbx) "
-> "set $pendingtraps = 0\n"
<- "(dbx) "
-> "set $piaddtohist = 1\n"
<- "(dbx) "
-> "set $pimode = 0\n"
<- "(dbx) "
-> "set $print_exception_frame = 0\n"
<- "(dbx) "
-> "set $printdata = 0\n"
<- "(dbx) "
-> "set $printwhilestep = 0\n"
<- "(dbx) "
-> "set $printwide = 0\n"
<- "(dbx) "
-> "set $regstyle = 1\n"
<- "(dbx) "
-> "set $repeatmode = 1\n"
<- "(dbx) "
-> "set $rimode = 0\n"
<- "(dbx) "
-> "set $searchstatics = 1\n"
<- "(dbx) "
-> "set $stdc = 0\n"
<- "(dbx) "
-> "set $stopformat = 1\n"
<- "(dbx) "
-> "set $addrfmt = \"0x%x\"\n"
<- "(dbx) "
-> "set $addrfmt64 = \"0x%llx\"\n"
<- "(dbx) "
-> "set $casesense = 2\n"
<- "(dbx) "
-> "set $editor = \"vim\"\n"
<- "(dbx) "
-> "set $lastchild = 0\n"
<- "(dbx) "
-> "set $lines = 50\n"
<- "(dbx) "
-> "set $listwindow = 22\n"
<- "(dbx) "
-> "set $maxstrlen = 662\n"
<- "(dbx) "
-> "set $pager = \"more\"\n"
<- "(dbx) "
-> "set $pagewidth = 296\n"
<- "(dbx) "
-> "set $pagewindow = 52\n"
<- "(dbx) "
-> "set $prompt = \"(dbx) \"\n"
<- "(dbx) "
-> "set $promptonfork = 0\n"
<- "(dbx) "
-> "set $shellparameters = \"\"\n"
<- "(dbx) "
-> "set $showbreakaddrs = 0\n"
<- "(dbx) "
-> "set $showfilename = 0\n"
<- "(dbx) "
-> "set $sourcepathrule = 1\n"
<- "(dbx) "
-> "set $stacktracelimit = 598\n"
<- "(dbx) "
-> "set $stepintoall = 0\n"
<- "(dbx) "
-> "set $tagfile = \"tags\"\n"
<- "(dbx) "
-> "set $whereisdsolimit = 1\n"
<- "(dbx) "
-> "# reset\n"
<- "\n"
<- "Syntax error: unrecognized command #\n"
<- "(dbx) "
-> "file\n"
<- "/build/zs/irix6.5m/work/irix/cmd/icrash/main.c\n"
<- "(dbx) "
-> "list\n"
<- "\n"
<- "\t Source (of /build/zs/irix6.5m/work/irix/cmd/icrash/main.c) not available 
for Process    -1\n"
<- "(dbx) "
-> "status\n"
<- "(dbx) "
-> "setenv TERM dumb\n"
<- "(dbx) "
-> "givenfile \n"
<- "Current givenfile is /build/zs/irix6.5m/work/irix/cmd/icrash/brut/icrash\n"
<- "(dbx) "
-> "help detach\n"
<- "Invalid keyword detach\n"
<- "(dbx) "
#  Opening session ".ddd"...done.
#  Welcome to DDD 3.3 "Blues by Night" (mips-sgi-irix6.5)
#  Current session is [none].
-> "help run\n"
<- "run   arg1 arg2 ...            - begin execution of the program\n"
<- "rerun arg1 arg2 ...            - begin execution of the program\n"
<- "rerun                          - restart execution of the program\n"
<- "                                 with same arguments last used on run or 
rerun\n"
<- "\n"
<- "The run and rerun commands use the command interpreter indicated by the\n"
<- "environment variable SHELL to expand and interpret\n"
<- "the arguments and redirections.  dbx has built in knowledge of the\n"
<- "Bourne shell (sh) the C shell (csh) and the Korn shell (ksh).  If a user 
is\n"
<- "using a different shell, the run command will not be able to disable 
invocation\n"
<- "of the shell\'s initialization file (.cshrc, .kshrc, etc.)  This may cause 
the\n"
<- "run command to fail if the user\'s initialization file spawns off a program 
or a\n"
<- "sub shell.  If a non standard shell is used, the dbx variable 
$shellparameters\n"
<- "may be set to a string that will instruct the shell to skip loading of 
the\n"
<- "initialization file (for csh one would use \"-f\", for example.)  See the\n"
<- "description of $shellparameters in the $variables section for more 
information.\n"
<- "To verify exactly how your application is being started by the\n"
<- "run/rerun command, start dbx with the -d option (there is no way\n"
<- "to check how your application is started except by adding -d on\n"
<- "the command line, for example:  \"dbx -d a.out\".\n"
<- "This will show other data which you should ignore, but run might show, 
for\n"
<- "example, with /bin/csh as the SHELL:\n"
<- "(gnome) r\n"
<- "Now execute givenfile with the following call:\n"
<- "execvp(\"/bin/csh\", \n"
<- "        \"/bin/csh,\n"
<- "        \"-f,\n"
<- "        \"-c,\n"
<- "        \"exec ./a.out,\n"
<- "        (char *)0);\n"
<- "Process 21473 (a.out) started\n"
<- "\n"
<- "If one wishes to debug a program with file-descriptors other than\n"
<- "the default 0,1,2 open, then care is required, since if $SHELL is\n"
<- "set to a C-shell, the extra file descriptors will be closed by\n"
<- "csh(1).  Instead, setenv SHELL /bin/sh (which means one can only use\n"
<- "sh-style redirections) for example, as sh(1) does not close the\n"
<- "extra file-descriptors.\n"
<- "\n"
<- "(dbx) "
-> "help step\n"
<- "step                           - single step 1 time.\n"
<- "step <int>                     - single step <int> times.\n"
<- "                                 \'step\' steps over procedures compiled 
without\n"
<- "                                 symbols by default.\n"
<- "                                 Breakpoints in procedures stepped over\n"
<- "                                 are honored.\n"
<- "                                 Functions coded entirely on one line 
cause\n"
<- "                                 step to act like stepi, since the actual\n"
<- "                                 code is all assigned one source line.\n"
<- "                                 Outstanding signals are ignored.\n"
<- "\n"
<- "  A step into a dso will fail (will result effectively in a \'next\')\n"
<- "  if rld(1) has not yet lazily evaluated the address of the function.\n"
<- "  Before rerunning the application, setenv LD_BIND_NOW 1\n"
<- "  will force rld to do immediate address resolution and will avoid\n"
<- "  the problem. \n"
<- "\n"
<- "(dbx) "
-> "help stepi\n"
<- "stepi                          - single step 1 assembly instruction\n"
<- "stepi <exp>                    - single step <exp> assembly instructions.\n"
<- "                                 See  $printwhilestep\n"
<- "\n"
<- "   A stepi into a dso will get into strange territory\n"
<- "   (rld(1) specifically)  and stack traces will not work\n"
<- "   well if rld(1) has not yet lazily evaluated the address\n"
<- "   of the function.  Before rerunning the application,\n"
<- "   setenv LD_BIND_NOW 1 will force rld to do immediate\n"
<- "   address resolution and will avoid the problem.\n"
<- "\n"
<- "nexti                          - like stepi, but step over subroutine 
calls\n"
<- "nexti <exp>                    - like stepi <exp>, but step over\n"
<- "                                 subroutine calls\n"
<- "$printwhilestep - if != 0, acts as if \'step[i] n\' was \'step[i]\' n 
times\n"
<- "(dbx) "
-> "help next\n"
<- "next                           - single step 1 time.      steps over 
procedures\n"
<- "next <int>                     - single step <int> times. steps over 
procedures\n"
<- "                                 \'next\' honors breakpoints in 
procedures\n"
<- "                                 stepped over.\n"
<- "                                 A consequence of this is that\n"
<- "                                 a ``stop if\'\' condition which is true 
will\n"
<- "                                 continue to be true -- making dbx stop 
after\n"
<- "                                 every statement in procedures one wanted 
to\n"
<- "                                 step over. Delete the ``stop if\'\'\n"
<- "                                 which has already become true to avoid 
the\n"
<- "                                 stops.\n"
<- "                                 Outstanding signals are ignored.\n"
<- "\n"
<- "(dbx) "
-> "help nexti\n"
<- "stepi                          - single step 1 assembly instruction\n"
<- "stepi <exp>                    - single step <exp> assembly instructions.\n"
<- "                                 See  $printwhilestep\n"
<- "\n"
<- "   A stepi into a dso will get into strange territory\n"
<- "   (rld(1) specifically)  and stack traces will not work\n"
<- "   well if rld(1) has not yet lazily evaluated the address\n"
<- "   of the function.  Before rerunning the application,\n"
<- "   setenv LD_BIND_NOW 1 will force rld to do immediate\n"
<- "   address resolution and will avoid the problem.\n"
<- "\n"
<- "nexti                          - like stepi, but step over subroutine 
calls\n"
<- "nexti <exp>                    - like stepi <exp>, but step over\n"
<- "                                 subroutine calls\n"
<- "$printwhilestep - if != 0, acts as if \'step[i] n\' was \'step[i]\' n 
times\n"
<- "(dbx) "
-> "help until\n"
<- "Invalid keyword until\n"
<- "(dbx) "
-> "help cont\n"
<- "cont                           - continue execution and wait until event\n"
<- "                                 see $promptonfork $mp_program and\n"
<- "                                 MULTIPLE PROCESS DEBUGGING for the\n"
<- "                                 behavior of this command with 
fork/exec/sproc\n"
<- "                                 If the program has a signal handler for\n"
<- "                                 a signal and the program stopped last on\n"
<- "                                 that signal, this passes the signal to\n"
<- "                                 the process on continuing.\n"
<- "cont <signal>                  - continue with signal and wait until 
event\n"
<- "                                 You must use the signal number or name\n"
<- "                                 unless the last stop for this process 
was\n"
<- "                                 via the desired signal.  Since it is 
difficult\n"
<- "                                 to be sure of this, it is simplest to\n"
<- "                                 use the <signal> clause.\n"
<- "cont at <line>                 - continue until <line> is reached\n"
<- "                                  (temporary breakpoint)\n"
<- "cont to <line>                 - same as \'continue at <line>\'\n"
<- "cont in <proc>                 - continue until <proc> is reached  (see 
above)\n"
<- "cont <signal> at <line>        - continue with signal until <line> (see 
above)\n"
<- "cont <signal> to <line>        - same as \'cont <signal> at <line>\'\n"
<- "cont <signal> in <proc>        - continue with signal until <proc> (see 
above)\n"
<- "(dbx) "
-> "help signal\n"
<- "Invalid keyword signal\n"
<- "(dbx) "
-> "help kill\n"
<- "kill                           - kill active process\n"
<- "kill <pid> ...                 - kill process (list) specified\n"
<- "(dbx) "
-> "help up\n"
<- "up                             - move up one activation level in the 
stack\n"
<- "up <exp>                       - move up <exp> activation levels in the 
stack\n"
<- "down                           - move down one activation level in stack\n"
<- "down <exp>                     - move down <exp> activation levels in 
stack\n"
<- "(dbx) "
-> "help down\n"
<- "up                             - move up one activation level in the 
stack\n"
<- "up <exp>                       - move up <exp> activation levels in the 
stack\n"
<- "down                           - move down one activation level in stack\n"
<- "down <exp>                     - move down <exp> activation levels in 
stack\n"
<- "(dbx) "
#  Deleting session ".ddd"...
#  Deleting session ".ddd"...done.
-> "quit\n"
#  Running DBX (pid 153297, tty /dev/ttyq10)...Exit 0.
#  Saving history in "/usr/people/zs/.ddd/history"...
#  Saving history in "/usr/people/zs/.ddd/history"...done.
#  Thanks for using DDD 3.3!

reply via email to

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