


ddd(1)                                                     ddd(1)


NNAAMMEE
       ddd, xddd - the data display debugger

SSYYNNOOPPSSIISS
       dddddd    [----hheellpp] [----ggddbb] [----ddbbxx] [----xxddbb] [----ddeebbuuggggeerr _n_a_m_e]
              [----hhoosstt _h_o_s_t_n_a_m_e [----llooggiinn _u_s_e_r_n_a_m_e]] [----rrhhoosstt _h_o_s_t_-
              _n_a_m_e [----llooggiinn _u_s_e_r_n_a_m_e]] [----vvssll--lliibbrraarryy _l_i_b_r_a_r_y]
              [----vvssll--ppaatthh _p_a_t_h] [----eexxeecc--wwiinnddooww]
              [----nnoo--eexxeecc--wwiinnddooww] [----aattttaacchh--wwiinnddoowwss]
              [----sseeppaarraattee--wwiinnddoowwss] [----ssccrroolllleedd--ggrraapphh--eeddiittoorr]
              [----ppaannnneedd--ggrraapphh--eeddiittoorr] [----ttrraaccee] [----nnww] [----ttttyy]
              [----ffuullllnnaammee] [----vveerrssiioonn] [----ccoonnffiigguurraattiioonn]
              [----cchheecckk--ccoonnffiigguurraattiioonn] [----mmaannuuaall] [----lliicceennssee]
              [_g_d_b_-_o_p_t_i_o_n_s] [_x_-_o_p_t_i_o_n_s] [_v_s_l_-_o_p_t_i_o_n_s] [_p_r_o_g_r_a_m
              [_c_o_r_e | _p_r_o_c_e_s_s_-_i_d]]

       but usually just

       dddddd    _p_r_o_g_r_a_m

DDEESSCCRRIIPPTTIIOONN
       The  purpose  of a debugger such as DDD is to allow you to
       see what is going on "inside"  another  program  while  it
       executes--or  what another program was doing at the moment
       it crashed.

       DDD can do four main kinds of things (plus other things in
       support of these) to help you catch bugs in the act:

       +o Start  your  program,  specifying  anything  that  might
         affect its behavior.

       +o Make your program stop on specified conditions.

       +o Examine  what  has  happened,  when  your  program   has
         stopped.

       +o Change  things  in  your  program, so you can experiment
         with correcting the effects of one  bug  and  go  on  to
         learn about another.

       "Classical"  UNIX debuggers such as the GNU debugger (GDB)
       provide a command-line interface and a multitude  of  com-
       mands  for  these  and other debugging purposes.  DDD is a
       _w_r_a_p_p_e_r around an inferior GDB, DBX, or XDB debugger.   In
       addition  to  the  command-line  interface of the inferior
       debugger, DDD provides a common _g_r_a_p_h_i_c_a_l  _u_s_e_r  _i_n_t_e_r_f_a_c_e
       to  support  debugging tasks.  The DDD _g_r_a_p_h_i_c_a_l _d_a_t_a _d_i_s_-
       _p_l_a_y allows for interactive  exploration  of  data  struc-
       tures.

IINNVVOOKKIINNGG DDDDDD
       You  can  run  DDD with no arguments or options.  However,
       the most usual way to start DDD is with  one  argument  or



DDD 2.1.1                   1 Jun 1997                          1





ddd(1)                                                     ddd(1)


       two, specifying an executable program as the argument:

         dddddd pprrooggrraamm

       You  can  also start with both an executable program and a
       core file specified:

         dddddd pprrooggrraamm ccoorree

       You can, instead, specify a process ID as a  second  argu-
       ment, if you want to debug a running process:

         dddddd pprrooggrraamm 11223344

       would  attach  DDD to process 11223344 (unless you also have a
       file named `11223344'; DDD does check for a core file  first).

       By default, DDD uses GDB as inferior debugger.  Use

         dddddd ----ddbbxx pprrooggrraamm

       or

         dddddd ----xxddbb pprrooggrraamm

       to run DBX or XDB as inferior debugger.

       To learn more about DDD options, run

         dddddd ----hheellpp

       to  get  a  list  of  frequently  used options, or see the
       `OOPPTTIIOONNSS' section, below.

TTHHEE DDDDDD WWIINNDDOOWWSS
       DDD is composed of three main windows:

       +o The _D_a_t_a _W_i_n_d_o_w shows the current data of  the  debugged
         program.

       +o The  _S_o_u_r_c_e  _W_i_n_d_o_w shows the current source code of the
         debugged program.

       +o The _D_e_b_u_g_g_e_r _C_o_n_s_o_l_e accepts debugger commands and shows
         debugger messages.

       By  default, DDD groups these main windows into one single
       window, but DDD can also be configured to treat  each  one
       separately.

       Besides  these main windows, there are some other optional
       windows

       +o The _C_o_m_m_a_n_d _T_o_o_l  offers  buttons  for  frequently  used



DDD 2.1.1                   1 Jun 1997                          2





ddd(1)                                                     ddd(1)


         commands.  It is usually placed on the source window.

       +o The  _M_a_c_h_i_n_e _C_o_d_e _W_i_n_d_o_w shows the current machine code.
         It is usually placed beneath the current source.

       +o The _E_x_e_c_u_t_i_o_n _W_i_n_d_o_w shows the input and output  of  the
         debugged program.

       DDD  also  has  several  temporary _d_i_a_l_o_g_s for showing and
       entering additional information.

       In this manual page,  we  discuss  all  the  functionality
       associated with these windows.  We start with the debugger
       console and its commands, continue with the source window,
       and  continue  with  the data window.  But before that, we
       tell you how to get help while working with DDD.

GGEETTTTIINNGG HHEELLPP
   BBuuttttoonn TTiippss
       You can get a short help text on most DDD buttons by  sim-
       ply  moving  the  mouse  pointer on it and leave it there.
       After a second, a small window (called  _b_u_t_t_o_n  _t_i_p)  pops
       up, giving a hint on the button's meaning.  The button tip
       disappears as soon  as  you  move  the  mouse  pointer  to
       another item.

   TThhee SSttaattuuss LLiinnee
       The  status  line also displays information about the cur-
       rently selected item.  By clicking on the status line, you
       can redisplay the most recent messages.

   CCoonntteexxtt--SSeennssiittiivvee HHeellpp
       You  can  get  detailed  help  on  any visible DDD item by
       pressing the `FF11' key and moving the question  mark  arrow
       on  the item you want help for.  Clicking on the item pops
       up a detailed help text.

       The DDD dialogs  all  contain  `HHeellpp'  buttons  that  give
       detailed information about the dialog.

   HHeellpp oonn DDeebbuuggggeerr CCoommmmaannddss
       You  can  get  help  on  GDB  and DBX commands by entering
       `hheellpp' at the `((ggddbb))' or `((ddbbxx))' prompt.  You can get help
       on XDB commands by entering `hheellpp' at the `>>' prompt.

       See  the  following  section  for details on entering com-
       mands.

EENNTTEERRIINNGG CCOOMMMMAANNDDSS
       In the _d_e_b_u_g_g_e_r _c_o_n_s_o_l_e, you can interact with the command
       interface of the inferior debugger.  Enter commands at the
       _d_e_b_u_g_g_e_r _p_r_o_m_p_t--that is, `((ggddbb))'  for  GDB,  `((ddbbxx))'  for
       DBX, and `>>' for XDB.  You can use arbitrary debugger com-
       mands; use the RREETTUURRNN key to enter them.



DDD 2.1.1                   1 Jun 1997                          3





ddd(1)                                                     ddd(1)


       You can _r_e_p_e_a_t previous and next commands by pressing  the
       `UUpp' and `DDoowwnn' arrow keys, respectively.  If you enter an
       empty line, the last command is  repeated  as  well.   The
       `CCoommmmaanndd  HHiissttoorryy......' item in the `CCoommmmaannddss......' menu shows
       the command history.

       You can _s_e_a_r_c_h for previous commands by pressing `CCttrrll++RR'.
       This  invokes _i_n_c_r_e_m_e_n_t_a_l _s_e_a_r_c_h _m_o_d_e_, where you can enter
       a string to  be  searched  in  previous  commands.   Press
       `CCttrrll++RR' again to repeat the search, or `CCttrrll++SS' to search
       in the reverse direction.  To return to normal mode, press
       EESSCC, or use any cursor command.


       Using GDB, you can also _c_o_m_p_l_e_t_e commands and arguments by
       pressing the `TTAABB' key; pressing the  `TTAABB'  key  multiple
       times shows one possible expansion after the other.

       Here  are some of the most frequently needed debugger com-
       mands.

   CCoommmmoonn GGDDBB ccoommmmaannddss
       bbrreeaakk [_f_i_l_e::]_f_u_n_c_t_i_o_n
               Set a breakpoint at _f_u_n_c_t_i_o_n (in _f_i_l_e).

       rruunn [_a_r_g_l_i_s_t]
              Start your program (with _a_r_g_l_i_s_t, if specified).

       wwhheerree  Display the program stack.

       pprriinntt _e_x_p_r
               Display the value of an expression.

       ccoonntt   Continue running your program (after stopping, e.g.
              at a breakpoint).

       nneexxtt   Execute  next  program  line (after stopping); step
              _o_v_e_r any function calls in the line.

       sstteepp   Execute next program line  (after  stopping);  step
              _i_n_t_o any function calls in the line.

       hheellpp [_n_a_m_e]
              Show information about the command _n_a_m_e, or general
              usage information.

       qquuiitt   Exit DDD.

       For full details on GDB commands, see _U_s_i_n_g _G_D_B_:  _A  _G_u_i_d_e
       _t_o  _t_h_e  _G_N_U _S_o_u_r_c_e_-_L_e_v_e_l _D_e_b_u_g_g_e_r, by Richard M. Stallman
       and Roland H. Pesch.  The same text is available online as
       the ggddbb entry in the iinnffoo program.





DDD 2.1.1                   1 Jun 1997                          4





ddd(1)                                                     ddd(1)


   CCoommmmoonn DDBBXX ccoommmmaannddss
       ssttoopp iinn _f_u_n_c_t_i_o_n
               Set a breakpoint at _f_u_n_c_t_i_o_n_.

       ssttoopp aatt _l_i_n_e
               Set a breakpoint at _l_i_n_e_.

       ffiillee _f_i_l_e
               Change the current file to _f_i_l_e_.

       rruunn [_a_r_g_l_i_s_t]
              Start your program (with _a_r_g_l_i_s_t, if specified).

       wwhheerree  Display the program stack.

       pprriinntt _e_x_p_r
               Display the value of an expression.

       ccoonntt   Continue running your program (after stopping, e.g.
              at a breakpoint).

       nneexxtt   Execute next program line  (after  stopping);  step
              _o_v_e_r any function calls in the line.

       sstteepp   Execute  next  program  line (after stopping); step
              _i_n_t_o any function calls in the line.

       hheellpp [_n_a_m_e]
              Show information about the command _n_a_m_e, or general
              usage information.

       qquuiitt   Exit DDD.

       For  full  details on DBX commands, see the DBX documenta-
       tion.

   CCoommmmoonn XXDDBB ccoommmmaannddss
       bb [_f_i_l_e::]_l_i_n_e
               Set a breakpoint at line _l_i_n_e (in _f_i_l_e).

       bb _f_u_n_c_t_i_o_n
               Set a breakpoint at _f_u_n_c_t_i_o_n_.

       rr [_a_r_g_l_i_s_t]
              Start your program (with _a_r_g_l_i_s_t, if specified).

       tt      Display the program stack.

       pp _e_x_p_r  Display the value of an expression.

       cc      Continue running your program (after stopping, e.g.
              at a breakpoint).

       SS      Execute  next  program  line (after stopping); step



DDD 2.1.1                   1 Jun 1997                          5





ddd(1)                                                     ddd(1)


              _o_v_e_r any function calls in the line.

       ss      Execute next program line  (after  stopping);  step
              _i_n_t_o any function calls in the line.

       hh [_n_a_m_e]
              Show information about the command _n_a_m_e, or general
              usage information.

       qq      Exit DDD.

       For full details on XDB commands, see the  XDB  documenta-
       tion.

OOPPEENNIINNGG FFIILLEESS
       If  you  did  not  invoke  DDD  specifying a program to be
       debugged, you can use the `FFiillee' menu  to  open  programs,
       core dumps and sources.


       To  open  a  program to be debugged, select `OOppeenn PPrrooggrraamm'
       from the `FFiillee' menu.

       To open a core dump for the  program,  select  `OOppeenn  CCoorree
       DDuummpp' from the `FFiillee' menu.

       To  open  an  arbitrary  source file, select `OOppeenn SSoouurrccee'
       from the `FFiillee' menu.

       Note: With XDB and some DBX versions, the debugged program
       must be specified upon invocation and cannot be changed at
       run time.

LLOOOOKKIINNGG UUPP IITTEEMMSS
       If the source of the debugged program  is  available,  the
       _s_o_u_r_c_e  _w_i_n_d_o_w  displays  its  current source text.  (If a
       source text cannot be found, use the GDB `ddiirreeccttoorryy'  com-
       mand to specify source text directories).

       In  the source window, you can lookup and examine function
       and variable definitions as well as search  for  arbitrary
       occurrences in the source text.

   LLooookkiinngg uupp DDeeffiinniittiioonnss
       If you wish to lookup a specific function or variable def-
       inition whose name is visible in the  source  text,  click
       with  the  _l_e_f_t  _m_o_u_s_e  _b_u_t_t_o_n on the function or variable
       name.  The name is copied to the argument field.  Click on
       the `LLooookkuupp(())' button to find its definition.


       As  a  shorter alternative, you can simply press the _r_i_g_h_t
       _m_o_u_s_e _b_u_t_t_o_n on the function name and select the  `llooookkuupp'
       item from the source popup menu.



DDD 2.1.1                   1 Jun 1997                          6





ddd(1)                                                     ddd(1)


       As another alternative, you can enter the function name in
       the argument field and click on the `LLooookkuupp(())'  button  to
       find its definition.

       Finally,  you  can  use the GDB `iinnffoo lliinnee' command.  Type
       `hheellpp iinnffoo lliinnee' at the `((ggddbb))' prompt for details.

   TTeexxttuuaall SSeeaarrcchh
       If the item you wish to search is visible  in  the  source
       text, click with the _l_e_f_t _m_o_u_s_e _b_u_t_t_o_n on it.  The identi-
       fier is copied  to  the  argument  field.   Click  on  the
       `FFiinndd>>>>(())' button to find following occurrences and on the
       `FFiinndd<<<<(())' button to find previous occurrences.

       As an alternative, you can enter the item in the  argument
       field and click on one of the `FFiinndd' buttons.

       By  default, DDD finds only complete words.  To search for
       arbitrary substrings, change the value of the `FFiinndd  WWoorrddss
       OOnnllyy' option in the `SSoouurrccee OOppttiioonnss' menu.


   LLooookkiinngg uupp PPrreevviioouuss LLooccaattiioonnss
       Use the `BBaacckk' and `FFoorrwwaarrdd' buttons to lookup previous or
       next looked-up locations.  The location  found  is  under-
       lined.

BBRREEAAKKPPOOIINNTTSS
       Using  the source window, you can make the program stop at
       certain _b_r_e_a_k_p_o_i_n_t_s and trace its execution.

   SSeettttiinngg BBrreeaakkppooiinnttss bbyy LLooccaattiioonn
       If the source line is visible, click with the  _l_e_f_t  _m_o_u_s_e
       _b_u_t_t_o_n on the source line number and then on the `BBrreeaakk aatt
       (())' button.

       As an alternative, you can simply press  the  _r_i_g_h_t  _m_o_u_s_e
       _b_u_t_t_o_n  on  the  source  line  number  and select the `SSeett
       BBrreeaakkppooiinntt' item from the line popup menu.


       As another alternative, you can enter the line  number  in
       the  argument  field (indicated by `(())::') and click on the
       `BBrreeaakk aatt (())' button.

       As yet another alternative, you can  select  `EEddiitt  BBrreeaakk--
       ppooiinnttss......'   in the `SSoouurrccee' menu, click on the `NNeeww' but-
       ton and enter the line number.

       And finally, you can also use the GDB `bbrreeaakk'  command  or
       the  DBX `ssttoopp' command.  Type `hheellpp bbrreeaakk' at the `((ggddbb))'
       prompt (or `hheellpp ssttoopp' at the `((ddbbxx))' prompt) for details.
       The XDB `bb' command works as well.




DDD 2.1.1                   1 Jun 1997                          7





ddd(1)                                                     ddd(1)


       (If  you  find  this  number of alternatives confusing, be
       aware that DDD users fall  into  three  categories,  which
       must  all  be supported.  _N_o_v_i_c_e _u_s_e_r_s explore DDD and may
       prefer to use one single  mouse  button.   _A_d_v_a_n_c_e_d  _u_s_e_r_s
       know how to use shortcuts and prefer popup menus.  _E_x_p_e_r_i_-
       _e_n_c_e_d _u_s_e_r_s prefer the command line interface.)

       Breakpoints are indicated by a  plain  stop  sign,  or  as
       `##_n##', where _n is the breakpoint number.

   SSeettttiinngg BBrreeaakkppooiinnttss bbyy NNaammee
       If the function name is visible, click with the _l_e_f_t _m_o_u_s_e
       _b_u_t_t_o_n on the function name.  The function name is  copied
       to  the argument field.  Click on the `BBrreeaakk aatt (())' button
       to set a breakpoint there.

       As a shorter alternative, you can simply press  the  _r_i_g_h_t
       _m_o_u_s_e  _b_u_t_t_o_n  on the function name and select the `bbrreeaakk'
       item from the popup menu.

       As another alternative, you can enter the function name in
       the  argument  field  (possibly  using  name completion by
       pressing the `TTAABB' key) and click on  the  `BBrreeaakk  aatt  (())'
       button.

       As  yet  another  alternative, you can click on `NNeeww' from
       the  Breakpoint  editor  (invoked  through  `EEddiitt   BBrreeaakk--
       ppooiinnttss......'   in  the `SSoouurrccee' menu) and enter the function
       name.

       Finally, you can use the GDB `bbrreeaakk' command  or  the  DBX
       `ssttoopp'  command.   Type `hheellpp bbrreeaakk' at the `((ggddbb))' prompt
       (or `hheellpp ssttoopp' at the `((ddbbxx))' prompt) for  details.   The
       XDB `bb' command works as well.

   DDiissaabblliinngg BBrreeaakkppooiinnttss
       Note: DBX does not support breakpoint disabling.

       To temporarily disable a breakpoint, press the _r_i_g_h_t _m_o_u_s_e
       _b_u_t_t_o_n on the breakpoint  name  and  select  the  `DDiissaabbllee
       BBrreeaakkppooiinntt'  item  from  the  breakpoint  popup  menu.  To
       enable it again, select `EEnnaabbllee BBrreeaakkppooiinntt'.


       As an alternative, you can select the breakpoint and click
       on `DDiissaabbllee' or `EEnnaabbllee' in the Breakpoint editor (invoked
       through `EEddiitt BBrreeaakkppooiinnttss......' in the `SSoouurrccee' menu).

       Disabled breakpoints are indicated by a grey stop sign, or
       `___n__', where _n is the breakpoint number.

       Finally,  you  can  use  the  GDB `ddiissaabbllee' command.  Type
       `hheellpp ddiissaabbllee' at the `((ggddbb))' prompt for details.




DDD 2.1.1                   1 Jun 1997                          8





ddd(1)                                                     ddd(1)


   TTeemmppoorraarryy BBrreeaakkppooiinnttss
       A _t_e_m_p_o_r_a_r_y _b_r_e_a_k_p_o_i_n_t is immediately deleted as  soon  as
       it  is reached.  To set a temporary breakpoint,  press the
       _r_i_g_h_t _m_o_u_s_e _b_u_t_t_o_n on the source line  number  and  select
       the `SSeett TTeemmppoorraarryy BBrreeaakkppooiinntt' item from the popup menu.

       Temporary  breakpoints  are convenient to make the program
       continue up to a specific location: just set the temporary
       breakpoint at this location and continue execution.

       The  `CCoonnttiinnuuee UUnnttiill HHeerree' item from the popup menu sets a
       temporary breakpoint on the source line number and immedi-
       ately continues execution.  In GDB, execution stops when a
       source line greater than the source line  is  reached,  or
       when  the  current stack frame is exited.  In DBX and XDB,
       execution stops when the temporary breakpoint is  reached.

   DDeelleettiinngg BBrreeaakkppooiinnttss
       If  the  breakpoint  is visible, click with the _l_e_f_t _m_o_u_s_e
       _b_u_t_t_o_n on the  breakpoint.   The  breakpoint  location  is
       copied  to the argument field.  Click on the `CClleeaarr aatt (())'
       button to delete all breakpoints there.

       If the function name is visible, click with the _l_e_f_t _m_o_u_s_e
       _b_u_t_t_o_n  on the function name.  The function name is copied
       to the argument field.  Click on the `CClleeaarr aatt (())'  button
       to set a breakpoint there.

       As  a  shorter alternative, you can simply press the _r_i_g_h_t
       _m_o_u_s_e _b_u_t_t_o_n on the  breakpoint  and  select  the  `DDeelleettee
       BBrreeaakkppooiinntt' item from the popup menu.

       As  yet another alternative, you can select the breakpoint
       and click on `DDeelleettee' in the  Breakpoint  editor  (invoked
       through `EEddiitt BBrreeaakkppooiinnttss......' in the `SSoouurrccee' menu).

       Finally,  you  can  use  the GDB `cclleeaarr' and `ddeelleettee' com-
       mands.  Type `hheellpp cclleeaarr' or `hheellpp ddeelleettee' at the  `((ggddbb))'
       prompt for details.

   FFiinnddiinngg BBrreeaakkppooiinnttss
       If  you  wish  to lookup a specific breakpoint, select the
       `LLooookkuupp' item from the `BBrreeaakkppooiinnttss' menu.  After  select-
       ing  a  breakpoint from the list and clicking the `LLooookkuupp'
       button, the breakpoint location is displayed.

       As an alternative, you can  enter  `##_n'  in  the  argument
       field,  where  _n is the breakpoint number and click on the
       `LLooookkuupp(())' button to find its definition.

   BBrreeaakkppooiinntt CCoonnddiittiioonnss
       Using the Breakpoint Editor (invoked through `EEddiitt  BBrreeaakk--
       ppooiinnttss......'  in  the `SSoouurrccee' menu), you can specify _b_r_e_a_k_-
       _p_o_i_n_t  _c_o_n_d_i_t_i_o_n_s.   Reaching  the  breakpoint  stops  the



DDD 2.1.1                   1 Jun 1997                          9





ddd(1)                                                     ddd(1)


       program  only if the associated condition is met--that is,
       if the condition expression evaluates to a non-zero value.

       To  set  a  breakpoint  condition,  select the appropriate
       breakpoint in the Breakpoint Editor and click on the `CCoonn--
       ddiittiioonn......'  button.   You  can  then enter (or change) the
       condition in a special dialog.


       As a faster alternative, you  can  also  press  the  _r_i_g_h_t
       _m_o_u_s_e  _b_u_t_t_o_n  on  the  breakpoint  in the source code and
       select the `SSeett CCoonnddiittiioonn......' item from the popup menu.

   BBrreeaakkppooiinntt IIggnnoorree CCoouunnttss
       Using the Breakpoint Editor (invoked through `EEddiitt  BBrreeaakk--
       ppooiinnttss......'  in  the `SSoouurrccee' menu), you can specify _i_g_n_o_r_e
       _c_o_u_n_t_s.  If an ignore count is set, each crossing  of  the
       breakpoint decrements the ignore count.  The program stops
       only if the ignore count is zero.

       To set a breakpoint ignore count, select  the  appropriate
       breakpoint  in  the  Breakpoint  Editor  and  click on the
       `IIggnnoorree CCoouunntt......' button.  You can then enter (or  change)
       the ignore count in a special dialog.

       As  a  faster  alternative,  you  can also press the _r_i_g_h_t
       _m_o_u_s_e _b_u_t_t_o_n on the breakpoint  in  the  source  code  and
       select the `SSeett IIggnnoorree CCoouunntt......' item from the popup menu.

   MMoorree BBrreeaakkppooiinntt FFeeaattuurreess
       More breakpoint features can be invoked through the debug-
       ger  console.   Enter  `hheellpp  bbrreeaakkppooiinnttss'  at the `((ggddbb))'
       prompt.

RRUUNNNNIINNGG TTHHEE PPRROOGGRRAAMM
   SSttaarrttiinngg PPrrooggrraamm EExxeeccuuttiioonn
       Select `RRuunn' from the `PPrrooggrraamm' menu to start execution of
       the  debugged  program.  You will then be prompted for the
       arguments to give to your program.  You can either  select
       from  a  list  of  previously  used arguments or enter own
       arguments in the text field.  Afterwards, press  the  `OOKK'
       button to start execution with the selected arguments.


       To run your program again, with the same arguments, select
       `RRuunn AAggaaiinn' from the `PPrrooggrraamm' menu  or  press  the  `RRuunn'
       button below.  You may also enter `rruunn', followed by argu-
       ments at the debugger prompt instead.

       By default, input and output of the debugged program go to
       the  debugger  console.   As  an alternative, DDD can also
       invoke an _e_x_e_c_u_t_i_o_n _w_i_n_d_o_w,  where  the  program  terminal
       input and output is shown.  See the `RRuunn iinn EExxeeccuuttiioonn WWiinn--
       ddooww' item in the `OOppttiioonnss......'  menu for details.



DDD 2.1.1                   1 Jun 1997                         10





ddd(1)                                                     ddd(1)


   SSttooppppiinngg tthhee PPrrooggrraamm
       The program stops as soon as a breakpoint is reached.  The
       current execution position is highlighted by an arrow.

       You  can  interrupt a running program any time by clicking
       the `IInntteerrrruupptt' button or typing CCttrrll++CC in a DDD window.

   RReessuummiinngg EExxeeccuuttiioonn
       To resume execution, at the  address  where  your  program
       last  stopped, click on the `CCoonnttiinnuuee` button.  Any break-
       points set at that address are bypassed.

       To execute just one source line, click on the `SStteepp'  but-
       ton.  The program is executed until control reaches a dif-
       ferent source line, which may be in a different  function.

       To  continue  to  the  next  line in the current function,
       click on the `NNeexxtt' button.  This is  similar  to  `SStteepp',
       but  any  function calls appearing within the line of code
       are executed without stopping.

       To continue running until the  current  function  returns,
       use  the  `FFiinniisshh' button.  The returned value (if any) is
       printed.


       To continue running until a line after the current  source
       line  is  reached,  use the `CCoonnttiinnuuee UUnnttiill HHeerree' facility
       from the line popup menu.   See  `TTeemmppoorraarryy  BBrreeaakkppooiinnttss',
       above, for a discussion.

   EExxaammiinniinngg tthhee SSttaacckk
       When your program has stopped, the first thing you need to
       know is where it stopped and how it got there.

       DDD provides a _b_a_c_k_t_r_a_c_e _w_i_n_d_o_w showing a summary  of  how
       your  program  got  where  it is.  To enable the backtrace
       window, select `BBaacckkttrraaccee......' from the `SSttaattuuss' menu.

       The `UUpp' button selects the function that called the  cur-
       rent one.

       The  `DDoowwnn' button selects the function that was called by
       the current one.

       You can also directly type the `uupp' and `ddoowwnn' commands at
       the   debugger  prompt.   Typing  CCttrrll++UUpp  and  CCttrrll++DDoowwnn,
       respectively, will also move you through the stack.


   EExxaammiinniinngg TThhrreeaaddss
       Note: Thread support is available with GDB only.  In  some
       operating systems, a single program may have more than one
       _t_h_r_e_a_d of execution.  The  precise  semantics  of  threads



DDD 2.1.1                   1 Jun 1997                         11





ddd(1)                                                     ddd(1)


       differ  from  one operating system to another, but in gen-
       eral the threads of a single program are akin to  multiple
       processes--except  that they share one address space (that
       is, they can all examine and modify the  same  variables).
       On  the  other hand, each thread has its own registers and
       execution stack, and perhaps private memory.

       For debugging purposes, DDD lets you display the  list  of
       threads  currently  active  in  your  program and lets you
       select the _c_u_r_r_e_n_t _t_h_r_e_a_d--the thread which is  the  focus
       of  debugging.  DDD shows all program information from the
       perspective of the current thread.

       To view all currently  active  threads  in  your  program,
       select  `TThhrreeaaddss'  from  the  `ssttaattuuss'  menu.  The current
       thread is highlighted.  Select any thread to make  it  the
       current thread.


       For  more  information on threads, see the section `DDeebbuugg--
       ggiinngg pprrooggrraammss wwiitthh mmuullttiippllee tthhrreeaaddss' in the GDB documenta-
       tion.

EEXXAAMMIINNIINNGG DDAATTAA
       DDD provides three means to examine data.

       VVaalluuee HHiinnttss
                 The quickest way to examine variables is to move
                 the pointer on an occurrence in the source text.
                 The value is displayed in the source line; after
                 a second, a  popup  window  shows  the  variable
                 value.   This is useful for quick examination of
                 several simple variables.

       PPrriinnttiinngg VVaalluueess
                 If you want to reuse variable values at a  later
                 time,  you  can  print the value in the debugger
                 console.  This allows for displaying and examin-
                 ing larger data structures.

       DDiissppllaayyiinngg VVaalluueess
                 If  you want to examine complex data structures,
                 you can display them  graphically  in  the  data
                 display.   Displays  remain  effective until you
                 delete them; they are updated each time the pro-
                 gram  stops.   This  is useful for large dynamic
                 structures.


   DDiissppllaayyiinngg SSiimmppllee VVaalluueess
       To display the value of a simple variable, move the  mouse
       pointer  on  its  name.   After  a  second, a small window
       (called _v_a_l_u_e _t_i_p) pops up showing the value of the  vari-
       able  pointed  at.   The  window disappears as soon as you



DDD 2.1.1                   1 Jun 1997                         12





ddd(1)                                                     ddd(1)


       move the mouse pointer away from the variable.  The  value
       is also shown in the status line.


       The  variable  value  can  also be printed in the debugger
       console, making it available for further  operations.   To
       print  a  variable  value,  select the desired variable by
       clicking the _l_e_f_t _m_o_u_s_e _b_u_t_t_o_n on its name.  The  variable
       name  is  copied  to  the argument field.  By clicking the
       `PPrriinntt(())' button, a new display is  created  in  the  data
       window.

       As  a  shorter alternative, you can simply press the _r_i_g_h_t
       _m_o_u_s_e _b_u_t_t_o_n on the variable name and select  the  `PPrriinntt'
       item from the popup menu.


   DDiissppllaayyiinngg CCoommpplleexx VVaalluueess
       To explore complex data structures, you can use the _g_r_a_p_h_-
       _i_c_a_l _d_a_t_a _d_i_s_p_l_a_y in the _d_a_t_a  _w_i_n_d_o_w.   The  data  window
       holds  _d_i_s_p_l_a_y_s showing names and the values of variables.
       The display is updated each time the program stops.

       To create a new display, select the  desired  variable  by
       clicking  the _l_e_f_t _m_o_u_s_e _b_u_t_t_o_n on its name.  The variable
       name is copied to the argument  field.   By  clicking  the
       `DDiissppllaayy(())'  button,  a new display is created in the data
       window.

       As a shorter alternative, you can simply press  the  _r_i_g_h_t
       _m_o_u_s_e _b_u_t_t_o_n on the variable name and select the `DDiissppllaayy'
       item from the popup menu.

       As another alternative, you may also enter the  expression
       to  be displayed in the argument field and press the `DDiiss--
       ppllaayy(())' button.

       If the data window is visible, you may click on  the  `NNeeww
       DDiissppllaayy'  button.  Enter the expression to be displayed in
       the resulting prompt dialog.


       Finally, you may also enter

         ggrraapphh ddiissppllaayy _e_x_p_r [aatt ((_x_, _y))] [ddeeppeennddeenntt oonn _d_i_s_p_l_a_y]

       at the debugger prompt.  If the  suffix  `aatt  ((_x_,  _y))'  is
       specified, the new data display is created at the position
       (_x, _y); otherwise, a default position is assigned.  If the
       suffix  `ddeeppeennddeenntt oonn _d_i_s_p_l_a_y' is given, an edge from dis-
       play numbered _d_i_s_p_l_a_y to the new display is created;  oth-
       erwise, no edge is created.





DDD 2.1.1                   1 Jun 1997                         13





ddd(1)                                                     ddd(1)


   SSeelleeccttiinngg DDiissppllaayyss
       Each display in the data window has a _t_i_t_l_e _b_a_r containing
       the _d_i_s_p_l_a_y _n_u_m_b_e_r and the displayed expression (the  _d_i_s_-
       _p_l_a_y  _n_a_m_e).  Below the title, the _d_i_s_p_l_a_y _v_a_l_u_e is shown.

       You can select individual displays  by  clicking  on  them
       with  the  _l_e_f_t _m_o_u_s_e _b_u_t_t_o_n.  The resulting expression is
       shown in the _a_r_g_u_m_e_n_t _f_i_e_l_d, below.

       You can _e_x_t_e_n_d an existing selection by pressing the SShhiifftt
       key  while  selecting.   You  can  also _t_o_g_g_l_e an existing
       selection  by  pressing  the  SShhiifftt  key  while  selecting
       already selected displays.

       Single  displays  may  also be selected by using the arrow
       keys.

   SSeelleeccttiinngg MMuullttiippllee DDiissppllaayyss
       Multiple displays are selected by pressing and holding the
       _l_e_f_t  _m_o_u_s_e _b_u_t_t_o_n somewhere on the window background.  By
       moving the pointer while holding the button,  a  selection
       rectangle  is shown; all displays fitting in the rectangle
       are selected when the mouse button is released.

       If the SShhiifftt key is pressed while selecting, the  existing
       selection is _e_x_t_e_n_d_e_d.

       By  double-clicking  on  a display, the display itself and
       all connected displays are automatically selected.



   SSeelleeccttiinngg DDiissppllaayy PPaarrttss
       If a display is composed from several values (that  is,  a
       C/C++  _c_l_a_s_s,  _s_t_r_u_c_t, _u_n_i_o_n, or _a_r_r_a_y; or a Pascal/Modula
       _R_E_C_O_R_D or _A_R_R_A_Y),  you  can  select  individual  parts  by
       clicking  on their names or values.  The resulting expres-
       sion is shown in the _a_r_g_u_m_e_n_t _f_i_e_l_d, below.

       Selection of multiple display parts is not supported.

   SShhoowwiinngg aanndd HHiiddiinngg VVaalluueess
       _A_g_g_r_e_g_a_t_e _V_a_l_u_e_s can be shown _e_x_p_a_n_d_e_d, that is,  display-
       ing all details, or _h_i_d_d_e_n, that is, displayed as `{{......}}'.

       To show details about an aggregate, select  the  aggregate
       by clicking the _l_e_f_t _m_o_u_s_e _b_u_t_t_o_n on its name or value and
       click on the `SShhooww(())' button.  Details are shown  for  the
       aggregate  itself  as  well  as  for  all  contained  sub-
       aggregates.

       To hide details about an aggregate, select  the  aggregate
       by clicking the _l_e_f_t _m_o_u_s_e _b_u_t_t_o_n on its name or value and
       click on the `HHiiddee(())' button.



DDD 2.1.1                   1 Jun 1997                         14





ddd(1)                                                     ddd(1)


       As a faster alternative, you  can  also  press  the  _r_i_g_h_t
       _m_o_u_s_e  _b_u_t_t_o_n  on the aggregate and select the appropriate
       menu item.



   RRoottaattiinngg AArrrraayyss
       Arrays can be  aligned  horizontally  or  vertically.   To
       change the alignment of an array, select it and then click
       on the `RRoottaattee(())' button.

       As a faster alternative, you  can  also  press  the  _r_i_g_h_t
       _m_o_u_s_e  _b_u_t_t_o_n  on  the  array and select the `RRoottaattee' menu
       item.



   DDiissppllaayyiinngg DDeeppeennddeenntt VVaalluueess
       Dependent displays are created from an  existing  display.
       The  dependency  is  indicated  by arrows leading from the
       originating display to the dependent display.

       To create a dependent display, select the originating dis-
       play  or  display part and click on the `NNeeww DDiissppllaayy' but-
       ton.  A prompt dialog appears where you can  enter  a  new
       expression  _E_X_P_R  in  the  argument field.  By clicking on
       `OOKK', the new display showing _E_X_P_R is created.

       As a faster alternative, you  can  also  press  the  _r_i_g_h_t
       _m_o_u_s_e  _b_u_t_t_o_n  on  the originating display part and select
       the `NNeeww DDiissppllaayy......' menu item.

       Using dependent displays, you  can  investigate  the  data
       structure of a "tree" for example and lay it out according
       to your intuitive image of the "tree" data structure.

       By default, DDD does not recognize shared data  structures
       (i.e.  a  data  object  referenced  by multiple other data
       objects).  See the section on _E_x_a_m_i_n_i_n_g _S_h_a_r_e_d _D_a_t_a _S_t_r_u_c_-
       _t_u_r_e_s,  below,  for  details on how to examine such struc-
       tures.

   DDeerreeffeerreenncciinngg PPooiinntteerrss
       Since so many data structures are realized using pointers,
       there  is a shortcut for creating dependent displays show-
       ing the value of a dereferenced pointer.

       To dereference a pointer, select the  originating  pointer
       value  or  name and click on the `DDiissppllaayy ** (())' button.  A
       new display showing the dereferenced pointer value is cre-
       ated.

       As  a  faster  alternative,  you  can also press the _r_i_g_h_t
       _m_o_u_s_e _b_u_t_t_o_n on the originating pointer value or name  and



DDD 2.1.1                   1 Jun 1997                         15





ddd(1)                                                     ddd(1)


       select the `DDiissppllaayy **' menu item.

   DDiissppllaayyiinngg LLooccaall VVaarriiaabblleess
       You  can  display  all local variables at once by choosing
       `DDiissppllaayy LLooccaall VVaarriiaabblleess' from the `DDaattaa' menu.  When  you
       using  DBX  or  XDB,  this  displays  all local variables,
       including the arguments of the current function.  When you
       are using GDB, function arguments are contained in a sepa-
       rate display, activated by `DDiissppllaayy AArrgguummeennttss'.

       The display showing the local variables can be manipulated
       just  like  any  other data display.  Individual variables
       can be selected and dereferenced.



   DDiissppllaayyiinngg PPrrooggrraamm SSttaattuuss
       Besides local variables, you can create a display from the
       output of an arbitrary debugger command.  By entering

         ggrraapphh ddiissppllaayy ``_c_o_m_m_a_n_d``

       the  output  of  _c_o_m_m_a_n_d  is  turned into a _s_t_a_t_u_s _d_i_s_p_l_a_y
       updated each time the program  stops.   For  instance,  by
       entering

         ggrraapphh ddiissppllaayy ``wwhheerree``

       a  status  display named `WWhheerree' is created that shows the
       current backtrace.

       If you are using GDB, DDD provides a panel from which  you
       can  choose  useful  status displays.  In the `DDaattaa' menu,
       select the `SSttaattuuss DDiissppllaayyss......' item and pick your  choice
       from the list.


       Note that status displays are quite time-consuming, so you
       should delete them as soon as  you  don't  need  them  any
       more.

   DDiissppllaayyiinngg MMuullttiippllee AArrrraayy IItteemmss
       When  debugging  C  or C++ programs, one often has to deal
       with pointers to arrays of  dynamically  determined  size.
       Both  DDD and GDB provide special support for such dynamic
       arrays.

       To display several successive objects of the same type  (a
       section of an array, or an array of dynamically determined
       size), use the notation [[_F_R_O_M...._T_O]] in display expressions.
       _F_R_O_M  and  _T_O  denote the first and last array position to
       display.  Thus,

         ggrraapphh ddiissppllaayy aarrggvv[[00....99]]



DDD 2.1.1                   1 Jun 1997                         16





ddd(1)                                                     ddd(1)


       creates ten new display nodes  for  `aarrggvv[[00]]',  `aarrggvv[[11]]',
       ..., `aarrggvv[[99]]'.

       Using  GDB  as  inferior  debugger, you can use _a_r_t_i_f_i_c_i_a_l
       _a_r_r_a_y_s.  Typing

         ggrraapphh ddiissppllaayy aarrggvv[[00]] @@ 1100

       creates a single array display node  containing  `aarrggvv[[00]]'
       up  to  `aarrggvv[[99]]'.   Generally, by using the `@@' operator,
       you can specify the number of array elements  to  be  dis-
       played.

       For  more  details on artificial arrays, see the GDB docu-
       mentation.

   AAlltteerriinngg VVaarriiaabbllee VVaalluueess
       Using the `SSeett (())' button or the `SSeett VVaalluuee' menu item  in
       the  data  popup  menu,  you  can  alter  the value of the
       selected variable, to resume execution  with  the  changed
       value.   In a dialog, you can modify the variable value at
       will; clicking the `OOKK' or  `AAppppllyy'  button  commits  your
       change.

       Note  that  most  inferior  debuggers  have no support for
       changing entire structures; you must change each primitive
       structure member separately.


   DDeelleettiinngg DDiissppllaayyss
       To  delete  a  single  display, select it and click on the
       `DDeelleettee(())' button.  As an alternative, you can also  press
       the  _r_i_g_h_t  _m_o_u_s_e  _b_u_t_t_o_n  on  the  display and select the
       `DDeelleettee DDiissppllaayy' item.

       When a display is deleted,  its  immediate  ancestors  and
       descendants  are  automatically  selected, so that you can
       easily delete entire graphs.

       To delete several displays at once, select the `DDeelleettee......'
       item in the Display Editor (invoked through the `EEddiitt DDiiss--
       ppllaayyss......'  item in the `DDaattaa' menu).  Select any number of
       display items in the usual way and delete them by pressing
       `DDeelleettee'.

       As an alternative, you can also type

         ggrraapphh uunnddiissppllaayy _d_i_s_p_l_a_y_s_._._.

       at the debugger prompt,  where  _d_i_s_p_l_a_y_s_._._.  is  a  space-
       separated list of display numbers to delete.

   DDiissaabblliinngg oorr EEnnaabblliinngg DDiissppllaayyss
       Note: DBX and XDB2+2 do not support display disabling.



DDD 2.1.1                   1 Jun 1997                         17





ddd(1)                                                     ddd(1)


       Unlike  a  _d_e_l_e_t_e_d  display  item, a _d_i_s_a_b_l_e_d display item
       remains in the display, but its value is not  shown  until
       it is enabled again.

       Displays  are  enabled  and disabled the same way they are
       deleted,  using  the  `DDiissaabbllee(())'/`EEnnaabbllee(())'  button,  the
       `DDiissaabbllee'/`EEnnaabbllee  DDiissppllaayy'  popup menu item, or the `DDiiss--
       aabbllee'/`EEnnaabbllee' buttons in the Display Editor.

       As an alternative, you can also type

         ggrraapphh ddiissaabbllee ddiissppllaayy _d_i_s_p_l_a_y_s_._._.

       and

         ggrraapphh eennaabbllee ddiissppllaayy _d_i_s_p_l_a_y_s_._._.

       at the debugger prompt.  _d_i_s_p_l_a_y_s_._._. is a  space-separated
       list of display numbers to disable or enable.


   EExxaammiinniinngg SShhaarreedd DDaattaa SSttrruuccttuurreess
       By  default,  DDD  does  not  recognize shared data struc-
       tures--that is, a data object referenced by multiple other
       data  objects.   For  instance,  if two pointers pp11 and pp22
       point at the same data object dd, the data displays dd, **pp11,
       and  **pp22  will  be separate, although they denote the same
       object.

       DDD provides a special mode which makes  it  detect  these
       situations.   DDD  recognizes if two or more data displays
       are stored at the same physical address, and  if  this  is
       so, merges all these _a_l_i_a_s_e_s into one single data display,
       the _o_r_i_g_i_n_a_l _d_a_t_a _d_i_s_p_l_a_y.   This  mode  is  called  _A_l_i_a_s
       _D_e_t_e_c_t_i_o_n;  it  is  enabled  via the `DDeetteecctt AAlliiaasseess' item
       `DDaattaa' menu.

       When alias detection is enabled, DDD inquires  the  memory
       location  (the  _a_d_d_r_e_s_s)  of  each data display after each
       program step.  If two displays have the same address, they
       are  merged  into  one.   More  specifically, only the one
       which has least recently  changed  remains  (the  _o_r_i_g_i_n_a_l
       _d_a_t_a _d_i_s_p_l_a_y); all other aliases are _s_u_p_p_r_e_s_s_e_d, i.e. com-
       pletely hidden.  The edges  leading  to  the  aliases  are
       replaced by edges leading to the original data display.

       An  edge  created  by alias detection is somewhat special:
       rather than connecting  two  displays  directly,  it  goes
       through an _e_d_g_e _h_i_n_t, describing an arc connecting the two
       displays and the edge hint.

       Each edge hint is a placeholder for  a  suppressed  alias;
       selecting  an  edge  hint  is  equivalent to selecting the
       alias.  This way, you can easily delete display aliases by



DDD 2.1.1                   1 Jun 1997                         18





ddd(1)                                                     ddd(1)


       simply  selecting  the  edge  hint and clicking on `DDeelleettee
       (())'.

       Edge hints can be made invisible by disabling  `SShhooww  EEddggee
       HHiinnttss' in the `DDaattaa OOppttiioonnss' menu.


       To access suppressed display aliases, you can also use the
       Display Editor.  Suppressed displays  are  listed  in  the
       Display  Editor  as  _a_l_i_a_s_e_s of the original data display.
       Via the Display Editor, you can select, change, and delete
       suppressed displays.


       Suppressed displays become visible again as soon as

       +o alias detection is disabled,

       +o their  address  changes  such  that  they  are  no  more
         aliases, or

       +o the original data display  is  deleted,  such  that  the
         least  recently  changed  alias becomes the new original
         data display.

       Please note the following _c_a_v_e_a_t_s with alias detection:

       +o Alias detection requires that  the  current  programming
         language provides a means to determine the address of an
         arbitrary data object.  Currently, only C  and  C++  are
         supported.

       +o Some  inferior  debuggers (for instance, SunOS DBX) pro-
         duce incorrect output for address expressions.  Given  a
         pointer  pp,  you may verify the correct function of your
         inferior debugger by comparing the values of  pp  and  &&pp
         (unless  pp  actually  points  to  itself).  You can also
         examine the data display addresses, as shown in the Dis-
         play Editor.

       +o Alias  detection  slows  down DDD considerably, which is
         why it is disabled by  default.   You  may  consider  to
         enable  it  only  at need--for instance, while examining
         some complex data structure--and disable it while  exam-
         ining  control  flow  (i.e.,  stepping through your pro-
         gram).  DDD will automatically restore  edges  and  data
         displays when switching modes.


   RReeffrreesshhiinngg tthhee DDaattaa WWiinnddooww
       Although  the  data  window refreshes itself automatically
       each time the program stops,  there  are  some  situations
       where you should refresh it explicitly.




DDD 2.1.1                   1 Jun 1997                         19





ddd(1)                                                     ddd(1)


       The data window should be refreshed whenever:

       +o you  disabled,  enabled or deleted displays items at the
         debugger prompt,

       +o the display stays unchanged although all items should be
         deleted (e.g. because you chose another file to debug),

       +o you think it could be useful.

       You  can refresh the data window by selecting the `RReeffrreesshh
       DDiissppllaayyss' item in the `DDaattaa' menu.

       As an alternative, you can press the _r_i_g_h_t _m_o_u_s_e _b_u_t_t_o_n on
       the  background of the data window and select the `RReeffrreesshh
       DDiissppllaayy' item.

       Typing

         ggrraapphh rreeffrreesshh

       at the debugger prompt has the same effect.

GGRRAAPPHH EEDDIITTIINNGG
       The DDD data window offers  some  basic  functionality  to
       manipulate the display graph.

   MMoovviinngg DDiissppllaayyss AArroouunndd
       From  time  to  time,  you  may  wish  to move displays at
       another place in the data window.  You can move  a  single
       display  by  pressing and holding the _l_e_f_t _m_o_u_s_e _b_u_t_t_o_n on
       the display title.  Moving the pointer while  holding  the
       button causes all selected displays to move along with the
       pointer.

       If the data window becomes too small to hold all displays,
       scroll  bars  are  created.   If your DDD is set up to use
       _p_a_n_n_e_r_s instead, a panner is created in  the  lower  right
       edge.   When  the  panner is moved around, the window view
       follows the position  of  the  panner.   See  `CCUUSSTTOOMMIIZZIINNGG
       DDDDDD',  below,  for details on how to set up scroll bars or
       panners.

       For fine-grain movements, selected displays  may  also  be
       moved  using  the arrow keys.  Pressing SShhiifftt and an arrow
       key moves displays by single pixels.  Pressing `CCttrrll'  and
       arrow keys moves displays by grid positions.

       Edge  hints  can  be  selected and moved around like other
       displays.  If an arc goes through the edge hint,  you  can
       change  the  shape  of  the  arc  by  moving the edge hint
       around.





DDD 2.1.1                   1 Jun 1997                         20





ddd(1)                                                     ddd(1)


   AAlliiggnniinngg DDiissppllaayyss
       You can align all displays on the nearest grid position by
       selecting `AAlliiggnn DDiissppllaayyss' from the `GGrraapphh' menu.  This is
       useful for keeping edges horizontal or vertical.

       You can enforce alignment by selecting `SSnnaapp ttoo  GGrriidd'  in
       the  `DDaattaa  OOppttiioonnss'  menu.  If `SSnnaapp ttoo GGrriidd' is enabled,
       displays can be moved on grid positions only.

   LLaayyoouuttiinngg tthhee DDiissppllaayy GGrraapphh
       You can layout the entire graph as  a  tree  by  selecting
       `LLaayyoouutt GGrraapphh' from the `DDaattaa' menu.

       Layouting  the  graph  may  introduce _e_d_g_e _h_i_n_t_s; that is,
       edges are no more straight lines, but lead to an edge hint
       and  from  there  to their destination.  You can make edge
       hints invisible by disabling  `SShhooww  EEddggee  HHiinnttss'  in  the
       `DDaattaa  OOppttiioonnss' menu.  Edge hints can be moved around like
       arbitrary displays.

       To enable a more compact layout, you can set the  `CCoommppaacctt
       LLaayyoouutt'  option in the `DDaattaa OOppttiioonnss' menu.  This realizes
       an alternate layout algorithm, where successors are placed
       next  to  their  parents.   This algorithm is suitable for
       homogeneous data structures only.

       You can enforce layout by setting the  `AAuuttoommaattiicc  LLaayyoouutt'
       option  in the `DDaattaa OOppttiioonnss' menu.  If `AAuuttoommaattiicc LLaayyoouutt'
       is enabled, the graph is layouted after each change.


   RRoottaattiinngg tthhee DDiissppllaayy GGrraapphh
       You can rotate the entire graph clockwise by 90 degrees by
       selecting `RRoottaattee GGrraapphh' from the `DDaattaa' menu.

       If the graph was previously layouted, you may need to lay-
       out it again.  Subsequent layouts will respect the  direc-
       tion of the last rotation.

   PPrriinnttiinngg tthhee DDiissppllaayy GGrraapphh
       DDD  allows  for  printing the graph picture on PostScript
       printers or into files.  This is  useful  for  documenting
       program states.


       To  print  the  graph  on a PostScript printer, select the
       `PPrriinntt GGrraapphh......' item from the  `FFiillee'  menu.   Enter  the
       printing  command  in the `PPrriinntt CCoommmmaanndd' field.  Click on
       the `PPrriinntt' button to start printing.

       To re-print the display graph using the previous settings,
       select the `PPrriinntt AAggaaiinn' item from the `FFiillee' menu.

       As an alternative, you may also print the graph in a file.



DDD 2.1.1                   1 Jun 1997                         21





ddd(1)                                                     ddd(1)


       Click on the `FFiillee' button and enter the file name in  the
       `FFiillee  NNaammee' field.  Click on the `PPrriinntt' button to create
       the file.

       When the graph is printed  in  a  file,  two  formats  are
       available:

       +o PPoossttSSccrriipptt  - suitable for enclosing it in another docu-
         ment;

       +o FFIIGG - suitable for editing, using the XFIG graphic  edi-
         tor,  or for conversion into other formats (among others
         IBMGL, LATEX, PIC), using the TRANSFIG or FIG2DEV  pack-
         age.


       Note: Arcs cannot be printed (yet).  Arcs joining two dis-
       plays are printed using straight  lines;  arcs  joining  a
       display with itself are suppressed.

MMAACCHHIINNEE--LLEEVVEELL DDEEBBUUGGGGIINNGG
       Note: Machine-level support is available with GDB only.

       Sometimes,  it  is desirable to examine a program not only
       at the source level, but also at the machine  level.   DDD
       provides  special  machine  code  and register windows for
       this task.

   EExxaammiinniinngg MMaacchhiinnee CCooddee
       To enable machine-level support, select  `DDiissppllaayy  MMaacchhiinnee
       CCooddee'  from  the  `SSoouurrccee  OOppttiioonnss'  menu.   With `DDiissppllaayy
       MMaacchhiinnee CCooddee' enabled, an additional _m_a_c_h_i_n_e  _c_o_d_e  _w_i_n_d_o_w
       shows up, displaying the machine code of the current func-
       tion.  By moving the sash at the right of  the  separating
       line  between  source and machine code, you can resize the
       source and machine code windows.

       The machine code window works very much  like  the  source
       window.   You  can  set,  clear, and change breakpoints by
       selecting the address and pressing  a  `BBrreeaakk  aatt  (())'  or
       `CClleeaarr  aatt  (())'  button;  the  usual  popup menus are also
       available.  Breakpoints and the current execution position
       are  displayed  simultaneously  in both source and machine
       code.

       The `LLooookkuupp(())' button can be used to look up  the  machine
       code  for  a specific function--or the function for a spe-
       cific address.  Just click on the location in  one  window
       and  press `LLooookkuupp(())' to see the corresponding code in the
       other window.

       If source code is not available,  only  the  machine  code
       window is updated.




DDD 2.1.1                   1 Jun 1997                         22





ddd(1)                                                     ddd(1)


   EExxeeccuuttiioonn
       All execution facilities available in the source code win-
       dow are available in the machine code window as well.  Two
       special facilities are convenient for machine-level debug-
       ging:

       To execute just one  machine  instruction,  click  on  the
       `SStteeppii' button.

       To  continue  to the next instruction in the current func-
       tion, click on the `NNeexxttii' button.   This  is  similar  to
       `SStteeppii',  but  any  subroutine  calls are executed without
       stopping.


   RReeggiisstteerrss
       DDD provides a _r_e_g_i_s_t_e_r _w_i_n_d_o_w showing the machine  regis-
       ter  values after each program stop.  To enable the regis-
       ter window, select `RReeggiisstteerrss......' from the `SSttaattuuss'  menu.

       By  selecting  one of the registers, its name is copied to
       the argument field.  You can use it  as  value  for  `DDiiss--
       ppllaayy(())',  for instance, to have its value displayed in the
       data window.


EEDDIITTIINNGG SSOOUURRCCEE CCOODDEE
       In DDD itself, you cannot change the source file currently
       displayed.   DDD  allows  you  to  invoke  a  _t_e_x_t  _e_d_i_t_o_r
       instead.  To invoke a text editor for the  current  source
       file,  select  the  `EEddiitt'  button or the `EEddiitt SSoouurrccee......'
       item from the `SSoouurrccee' menu.

       The editor  command  is  specified  in  the  `eeddiittCCoommmmaanndd'
       resource.   By  default,  DDD  tries  to  invoke the first
       available editor from the following list:

       +o The editor specified in the `XXEEDDIITTOORR' environment  vari-
         able;

       +o The `ggnnuucclliieenntt' program, invoking a separate window from
         a running EEmmaaccss editor;

       +o The `eemmaaccsscclliieenntt' program, invoking  a  separate  window
         from a running EEmmaaccss editor;

       +o A `xxtteerrmm' terminal emulator running the editor specified
         in the `EEDDIITTOORR' environment variable;

       +o A `xxtteerrmm' terminal emulator running the `vvii' editor.

       After the editor has exited,  the  source  code  shown  is
       automatically brought up-to-date.




DDD 2.1.1                   1 Jun 1997                         23





ddd(1)                                                     ddd(1)


       If you have DDD and an editor running in parallel, you can
       also update the source  code  manually  by  selecting  the
       `RReellooaadd  SSoouurrccee......'  item  from  the  `SSoouurrccee' menu.  This
       reloads the source code shown from the  source  file.   As
       DDD  automatically reloads the source code if the debugged
       program has been recompiled, this should seldom be  neces-
       sary.

QQUUIITTTTIINNGG DDDDDD
       To  exit DDD, select `EExxiitt' from the `FFiillee' menu.  You may
       also type the `qquuiitt' command at the debugger prompt.   GDB
       and  XDB  also  accept  the  `qq' command or an end-of-file
       character (usually CCttrrll++DD).

       An interrupt (CCttrrll++CC or IInntteerrrruupptt) does not exit from DDD,
       but  rather  terminates the action of any debugger command
       that is in progress and returns to  the  debugger  command
       level.   It is safe to type the interrupt character at any
       time because the debugger does not allow it to take effect
       until a time when it is safe.

       In  case  an  ordinary interrupt does not succeed, you can
       also use an abort (CCttrrll++\\ or AAbboorrtt), which  sends  a  QUIT
       signal  to the inferior debugger.  Use this in emergencies
       only; the inferior debugger may be left inconsistent after
       a QUIT signal.

       As  a  last  resort--if  DDD hangs, for example--, you may
       also interrupt DDD itself using an interrupt signal  (SIG-
       INT).   This  can  be done by pressing CCttrrll++CC in the shell
       DDD was started from, or by using the UNIX `kkiillll' command.
       An  interrupt  signal interrupts any DDD action; the infe-
       rior debugger is interrupted as well.  Since  this  inter-
       rupt  signal  can  result in internal inconsistencies, use
       this as a last resort in emergencies only; save your  work
       as soon as possible and restart DDD.

RREEMMOOTTEE DDEEBBUUGGGGIINNGG
       It  is  possible  to  have  the inferior debugger run on a
       remote UNIX host.  This is useful when the remote host has
       a  slow network connection or when DDD is available on the
       local host only.

       In order to run the inferior debugger on  a  remote  host,
       you  need  `rreemmsshh' (called `rrsshh' on BSD systems) access on
       the remote host.

       To run the debugger on a remote host _h_o_s_t_n_a_m_e, invoke  DDD
       as

         dddddd ----hhoosstt _h_o_s_t_n_a_m_e _r_e_m_o_t_e_-_p_r_o_g_r_a_m

       If  your remote  _u_s_e_r_n_a_m_e differs from the local username,
       use



DDD 2.1.1                   1 Jun 1997                         24





ddd(1)                                                     ddd(1)


         dddddd ----hhoosstt _h_o_s_t_n_a_m_e ----llooggiinn _u_s_e_r_n_a_m_e _r_e_m_o_t_e_-_p_r_o_g_r_a_m

       instead.

       There are a few _c_a_v_e_a_t_s in remote mode:

       +o The remote debugger  is  started  in  your  remote  home
         directory.   Hence,  you  must  specify an absolute path
         name for _r_e_m_o_t_e_-_p_r_o_g_r_a_m (or a path name relative to your
         remote  home  directory).   Same  applies to remote core
         files.  Also, be sure to specify  a  remote  process  id
         when debugging a running program.

       +o The  remote debugger is started non-interactively.  Some
         DBX versions have trouble with this.  If you don't get a
         prompt  from  the  remote  debugger,  use  the `----rrhhoosstt'
         option instead of `----hhoosstt'.  This will invoke the remote
         debugger  via  an  interactive shell on the remote host,
         which may lead to better results.
         Note: using `----rrhhoosstt', DDD invokes the inferior debugger
         as  soon as a shell prompt appears.  The first output on
         the remote host ending in a space character or  `>>'  and
         not  followed  by  a  newline  is  assumed to be a shell
         prompt.  If necessary, adjust your shell prompt  on  the
         remote host.

       +o To run the remote program, DDD invokes an `xxtteerrmm' termi-
         nal emulator on the remote  host,  giving  your  current
         `DDIISSPPLLAAYY'  environment  variable  as  address.   If  the
         remote host cannot invoke  `xxtteerrmm',  or  does  not  have
         access   to   your   X   display,  start  DDD  with  the
         `----nnoo--eexxeecc--wwiinnddooww'  option.   The  program  input/output
         will then go through the DDD debugger console.

       +o In  remote  mode, all sources are loaded from the remote
         host; file dialogs scan remote  directories.   This  may
         result in somewhat slower operation than normal.

       +o To  help  you find problems due to remote execution, run
         DDD  with  the  `----ttrraaccee--sshheellll--ccoommmmaannddss'  option.   This
         prints  the  shell  commands  issued  by DDD on standard
         error.

RROOOOTT DDEEBBUUGGGGIINNGG
       Sometimes, you may require to  debug  programs  with  root
       privileges, but without actually logging in as root.  This
       is usually done by installing the  debugger  _s_e_t_u_i_d  _r_o_o_t,
       that  is,  having  the  debugger run with root privileges.
       For security reasons, you cannot install DDD as  a  setuid
       program.   Instead,  you  should  invoke  DDD  such that a
       _s_e_t_u_i_d copy of the inferior debugger is used.

       Here is an example.   Have  a  _s_e_t_u_i_d  _r_o_o_t  copy  of  GDB
       installed as `rroooottggddbb'.  Then invoke



DDD 2.1.1                   1 Jun 1997                         25





ddd(1)                                                     ddd(1)


         dddddd ----ddeebbuuggggeerr rroooottggddbb

       to debug programs with root privileges.

       Since  a  program like `rroooottggddbb' grants root privileges to
       any invoking user, you should give it very limited access.

IINNTTEEGGRRAATTIINNGG DDDDDD
       You  can run DDD as an inferior debugger in other debugger
       front-ends, combining their special abilities  with  those
       of DDD.

   GGeenneerraall IInnffoorrmmaattiioonn
       To  have  DDD  run as an inferior debugger in other front-
       ends, set up your debugger front-end such that `dddddd ----ttttyy'
       is  invoked instead of the inferior debugger.  When DDD is
       invoked using the  `----ttttyy'  option,  it  enables  its  _T_T_Y
       _i_n_t_e_r_f_a_c_e,  taking additional debugger commands from stan-
       dard input and forwarding debugger output to standard out-
       put,  just  as  if  the inferior debugger had been invoked
       directly.    All   remaining   DDD   functionality   stays
       unchanged.

       In  case  your debugger front-end uses the GDB `--ffuullllnnaammee'
       option to have  GDB  report  source  code  positions,  the
       `----ttttyy'  option  is  not  required.   DDD  recognizes  the
       `--ffuullllnnaammee' option, finds that it has been invoked from  a
       debugger  front-end  and  automatically  enables  the  TTY
       interface.

       You may also invoke `dddddd  ----ttttyy'  directly,  entering  DDD
       commands  from  your TTY, or use DDD as the end of a pipe,
       controlled by a remote program.  Be aware,  however,  that
       the  TTY  interface does not support line editing and com-
       mand completion and that DDD exits as soon as it  receives
       a  EOF on its standard input.  Also, do not try to run DDD
       with DDD as inferior debugger.

       The `----ttttyy' option  automatically  disables  the  debugger
       console,  as its facilities are supposed to be provided by
       the integrating front-end.  If the front-end also provides
       source  and/or  data  facilities, you may be interested in
       disabling the DDD source window or the  DDD  data  window,
       too.   Use the `----nnoo--ssoouurrccee--wwiinnddooww' and `----nnoo--ddaattaa--wwiinnddooww'
       options for this purpose.

   UUssiinngg DDDDDD wwiitthh GGNNUU EEmmaaccss
       Use `MM--xx ggddbb' or `MM--xx ddbbxx' to start a  debugging  session.
       At  the  prompt, enter `dddddd ----ttttyy', followed by `----ddbbxx' or
       `----ggddbb', if required, and the name of the  program  to  be
       debugged.  Proceed as usual.

   UUssiinngg DDDDDD wwiitthh XXEEmmaaccss
       Set  the  variable ggddbb--ccoommmmaanndd--nnaammee to ""dddddd"", by inserting



DDD 2.1.1                   1 Jun 1997                         26





ddd(1)                                                     ddd(1)


       the following line in your $$HHOOMMEE//..eemmaaccss file or evaluating
       it  by  pressing  EESSCC :: (EESSCC EESSCC for XEmacs 19.13 and ear-
       lier):

         ((sseettqq ggddbb--ccoommmmaanndd--nnaammee ""dddddd""))

       Use `MM--xx ggddbb' or `MM--xx ggddbbssrrcc' to start  a  debugging  ses-
       sion.  Proceed as usual.

   UUssiinngg DDDDDD wwiitthh XXXXGGDDBB
       Invoke xxxxggddbb as

        xxxxggddbb --ddbb__nnaammee dddddd --ddbb__pprroommpptt ''((ggddbb)) ''


PPRREEFFEERREENNCCEESS
       You  can set up your personal DDD preferences by using the
       `OOppttiioonnss' menu from the menu bar.   These  options  affect
       your running DDD process only, unless you save these pref-
       erences for a later DDD invocation.

   FFrreeqquueenntt PPrreeffeerreenncceess
       If you want to run your debugged  process  in  a  separate
       terminal  emulator  window, set the `RRuunn iinn EExxeeccuuttiioonn WWiinn--
       ddooww' option.  This is useful for programs that  have  spe-
       cial  terminal  requirements  not provided by the debugger
       window, as raw keyboard  processing  or  terminal  control
       sequences.

       By default, DDD finds only complete words.  This is conve-
       nient for clicking on an identifier in the source text and
       search  for  exactly this identifier.  If you want to find
       all occurrences, including word  parts,  unset  the  `FFiinndd
       WWoorrddss OOnnllyy' option.

       If  you wish to display machine code of selected funtions,
       set the `DDiissppllaayy MMaacchhiinnee CCooddee' option.  This makes DDD run
       a little slower, so it is disabled by default.

       Through  the  `PPrreeffeerreenncceess......'  item,  you can set up more
       preferences, which are dicussed here.

   GGeenneerraall PPrreeffeerreenncceess
       By default, when you move the pointer over a  button,  DDD
       gives  a  hint  on the button's meaning in a small window.
       Experienced users may find these _b_u_t_t_o_n  _t_i_p_s  disturbing;
       this  is  why you can disable them by unsetting the `AAuuttoo--
       mmaattiicc ddiissppllaayy ooff bbuuttttoonn hhiinnttss aass ppooppuupp ttiippss' option.

       The button hints are also displayed in  the  status  line.
       Disabling  hints  in  status line (by unsetting the `AAuuttoo--
       mmaattiicc ddiissppllaayy ooff bbuuttttoonn hhiinnttss iinn tthhee ssttaattuuss lliinnee'  option)
       and  disabling  button tips as well makes DDD run slightly
       faster.



DDD 2.1.1                   1 Jun 1997                         27





ddd(1)                                                     ddd(1)


       By default, when you move the pointer over a  variable  in
       the  source  code,  DDD  displays  the variable value in a
       small window.  Users may find these _v_a_l_u_e _t_i_p_s disturbing;
       this  is  why you can disable them by unsetting the `AAuuttoo--
       mmaattiicc ddiissppllaayy ooff vvaarriiaabbllee vvaalluueess aass ppooppuupp ttiippss' option.

       The variable values are also displayed in the status line.
       Disabling variable values in status line (by unsetting the
       `AAuuttoommaattiicc ddiissppllaayy ooff vvaarriiaabbllee vvaalluueess iinn tthhee ssttaattuuss  lliinnee'
       option) and disabling value tips as well will make DDD run
       slightly faster.

       If you want to use TTAABB key completion in all text windows,
       set  the  `TTAABB kkeeyy ccoommpplleetteess iinn aallll wwiinnddoowwss' option.  This
       is useful if you have pointer-driven keyboard  focus  (see
       below)  and  no special usage for the TTAABB key.  Otherwise,
       the TTAABB key completes in the debugger console only.

       If you frequently switch  between  DDD  and  other  multi-
       window  applications, you may like to set the `IIccoonniiffyy aallll
       wwiinnddoowwss aatt oonnccee' option.  This way, all  DDD  windows  are
       iconified and deiconified as a group.

       If  you  are bothered by X warnings, you can suppress them
       by setting the `SSuupppprreessss XX wwaarrnniinnggss' option.

       When debugging a modal X application, DDD may interrupt it
       while  it has grabbed the pointer, making further interac-
       tion impossible.  If the `UUnnggrraabb mmoouussee ppooiinntteerr wwhheenn iinntteerr--
       rruuppttiinngg mmooddaall XX aapppplliiccaattiioonn' option is set, DDD will check
       after each interaction whether the pointer is grabbed.  If
       this  is  so,  DDD  will  instruct the debugged program to
       ungrab the mouse pointer such that you can continue to use
       your display.

       If  you  want to save the command history for the next DDD
       invocation, set the `SSaavvee ccoommmmaanndd hhiissttoorryy oonn eexxiitt' option.
       Note:  This  option is always set if your GDB is set up to
       save its command history.

       The `RReesseett' button restores the most recently saved  pref-
       erences.

   SSoouurrccee PPrreeffeerreenncceess
       In  the  source  text,  the current execution position and
       breakpoints are indicated by symbols (``glyphs'').  As  an
       alternative,  DDD  can also indicate these positions using
       text characters.  If you wish to disable glyphs, unset the
       `UUssee  GGllyypphhss'  option.   This  also makes DDD run slightly
       faster, especially when scrolling.

       By default, DDD caches source files in  memory.   This  is
       convenient  for remote debugging, since remote file access
       may be slow.  If you want to reduce  memory  usage,  unset



DDD 2.1.1                   1 Jun 1997                         28





ddd(1)                                                     ddd(1)


       the `CCaacchhee ssoouurrccee ffiilleess' option.

       By  default,  DDD  caches machine code in memory.  This is
       bad for memory usage, but convenient for speed, since dis-
       assembling  a  function  each  time it is reached may take
       time.  If you want  to  reduce  memory  usage,  unset  the
       `CCaacchhee mmaacchhiinnee ccooddee' option.

       Some  DBX and XDB variants do not properly handle paths in
       source file specifications.   If  you  want  the  inferior
       debugger to refer to source locations by source base names
       only, unset the `RReeffeerr  ttoo  ssoouurrcceess  bbyy  ffuullll  ppaatthh  nnaammee'
       option.

       The  `RReesseett' button restores the most recently saved pref-
       erences.

   DDaattaa PPrreeffeerreenncceess
       If you  want  DDD  to  detect  aliases,  set  the  `DDeetteecctt
       AAlliiaasseess'  option.  Note that alias detection makes DDD run
       slower.  See `EExxaammiinniinngg SShhaarreedd  DDaattaa  SSttrruuccttuurreess',  above,
       for details on alias detection.

       Graph layout and alias detection may introduce _e_d_g_e _h_i_n_t_s;
       that is, edges are no more straight lines, but lead to  an
       edge hint and from there to their destination.  These edge
       hints can be selected and moved around like displays.  You
       can  make  edge  hints  visible  by setting the `SShhooww EEddggee
       HHiinnttss' option.

       To facilitate alignment of data displays, you can set  the
       `AAuuttoo--aalliiggnn   ddiissppllaayyss'   option.   If  auto-alignment  is
       enabled, displays can be moved on grid positions only.

       To enable a more compact layout, you can set the  `CCoommppaacctt
       LLaayyoouutt'  option.   This realizes an alternate layout algo-
       rithm, where successors are placed next to their  parents.
       This algorithm is suitable for homogeneous data structures
       only.

       To enforce layout, you can set the `RRee--llaayyoouutt ggrraapphh  aauuttoo--
       mmaattiiccaallllyy'  option.   If  automatic layout is enabled, the
       graph is layouted after each change.

       In the `GGrriidd SSiizzee' scale, you can change  the  spacing  of
       grid  points.   A spacing of 0 disables the grid.  Default
       is 16.

       The `RReesseett' button restores the most recently saved  pref-
       erences.

   SSttaarrttuupp PPrreeffeerreenncceess
       By  default,  DDD  uses  one  single  window for commands,
       source, and data.  To have separate  windows  for  source,



DDD 2.1.1                   1 Jun 1997                         29





ddd(1)                                                     ddd(1)


       data,  and  debugger  console, set the `WWiinnddoowwss' option to
       `SSeeppaarraattee WWiinnddoowwss'.  This change takes only  effect  after
       you  have  saved  options and restarted DDD.  See also the
       `----aattttaacchh--wwiinnddoowwss'   and   `----sseeppaarraattee--wwiinnddoowwss'   options,
       below.

       DDD  can  display  the status line at the bottom (`aatt bboott--
       ttoomm') or at the top (`aatt ttoopp').  This  change  takes  only
       effect  after  you  have  saved options and restarted DDD.
       Pick your choice.

       DDD can locate the tool buttons in the command  tool  (`iinn
       ccoommmmaanndd  ttooooll')  or  in  another line of buttons below the
       program source (`iinn ssoouurrccee wwiinnddooww').  Pick your choice.

       By default, DDD directs keyboard input to  the  item  your
       mouse  pointer  points  at.  If you prefer a click-to-type
       keyboard focus (that is, click  on  an  item  to  make  it
       accept keyboard input), set the `KKeeyybbooaarrdd FFooccuuss' option on
       `CClliicckk ttoo ttyyppee'.

       By default, DDD uses Motif scroll bars to scroll the  data
       window.  Many people find this inconvenient, since you can
       scroll in the horizontal or vertical direction  only.   As
       an  alternative,  DDD  provides  a  panner (a kind of two-
       dimensional scroll bar).  This is much  more  comfortable,
       but  may  be incompatible with your Motif toolkit.  To set
       up DDD such that it uses panners by default, set the `DDaattaa
       SSccrroolllliinngg'  option  to  `PPaannnneerr'.   This change takes only
       effect after you have saved  options  and  restarted  DDD.
       See      also      the     `----ppaannnneedd--ggrraapphh--eeddiittoorr'     and
       `----ssccrroolllleedd--ggrraapphh--eeddiittoorr' options, below.

       By default, DDD runs with GDB as  inferior  debugger.   To
       change  this  default,  set  the `DDeebbuuggggeerr TTyyppee' option to
       another debugger.  This change takes only effect after you
       have  saved  options  and  restarted  DDD.   See  also the
       `----ggddbb', `----ddbbxx', and `----xxddbb' options, below.

       The `RReesseett' button restores the most recently saved  pref-
       erences.

   SSaavviinngg OOppttiioonnss
       You  can  save  the  current  option settings by selecting
       `SSaavvee OOppttiioonnss' in the `OOppttiioonnss' menu.  Options  are  saved
       in a file named `..ddddddiinniitt' in your home directory.

   OOtthheerr CCuussttoommiizzaattiioonnss
       Other  personal  DDD  resources  can  also  be set in your
       `..ddddddiinniitt' file.  See the `RREESSOOUURRCCEESS' section, below.

       The inferior debugger can be customized through the  `SSeett--
       ttiinnggss......'  item.   See  the  `DDEEBBUUGGGGEERR  SSEETTTTIINNGGSS' section,
       below.



DDD 2.1.1                   1 Jun 1997                         30





ddd(1)                                                     ddd(1)


DDEEBBUUGGGGEERR SSEETTTTIINNGGSS
       If you use GDB as inferior debugger, you  can  change  its
       settings  using  the  `SSeettttiinnggss......'  item in the `OOppttiioonnss'
       menu.   Using  the  settings  editor,  you  can  determine
       whether C++ names are to be demangled, how many array ele-
       ments are to print, and so on.


       The capabilities of the  settings  editor  depend  on  the
       capabilities  of your inferior debugger--that is, your GDB
       version.  Clicking on `??' gives an an explanation  on  the
       specific item; the GDB documentation gives more details.

       Clicking  on `RReesseett' restores the most recently saved set-
       tings.

       Some debugger  settings  are  insensitive  and  cannot  be
       changed,  because  doing  so would endanger DDD operation.
       See the `ggddbbIInniittCCoommmmaannddss' resource for details.

       All debugger settings (except source and object paths) are
       saved with DDD options.

UUSSIINNGG DDDDDD WWIITTHH LLEESSSSTTIIFF
       DDD  2.1.1  and  later include a number of hacks that make
       DDD run with _L_e_s_s_T_i_f_, a free Motif clone, without loss  of
       functionality.   Since  a  DDD  binary  may be dynamically
       bound  and  used  with  either  an  OSF/Motif  or  LessTif
       library,  these  hacks  can be enabled and disabled at run
       time.  The default setting depends on  the  include  files
       used when compiling DDD:

       +o If DDD was compiled using LessTif 0.99 or earlier, these
         hacks are enabled by default.  When using a  dynamically
         bound  DDD  binary  with  a  LessTif  1.0  library or an
         OSF/Motif library, you may wish to  disable  the  hacks.
         To disable them, invoke DDD with `----nnoo--lleessssttiiff--hhaacckkss' or
         set the `lleessssTTiiffHHaacckkss' resource to `ffaallssee'.

       +o If DDD was compiled using  OSF/Motif  include  files  or
         LessTif include files, version 1.0 or later, these hacks
         are disabled by default.  When using a dynamically bound
         DDD  binary with a LessTif library, version 0.99 or ear-
         lier, you may wish to enable  these  hacks.   To  enable
         them,  invoke  DDD  with  `----lleessssttiiff--hhaacckkss'  or  set the
         `lleessssTTiiffHHaacckkss' resource to `ttrruuee'.

       All of these hacks apply to LessTif 0.79;  future  LessTif
       releases  might  need  them  no  more.  In the DDD source,
       these hacks are controlled by the string  `lleessssttiiff__hhaacckkss'.

RREESSOOUURRCCEESS
       DDD  understands  all of the core X Toolkit resource names
       and classes.  The following resources are specific to DDD.



DDD 2.1.1                   1 Jun 1997                         31





ddd(1)                                                     ddd(1)


   SSeettttiinngg DDDDDD FFoonnttss
       This is the default font setting in DDD:

         DDdddd**ffoonnttLLiisstt:: \\
         --**--hheellvveettiiccaa--bboolldd--rr--**--**--1122--**--**--**--**--**--**--**==cchhaarrsseett,,\\
         --**--hheellvveettiiccaa--bboolldd--rr--**--**--1100--**--**--**--**--**--**--**==ssmmaallll,,\\
         --**--lluucciiddaattyyppeewwrriitteerr--mmeeddiiuumm--rr--**--**--1122--**--**--**--**--**--**--**==tttt,,\\
         --**--hheellvveettiiccaa--bboolldd--rr--**--**--1122--**--**--**--**--**--**--**==kkeeyy,,\\
         --**--hheellvveettiiccaa--mmeeddiiuumm--rr--**--**--1122--**--**--**--**--**--**--**==rrmm,,\\
         --**--hheellvveettiiccaa--mmeeddiiuumm--oo--**--**--1122--**--**--**--**--**--**--**==ssll,,\\
         --**--hheellvveettiiccaa--bboolldd--rr--**--**--1122--**--**--**--**--**--**--**==bbff,,\\
         --**--hheellvveettiiccaa--bboolldd--oo--**--**--1122--**--**--**--**--**--**--**==bbss,,\\
         --**--hheellvveettiiccaa--bboolldd--rr--**--**--1144--**--**--**--**--**--**--**==LLooggoo,,\\
         --**--hheellvveettiiccaa--bboolldd--rr--**--**--1122--**--**--**--**--**--**--**==llooggoo,,\\
         --**--ssyymmbbooll--**--**--**--1122--**--**--**--**--**--**--**==ssyymmbbooll


       The font names are used as follows:

       cchhaarrsseett   The default font in buttons, menus, etc.

       ssmmaallll     The default font in a slightly smaller size.

       tttt        The fixed-width font (teletype) used in texts.

       kkeeyy       The font used for describing key caps.

       rrmm        Roman font.  In help texts.

       ssll        Slanted font.  In help texts.

       bbff        Bold face.  In help texts.

       bbss        Slanted bold face.  In help texts.

       LLooggoo      The DDD logo font (uppercase letters).

       llooggoo      The DDD logo font (lowercase letters).

       ssyymmbbooll    The symbol font.  In help texts.

       Here  is  an  alternative, resolution-independent setting,
       which you may copy into your `$$HHOOMMEE//..ddddddiinniitt' file:

         DDdddd**ffoonnttLLiisstt:: \\
         --**--hheellvveettiiccaa--bboolldd--rr--**--**--**--9900--**--**--**--**--**--**==cchhaarrsseett,,\\
         --**--hheellvveettiiccaa--bboolldd--rr--**--**--**--8800--**--**--**--**--**--**==ssmmaallll,,\\
         --**--lluucciiddaattyyppeewwrriitteerr--mmeeddiiuumm--rr--**--**--**--9900--**--**--**--**--**--**==tttt,,\\
         --**--hheellvveettiiccaa--bboolldd--rr--**--**--**--9900--**--**--**--**--**--**==kkeeyy,,\\
         --**--hheellvveettiiccaa--mmeeddiiuumm--rr--**--**--**--9900--**--**--**--**--**--**==rrmm,,\\
         --**--hheellvveettiiccaa--mmeeddiiuumm--oo--**--**--**--9900--**--**--**--**--**--**==ssll,,\\
         --**--hheellvveettiiccaa--bboolldd--rr--**--**--**--9900--**--**--**--**--**--**==bbff,,\\
         --**--hheellvveettiiccaa--bboolldd--oo--**--**--**--9900--**--**--**--**--**--**==bbss,,\\
         --**--hheellvveettiiccaa--bboolldd--rr--**--**--**--112200--**--**--**--**--**--**==LLooggoo,,\\



DDD 2.1.1                   1 Jun 1997                         32





ddd(1)                                                     ddd(1)


         --**--hheellvveettiiccaa--bboolldd--rr--**--**--**--9900--**--**--**--**--**--**==llooggoo,,\\
         --**--ssyymmbbooll--**--**--**--**--9900--**--**--**--**--**--**==ssyymmbbooll

       The fonts in text fields are specified as follows:

         DDdddd**XXmmTTeexxttFFiieelldd..FFoonnttLLiisstt:: \\
         --**--lluucciiddaattyyppee--
       wwrriitteerr--mmeeddiiuumm--rr--**--**--1122--**--**--**--**--**--**--**==cchhaarrsseett
         DDdddd**XXmmTTeexxtt..FFoonnttLLiisstt:: \\
         --**--lluucciiddaattyyppee--
       wwrriitteerr--mmeeddiiuumm--rr--**--**--1122--**--**--**--**--**--**--**==cchhaarrsseett

       And here is another resolution-independent alternative:

         DDdddd**XXmmTTeexxttFFiieelldd..FFoonnttLLiisstt:: \\
         --**--lluucciiddaattyyppee--
       wwrriitteerr--mmeeddiiuumm--rr--**--**--**--9900--**--**--**--**--**--**==cchhaarrsseett
         DDdddd**XXmmTTeexxtt..FFoonnttLLiisstt:: \\
         --**--lluucciiddaattyyppee--
       wwrriitteerr--mmeeddiiuumm--rr--**--**--**--9900--**--**--**--**--**--**==cchhaarrsseett

       These are the fonts in the command tool:

         DDdddd**ttooooll__bbuuttttoonnss..rruunn..ffoonnttLLiisstt:: \\
         --**--hheellvveettiiccaa--bboolldd--rr--**--**--1122--**--**--**--**--**--**--**==cchhaarrsseett
         DDdddd**ttooooll__bbuuttttoonnss..bbrreeaakk..ffoonnttLLiisstt:: \\
         --**--hheellvveettiiccaa--bboolldd--rr--**--**--1122--**--**--**--**--**--**--**==cchhaarrsseett
         DDdddd**ttooooll__bbuuttttoonnss**ffoonnttLLiisstt:: \\
         --**--hheellvveettiiccaa--mmeeddiiuumm--rr--**--**--1100--**--**--**--**--**--**--**==cchhaarrsseett

       The resolution-independent alternative looks like this:

         DDdddd**ttooooll__bbuuttttoonnss..rruunn..ffoonnttLLiisstt:: \\
         --**--hheellvveettiiccaa--bboolldd--rr--**--**--**--9900--**--**--**--**--**--**==cchhaarrsseett
         DDdddd**ttooooll__bbuuttttoonnss..bbrreeaakk..ffoonnttLLiisstt:: \\
         --**--hheellvveettiiccaa--bboolldd--rr--**--**--**--9900--**--**--**--**--**--**==cchhaarrsseett
         DDdddd**ttooooll__bbuuttttoonnss**ffoonnttLLiisstt:: \\
         --**--hheellvveettiiccaa--mmeeddiiuumm--rr--**--**--**--8800--**--**--**--**--**--**==cchhaarrsseett

       Pick your choice  and  copy  and  modify  the  appropriate
       resources to your `$$HHOOMMEE//..ddddddiinniitt' file.  For fonts within
       the data display, see the `vvssllDDeeffss' resource, below.

   SSeettttiinngg DDDDDD CCoolloorrss
       These are the most important color resources used in DDD:

       DDdddd**ffoorreeggrroouunndd::               bbllaacckk

       DDdddd**bbaacckkggrroouunndd::               ggrreeyy

       DDdddd**XXmmTTeexxtt..bbaacckkggrroouunndd::        ggrreeyy9900

       DDdddd**XXmmTTeexxttFFiieelldd..bbaacckkggrroouunndd::   ggrreeyy9900




DDD 2.1.1                   1 Jun 1997                         33





ddd(1)                                                     ddd(1)


       DDdddd**GGrraapphhEEddiitt..bbaacckkggrroouunndd::     ggrreeyy9900

       DDdddd**XXmmLLiisstt..bbaacckkggrroouunndd::        ggrreeyy9900

       DDdddd**ggrraapphh__eeddiitt..nnooddeeCCoolloorr::     bbllaacckk

       DDdddd**ggrraapphh__eeddiitt..eeddggeeCCoolloorr::     bblluuee44

       DDdddd**ggrraapphh__eeddiitt..sseelleeccttCCoolloorr::   bbllaacckk

       DDdddd**ggrraapphh__eeddiitt..ggrriiddCCoolloorr::     bbllaacckk

       DDdddd**ggrraapphh__eeddiitt..ffrraammeeCCoolloorr::    ggrreeyy5500

       DDdddd**ggrraapphh__eeddiitt..oouuttlliinneeCCoolloorr::  ggrreeyy5500

       Again, you can copy and modify the  appropriate  resources
       to your `$$HHOOMMEE//..ddddddiinniitt' file.  For colors within the data
       display, see the `vvssllDDeeffss' resource, below.

   OOppttiioonnss aanndd PPrreeffeerreenncceess
       The following resources determine DDD options and  prefer-
       ences.

       bbuuttttoonnTTiippss ((class TTiippss))
              Whether  button  tips are enabled (`ttrruuee', default)
              or not (`ffaallssee').   Button  tips  are  helpful  for
              novices,  but  may  be  distracting for experienced
              users.

       bbuuttttoonnDDooccss ((class DDooccss))
              Whether the display of button hints in  the  status
              line is enabled (`ttrruuee', default) or not (`ffaallssee').

       ccaacchheeMMaacchhiinneeCCooddee ((class CCaacchheeMMaacchhiinneeCCooddee))
              Whether to cache disassembled machine code (`ttrruuee',
              default)  or  not  (`ffaallssee').  Caching machine code
              requires more memory, but makes DDD run faster.

       ccaacchheeSSoouurrcceeFFiilleess ((class CCaacchheeSSoouurrcceeFFiilleess))
              Whether to cache source files (`ttrruuee', default)  or
              not  (`ffaallssee').  Caching source files requires more
              memory, but makes DDD run faster.

       ddaattaaWWiinnddooww ((class WWiinnddooww))
              If `ffaallssee', no data window is created  upon  start-
              up.

       ddeebbuuggggeerrCCoonnssoollee ((class WWiinnddooww))
              If  `ffaallssee',  no  debugger  console is created upon
              start-up.

       ddiissaasssseemmbbllee ((class DDiissaasssseemmbbllee))
              If this is `ttrruuee', the source code is automatically



DDD 2.1.1                   1 Jun 1997                         34





ddd(1)                                                     ddd(1)


              disassembled.   The  default  is `ffaallssee'.  See also
              the `----ddiissaasssseemmbbllee' and `----nnoo--ddiissaasssseemmbbllee' options,
              below.

       ddiissppllaayyGGllyypphhss ((class DDiissppllaayyGGllyypphhss))
              If  this  is `ttrruuee', the current execution position
              and breakpoints are displayed as glyphs; otherwise,
              they are shown through characters in the text.  The
              default is `ttrruuee'.  See  also  the  `----ggllyypphhss'  and
              `----nnoo--ggllyypphhss' options, below.

       ffiinnddWWoorrddssOOnnllyy ((class FFiinnddWWoorrddssOOnnllyy))
              If  this  is  `ttrruuee' (default), the `FFiinndd' commands
              find complete  words  only.   Otherwise,  arbitrary
              occurrences are found.

       gglloobbaallTTaabbCCoommpplleettiioonn ((class GGlloobbaallTTaabbCCoommpplleettiioonn))
              If  this is `ttrruuee' (default), the TTAABB key completes
              arguments in all windows.  If this is `ffaallssee',  the
              TTAABB key completes arguments in the debugger console
              only.

       ggrroouuppIIccoonniiffyy ((class GGrroouuppIIccoonniiffyy))
              If this is `ttrruuee', (de)iconifying  any  DDD  window
              causes  all  other  DDD  windows  to (de)iconify as
              well.  Default is `ffaallssee', meaning  that  each  DDD
              window can be iconified on its own.

       iinnddeennttAAmmoouunntt ((class IInnddeennttAAmmoouunntt))
              The number of columns used for the code line number
              display (default: 88)

       ppaannnneeddGGrraapphhEEddiittoorr ((class PPaannnneeddGGrraapphhEEddiittoorr))
              What shall DDD use if the graph gets too  large  to
              be  displayed?  If this is `ttrruuee', an Athena panner
              is used (a kind of two-directional scrollbar).   If
              this is `ffaallssee' (default), two Motif scrollbars are
              used.  See also the  `----ssccrroolllleedd--ggrraapphh--eeddiittoorr'  and
              `----ppaannnneedd--ggrraapphh--eeddiittoorr' options, below.

       ppaappeerrSSiizzee ((class PPaappeerrSSiizzee))
              The paper size used for printing, in format _W_I_D_T_H x
              _H_E_I_G_H_T.  The default is  A4  format,  or  `221100mmmm  xx
              229977mmmm'.

       ssaavveeHHiissttoorryyOOnnEExxiitt ((class SSaavveeHHiissttoorryyOOnnEExxiitt))
              If  `ttrruuee'  (default), the command history is auto-
              matically saved when DDD exits.   If  the  inferior
              debugger  saves  its  command  history, its history
              file is used,  otherwise,  `$$HHOOMMEE//..dddddd__hhiissttoorryy'  is
              used.

       sseeppaarraatteeDDaattaaWWiinnddooww ((class SSeeppaarraattee))
              If `ttrruuee', the data window and the debugger console



DDD 2.1.1                   1 Jun 1997                         35





ddd(1)                                                     ddd(1)


              are realized in different  top-level  windows.   If
              `ffaallssee'  (default),  the data window is attached to
              the    debugger    console.     See    also     the
              `----aattttaacchh--wwiinnddoowwss'    and    `----aattttaacchh--ddaattaa--wwiinnddooww'
              options, below.

       sseeppaarraatteeEExxeeccWWiinnddooww ((class SSeeppaarraattee))
              If `ttrruuee', the debugged program is  executed  in  a
              separate  execution  window.  If `ffaallssee' (default),
              the debugged program is  executed  in  the  console
              window.    See   also   the   `----eexxeecc--wwiinnddooww'   and
              `----nnoo--eexxeecc--wwiinnddooww' options, below.

       sseeppaarraatteeSSoouurrcceeWWiinnddooww ((class SSeeppaarraattee))
              If `ttrruuee', the source window and the debugger  con-
              sole  are  realized in different top-level windows.
              If `ffaallssee' (default), the source window is attached
              to    the   debugger   console.    See   also   the
              `----aattttaacchh--wwiinnddoowwss'   and   `----aattttaacchh--ssoouurrccee--wwiinnddooww'
              options, below.

       ssoouurrcceeWWiinnddooww ((class WWiinnddooww))
              If `ffaallssee', no source window is created upon start-
              up.

       ssttaattuussAAttBBoottttoomm ((class SSttaattuussAAttBBoottttoomm))
              If `ttrruuee' (default), the status line is  placed  at
              the  bottom  of the DDD source window.  If `ffaallssee',
              the status line is placed at the  top  of  the  DDD
              source  window.   See also the `----ssttaattuuss--aatt--bboottttoomm'
              and `----ssttaattuuss--aatt--ttoopp' options, below.

       ssuupppprreessssWWaarrnniinnggss ((class SSuupppprreessssWWaarrnniinnggss))
              If `ttrruuee', X  warnings  are  suppressed.   This  is
              sometimes useful for executables that were built on
              a machine with a different X  or  Motif  configura-
              tion.  By default, this is `ffaallssee'.

       ttaabbWWiiddtthh ((class TTaabbWWiiddtthh))
              The  tab  width used in the source window (default:
              88)

       uunnggrraabbMMoouusseePPooiinntteerr ((class UUnnggrraabbMMoouusseePPooiinntteerr))
              When debugging  a  modal  X  application,  DDD  may
              interrupt it while it has grabbed the pointer, mak-
              ing further interaction  impossible.   If  this  is
              `ttrruuee'  (default), DDD will check after each inter-
              action whether the pointer is grabbed.  If this  is
              so,  DDD  will  instruct  the  debugged  program to
              ungrab the mouse pointer.

       uusseeSSoouurrcceePPaatthh ((class UUsseeSSoouurrcceePPaatthh))
              If this is `ffaallssee' (default), the inferior debugger
              refers  to source code locations only by their base



DDD 2.1.1                   1 Jun 1997                         36





ddd(1)                                                     ddd(1)


              names.  If this is `ttrruuee' (default), DDD  uses  the
              full source code paths.

       vvaalluueeTTiippss ((class TTiippss))
              Whether value tips are enabled (`ttrruuee', default) or
              not (`ffaallssee').  Value tips affect  DDD  performance
              and  may be distracting for some experienced users.

       vvaalluueeDDooccss ((class DDooccss))
              Whether the display of variable values in the  sta-
              tus  line  is  enabled  (`ttrruuee',  default)  or  not
              (`ffaallssee').

   DDeebbuuggggeerr SSeettttiinnggss
       The following resources determine the inferior debugger.

       ddbbxxIInniittCCoommmmaannddss ((class DDBBXXIInniittCCoommmmaannddss))
              This string contains a  list  of  newline-separated
              commands  that  are  initially  sent  to  DBX.   By
              default, it is empty.
              Do not use this resource to customize DBX; instead,
              use  a  personal `$$HHOOMMEE//..ddbbxxiinniitt' or `$$HHOOMMEE//..ddbbxxrrcc'
              file.  See your DBX documentation for details.

       ddbbxxSSeettttiinnggss ((class DDBBXXSSeettttiinnggss))
              This string contains a  list  of  newline-separated
              commands  that  are also initially sent to DBX.  By
              default, it is empty.
              In future DDD releases, this resource will be  used
              to save and restore debugger settings.

       ddeebbuuggggeerr ((class DDeebbuuggggeerr))
              The type of the inferior debugger (`ggddbb', `ddbbxx', or
              `xxddbb').  Default value is `ggddbb'.  This resource  is
              usually  set  through  the  `----ggddbb',  `----ddbbxx',  and
              `----xxddbb' options; see below for details.

       ddeebbuuggggeerrCCoommmmaanndd ((class DDeebbuuggggeerrCCoommmmaanndd))
              The name under which the inferior debugger is to be
              invoked.   If  this  string  is empty, the debugger
              type (`ddeebbuuggggeerr' resource) is used.  This  resource
              is usually set through the `----ddeebbuuggggeerr' option; see
              below for details.

       ddeebbuuggggeerrHHoosstt ((class DDeebbuuggggeerrHHoosstt))
              The host where the inferior debugger is to be  exe-
              cuted;  an  empty  string (default) means the local
              host.  See the `----hhoosstt' option, below, and  `RREEMMOOTTEE
              DDEEBBUUGGGGIINNGG', above.

       ddeebbuuggggeerrHHoossttLLooggiinn ((class DDeebbuuggggeerrHHoossttLLooggiinn))
              The  login  user  name on the remote host; an empty
              string (default) means using the local  user  name.
              See   the  `----llooggiinn'  option,  below,  and  `RREEMMOOTTEE



DDD 2.1.1                   1 Jun 1997                         37





ddd(1)                                                     ddd(1)


              DDEEBBUUGGGGIINNGG', above.

       ddeebbuuggggeerrRRHHoosstt ((class DDeebbuuggggeerrRRHHoosstt))
              The host where the inferior debugger is to be  exe-
              cuted;  an  empty string (default) means to use the
              `ddeebbuuggggeerrHHoosstt' resource.  In contrast to `ddeebbuuggggeerr--
              HHoosstt',  using  this  resource  causes  DDD to login
              interactively to the remote  host  and  invoke  the
              inferior  debugger from the remote shell.  See also
              the `----rrhhoosstt' option,  below,  and  `RREEMMOOTTEE  DDEEBBUUGG--
              GGIINNGG', above.

       ffuullllNNaammeeMMooddee ((class TTTTYYMMooddee))
              If  this  is `ttrruuee', DDD reports the current source
              position on standard  output  in  GDB  `----ffuullllnnaammee'
              format.  See also the `----ffuullllnnaammee' option, below.

       ggddbbIInniittCCoommmmaannddss ((class GGDDBBIInniittCCoommmmaannddss))
              This  string  contains  a list of newline-separated
              commands that are initially  sent  to  GDB.   As  a
              side-effect,   all   settings   specified  in  this
              resource are considered fixed and cannot be changed
              through  the GDB settings panel, unless preceded by
              white space.   By  default,  the  `ggddbbIInniittCCoommmmaannddss'
              resource contains some settings vital to DDD:

                DDdddd**ggddbbIInniittCCoommmmaannddss:: \\
                sseett hheeiigghhtt 00\\nn\\
                sseett wwiiddtthh 00\\nn\\
                 sseett vveerrbboossee ooffff\\nn\\
                sseett pprroommpptt ((ggddbb)) \\nn

              While  the  `sseett  hheeiigghhtt',  `sseett  wwiiddtthh',  and `sseett
              pprroommpptt' settings are fixed, the `sseett vveerrbboossee'  set-
              tings can be changed through the GDB settings panel
              (although being reset upon  each  new  DDD  invoca-
              tion).
              Do not use this resource to customize GDB; instead,
              use a personal `$$HHOOMMEE//..ggddbbiinniitt' file.  See your GDB
              documentation for details.

       ggddbbSSeettttiinnggss ((class GGDDBBSSeettttiinnggss))
              This  string  contains  a list of newline-separated
              commands that are also initially sent to GDB.   Its
              default value is

                DDdddd**ggddbbSSeettttiinnggss:: \\
                sseett pprriinntt rreeppeeaattss 00\\nn\\
                sseett pprriinntt aassmm--ddeemmaannggllee oonn\\nn

              This  resource  is  used  to  save  and restore the
              debugger settings.





DDD 2.1.1                   1 Jun 1997                         38





ddd(1)                                                     ddd(1)


       qquueessttiioonnTTiimmeeoouutt ((class QQuueessttiioonnTTiimmeeoouutt))
              The time (in seconds)  to  wait  for  the  inferior
              debugger to reply.  Default is 1100.

       rrHHoossttIInniittCCoommmmaannddss ((class RRHHoossttIInniittCCoommmmaannddss))
              These  commands  are initially executed in a remote
              interactive session, using  the  `----rrhhoosstt'  option.
              By  default,  it  sets  up the remote terminal such
              that it suits DDD:

                DDdddd**rrHHoossttIInniittCCoommmmaannddss:: ssttttyy --eecchhoo --oonnllccrr

              You may add other commands here--for  instance,  to
              set  the  executable  path  or to invoke a suitable
              shell.

       ssyynncchhrroonnoouussDDeebbuuggggeerr ((class SSyynncchhrroonnoouussDDeebbuuggggeerr))
              If `ttrruuee', X events are  not  processed  while  the
              debugger is busy.  This may result in slightly bet-
              ter performance on single-processor  systems.   See
              also the `----ssyynncc--ddeebbuuggggeerr' option, below.

       ttttyyMMooddee ((class TTTTYYMMooddee))
              If  `ttrruuee', enable TTY interface, taking additional
              debugger commands from standard input and  forward-
              ing  debugger  output on standard output.  See also
              the `----ttttyy' and `----ffuullllnnaammee' options, below.

       uusseeTTTTYYCCoommmmaanndd ((class UUsseeTTTTYYCCoommmmaanndd))
              If `ttrruuee', use the GDB `ttttyy' command for  redirect-
              ing  input/output to the separate execution window.
              If `ffaallssee', use explicit redirection through  shell
              redirection  operators `<<' and `>>'.  The default is
              `ffaallssee' (explicit redirection), since on some  sys-
              tems, the `ttttyy' command does not work properly.

       xxddbbIInniittCCoommmmaannddss ((class XXDDBBIInniittCCoommmmaannddss))
              This  string  contains  a list of newline-separated
              commands  that  are  initially  sent  to  XDB.   By
              default, it is empty.
              Do not use this resource to customize DBX; instead,
              use a personal `$$HHOOMMEE//..xxddbbrrcc' file.  See  your  XDB
              documentation for details.

       xxddbbSSeettttiinnggss ((class XXDDBBSSeettttiinnggss))
              This  string  contains  a list of newline-separated
              commands that are also initially sent to  XDB.   By
              default, it is empty.
              In  future DDD releases, this resource will be used
              to save and restore debugger settings.


   UUsseerr--ddeeffiinneedd BBuuttttoonnss
       The following resources can be used to create user-defined



DDD 2.1.1                   1 Jun 1997                         39





ddd(1)                                                     ddd(1)


       buttons.

       ccoonnssoolleeBBuuttttoonnss ((class CCoonnssoolleeBBuuttttoonnss))
              A colon-separated list of buttons to be added under
              the debugger console.  Each button issues the  com-
              mand given by its name.

              The following characters have special meanings:

              +o Commands  ending  with  '......'  insert their name,
                followed by a space, in the debugger console.

              +o Commands ending with a  control  character  (that
                is,  `^^'  followed by a letter or `??') insert the
                given control character.

              +o The string `(())' is replaced by the  current  con-
                tents of the argument field `()'.

              The following button names are reserved:

              CClleeaarr     Clear current command

              PPrreevv      Show previous command

              NNeexxtt      Show next command

              AAppppllyy     Send the given command to the debugger.

              BBaacckk      Lookup  previously  selected source posi-
                        tion.

              FFoorrwwaarrdd   Lookup next selected source position.

              EEddiitt      Edit current source file.

              RReellooaadd    Reload source file.

              CCoommpplleettee  Complete current command.

              YYeess       Answer  current  debugger   prompt   with
                        `yyeess'.   This  button  is visible only if
                        the debugger asks a yes/no question.

              NNoo        Answer current debugger prompt with `nnoo'.
                        This button is visible only if the debug-
                        ger asks a yes/no question.


              The name of the button widget  is  built  from  the
              button  specification.   First,  trailing `......' and
              `^^'  specifications  removed.    Then,   any   non-
              identifier  character  (letter, number, underscore)
              is replaced by `__' (underscore).  Thus, the  button



DDD 2.1.1                   1 Jun 1997                         40





ddd(1)                                                     ddd(1)


              specification  `ddiissppllaayy **(())......' results in a widget
              named  `ddiissppllaayy________'.    Unless   a   `llaabbeellSSttrriinngg'
              resource is specified, the capitalized button spec-
              ification is used as label.

              The default resource  value  is  empty--no  console
              buttons are created.

              Here   are   some  examples  to  insert  into  your
              `$$HHOOMMEE//..ddddddiinniitt' file.  These are the  settings  of
              DDD 1.x:

                DDdddd**ccoonnssoolleeBBuuttttoonnss:: YYeess::NNoo::bbrreeaakk^^CC

              This setting creates some more buttons:

                DDdddd**ccoonnssoolleeBBuuttttoonnss:: \\
                YYeess::NNoo::rruunn::CClleeaarr::PPrreevv::NNeexxtt::AAppppllyy::bbrreeaakk^^CC

              See  also  the  `ddaattaaBBuuttttoonnss',  `ssoouurrcceeBBuuttttoonnss' and
              `ttoooollBBuuttttoonnss' resources, below.


       ddaattaaBBuuttttoonnss ((class DDaattaaBBuuttttoonnss))
              A colon-separated list of buttons to be added under
              the  data  display.  Each button issues the command
              given  by  its  name.   See  the   `ccoonnssoolleeBBuuttttoonnss'
              resource, above, for details on button syntax.

              The default resource value is empty--no source but-
              tons are created.

       ssoouurrcceeBBuuttttoonnss ((class SSoouurrcceeBBuuttttoonnss))
              A colon-separated list of buttons to be added under
              the  debugger console.  Each button issues the com-
              mand given by its name.  See  the  `ccoonnssoolleeBBuuttttoonnss'
              resource, above, for details on button syntax.

              The default resource value is empty--no source but-
              tons are created.

              Here  are  some  example  to   insert   into   your
              `$$HHOOMMEE//..ddddddiinniitt'  file.   These are the settings of
              DDD 1.x:

                DDdddd**ssoouurrcceeBBuuttttoonnss:: \\
                rruunn::sstteepp::nneexxtt::sstteeppii::nneexxttii::ccoonntt::\\
                ffiinniisshh::kkiillll::uupp::ddoowwnn::\\
                BBaacckk::FFoorrwwaarrdd::EEddiitt::iinntteerrrruupptt^^CC

              This setting creates some  buttons  which  are  not
              found on the command tool:

                DDdddd**ssoouurrcceeBBuuttttoonnss:: \\



DDD 2.1.1                   1 Jun 1997                         41





ddd(1)                                                     ddd(1)


                pprriinntt **(())::ggrraapphh ddiissppllaayy **(())::pprriinntt //xx (())::\\
                wwhhaattiiss (())::ppttyyppee (())::wwaattcchh (())::uunnttiill::sshheellll

              An  even  more professional setting uses customized
              button labels:

                DDdddd**ssoouurrcceeBBuuttttoonnss:: \\
                pprriinntt **(((())))::ggrraapphh ddiissppllaayy **(((())))::pprriinntt //xx (())::\\
                wwhhaattiiss (())::ppttyyppee (())::wwaattcchh (())::uunnttiill::sshheellll
                DDdddd**ggrraapphh__ddiissppllaayy____________..llaabbeellSSttrriinngg:: DDiissppllaayy **(())
                DDdddd**pprriinntt____________..llaabbeellSSttrriinngg::         PPrriinntt **(())
                DDdddd**wwhhaattiiss______..llaabbeellSSttrriinngg::           WWhhaatt iiss (())

              See also  the  `ccoonnssoolleeBBuuttttoonnss'  and  `ddaattaaBBuuttttoonnss'
              resources,  above,  and the `ttoooollBBuuttttoonnss' resource,
              below.

       ttoooollBBaarr ((class TToooollBBaarr))
              Whether the tool buttons  (see   the  `ttoooollBBuuttttoonnss'
              resource,  below)  should  be  shown  in a tool bar
              below the source window (ttrruuee) or within  the  com-
              mand  tool (ffaallssee, default).  Enabling the tool bar
              disables the command tool and vice versa.

       ttoooollBBuuttttoonnss ((class TToooollBBuuttttoonnss))
              A colon-separated list of buttons to be included in
              the command tool or the tool bar (see the `ttoooollBBaarr'
              resource, above).  Each button issues  the  command
              given   by  its  name.   See  the  `ccoonnssoolleeBBuuttttoonnss'
              resource, above, for details on button syntax.

              The default resource value is

                DDdddd**ttoooollBBuuttttoonnss:: \\
                rruunn::iinntteerrrruupptt^^CC::sstteepp::sstteeppii::\\
                nneexxtt::nneexxttii::ccoonntt::ffiinniisshh::\\
                uupp::ddoowwnn::BBaacckk::FFoorrwwaarrdd::EEddiitt::kkiillll

              For each button, its location in the  command  tool
              must   be   specified   using   XXmmFFoorrmm   constraint
              resources.  Each side of a button is attached to  a
              row  or  column position.  Rows are numbered from 0
              (top side) to 8 (bottom side); columns likewise are
              numbered from 0 (left side) to 8 (right side).  The
              position of the  bbrreeaakk  button,  for  instance,  is
              specified as:

                DDdddd**ttooooll__bbuuttttoonnss..bbrreeaakk..ttooppPPoossiittiioonn::    11
                DDdddd**ttooooll__bbuuttttoonnss..bbrreeaakk..bboottttoommPPoossiittiioonn:: 22
                DDdddd**ttooooll__bbuuttttoonnss..bbrreeaakk..lleeffttPPoossiittiioonn::   00
                DDdddd**ttooooll__bbuuttttoonnss..bbrreeaakk..rriigghhttPPoossiittiioonn::  88

              while the BBaacckk button position is specified as




DDD 2.1.1                   1 Jun 1997                         42





ddd(1)                                                     ddd(1)


                DDdddd**ttooooll__bbuuttttoonnss..BBaacckk..ttooppPPoossiittiioonn::     66
                DDdddd**ttooooll__bbuuttttoonnss..BBaacckk..bboottttoommPPoossiittiioonn::  77
                DDdddd**ttooooll__bbuuttttoonnss..BBaacckk..lleeffttPPoossiittiioonn::    00
                DDdddd**ttooooll__bbuuttttoonnss..BBaacckk..rriigghhttPPoossiittiioonn::   44

              The  number of rows and columns (default: 8) can be
              changed by setting the `ffrraaccttiioonnBBaassee' resource to a
              different value:

                DDdddd**ttooooll__bbuuttttoonnss..ffrraaccttiioonnBBaassee::         1100

              If you change the `ffrraaccttiioonnBBaassee' resource, you must
              provide new positions for _a_l_l buttons in  the  com-
              mand  tool.   See  the  `DDdddd' app-defaults file for
              more details.

              If the `ttoooollBBuuttttoonnss' resource value is  empty,  the
              command tool is not created.

       ttoooollRRiigghhttOOffffsseett ((class OOffffsseett))
              The  distance  between the right border of the com-
              mand tool and the right border of the  source  text
              (in pixels).  Default is 8 pixels.

       ttoooollTTooppOOffffsseett ((class OOffffsseett))
              The  distance  between the upper border of the com-
              mand tool and the upper border of the  source  text
              (in pixels).  Default is 8 pixels.

       vveerriiffyyBBuuttttoonnss ((class VVeerriiffyyBBuuttttoonnss))
              If  true  (default), verify for each button whether
              its command is actually supported by  the  inferior
              debugger.  If the command is unknown, the button is
              disabled.  If this resource is false,  no  checking
              is done: all commands are accepted `as is'.

   DDaattaa DDiissppllaayy RReessoouurrcceess
       The following resources control the data display.

       vvssllDDeeffss ((class VVSSLLDDeeffss))
              A  string  with additional VSL definitions that are
              appended to the builtin VSL library.  This resource
              can  be  used  to override specific VSL definitions
              that affect the data display.

              The general pattern to replace a  function  defini-
              tion _F_U_N_C_T_I_O_N with a new definition _N_E_W___D_E_F is:

              ##pprraaggmmaa rreeppllaaccee _F_U_N_C_T_I_O_N
              _F_U_N_C_T_I_O_N((_A_R_G_S...)) == _N_E_W___D_E_F;;

              The following VSL functions are frequently used:





DDD 2.1.1                   1 Jun 1997                         43





ddd(1)                                                     ddd(1)


              ccoolloorr((_B_O_X,, _F_O_R_E_G_R_O_U_N_D [[,, _B_A_C_K_G_R_O_U_N_D]]))
                        Set  the _F_O_R_E_G_R_O_U_N_D and _B_A_C_K_G_R_O_U_N_D colors
                        of _B_O_X.

              ddiissppllaayy__ccoolloorr((_B_O_X))
                        The  color   used   in   data   displays.
                        Default: ccoolloorr((_B_O_X,, ""bbllaacckk"",, ""ggrreeyy9955""))

              ttiittllee__ccoolloorr((_B_O_X))
                        The   color   used   in  the  title  bar.
                        Default: ccoolloorr((_B_O_X,, ""bbllaacckk""))

              ddiissaabblleedd__ccoolloorr((_B_O_X))
                        The  color  used  for   disabled   boxes.
                        Default: ccoolloorr((_B_O_X,, ""wwhhiittee"",, ""ggrreeyy5500""))

              ssiimmppllee__ccoolloorr((_B_O_X))
                        The   color   used   for  simple  values.
                        Default: ccoolloorr((_B_O_X,, ""bbllaacckk""))

              ppooiinntteerr__ccoolloorr((_B_O_X))
                        The color used  for  pointers.   Default:
                        ccoolloorr((_B_O_X,, ""bblluuee44""))

              ssttrruucctt__ccoolloorr((_B_O_X))
                        The  color used for structures.  Default:
                        ccoolloorr((_B_O_X,, ""bbllaacckk""))

              aarrrraayy__ccoolloorr((_B_O_X))
                        The  color  used  for  arrays.   Default:
                        ccoolloorr((_B_O_X,, ""bblluuee44""))

              rreeffeerreennccee__ccoolloorr((_B_O_X))
                        The  color used for references.  Default:
                        ccoolloorr((_B_O_X,, ""bblluuee44""))

              ssttddffoonnttffaammiillyy(())
                        The  font  family  used.   One  of   ffaamm--
                        iillyy__ttiimmeess(()),    ffaammiillyy__ccoouurriieerr(()),    ffaamm--
                        iillyy__hheellvveettiiccaa(()), ffaammiillyy__nneeww__cceennttuurryy(()), or
                        ffaammiillyy__ttyyppeewwrriitteerr(()) (default).

              ssttddffoonnttssiizzee(())
                        The  font size used (in pixels).  00 means
                        to use ssttddffoonnttppooiinnttss(()) instead.   Default
                        value: 1122.

              ssttddffoonnttppooiinnttss(())
                        The  font  size used (in 1/10 points).  00
                        (default)  means  to  use   ssttddffoonnttssiizzee(())
                        instead.

              ssttddffoonnttwweeiigghhtt(())
                        The    font    weight    used.     Either



DDD 2.1.1                   1 Jun 1997                         44





ddd(1)                                                     ddd(1)


                        wweeiigghhtt__mmeeddiiuumm(())       (default)        or
                        wweeiigghhtt__bboolldd(()).

              To set the pointer color to "red4", use

                DDdddd**vvssllDDeeffss:: \\
                ##pprraaggmmaa rreeppllaaccee ppooiinntteerr__ccoolloorr\\nn\\
                ppooiinntteerr__ccoolloorr((bbooxx)) == ccoolloorr((bbooxx,, ""rreedd44""));;\\nn

              To   set  the  default  font  size  to  resolution-
              independent 10.0 points, use

                DDdddd**vvssllDDeeffss:: \\
                ##pprraaggmmaa rreeppllaaccee ssttddffoonnttssiizzee\\nn\\
                ##pprraaggmmaa rreeppllaaccee ssttddffoonnttppooiinnttss\\nn\\
                ssttddffoonnttssiizzee(()) == 00;;\\nn
                ssttddffoonnttppooiinnttss(()) == 110000;;\\nn

              To set the default font to 12-pixel courier, use

                DDdddd**vvssllDDeeffss:: \\
                ##pprraaggmmaa rreeppllaaccee ssttddffoonnttssiizzee\\nn\\
                ##pprraaggmmaa rreeppllaaccee ssttddffoonnttffaammiillyy\\nn\\
                ssttddffoonnttssiizzee(()) == 1122;;\\nn\\
                ssttddffoonnttffaammiillyy(()) == ffaammiillyy__ccoouurriieerr(());;\\nn

              See the file `dddddd..vvssll' for further  definitions  to
              override using the `vvssllDDeeffss' resource.


       vvssllLLiibbrraarryy ((class VVSSLLLLiibbrraarryy))
              The  VSL library to use.  `bbuuiillttiinn' (default) means
              to use the built-in library,  any  other  value  is
              used as file name.

       vvssllPPaatthh ((class VVSSLLPPaatthh))
              A colon-separated list of directories to search for
              VSL include files.  Default  is  `..',  the  current
              directory.

              If  your  DDD  source  distribution is installed in
              `//oopptt//ssrrcc', you can use the following  settings  to
              read the VSL library from `//hhoommee//jjooee//dddddd..vvssll':

                DDdddd**vvssllLLiibbrraarryy::  //hhoommee//jjooee//dddddd..vvssll
                DDdddd**vvssllPPaatthh::  \\
                ..:://oopptt//ssrrcc//dddddd//dddddd:://oopptt//ssrrcc//dddddd//vvsslllliibb

              VSL include files referenced by `//hhoommee//jjooee//dddddd..vvssll'
              are searched first in the  current  directory  `..',
              then    in   `//oopptt//ssrrcc//dddddd//dddddd//',   and   then   in
              `//oopptt//ssrrcc//dddddd//vvsslllliibb//'.

              Instead of supplying another  VSL  library,  it  is



DDD 2.1.1                   1 Jun 1997                         45





ddd(1)                                                     ddd(1)


              often  easier  to specify some minor changes to the
              built-in  library.   See  the  `vvssllDDeeffss'  resource,
              above, for details.

   CCuussttoommiizziinngg HHeellppeerr PPrrooggrraammss
       The   following   resources  determine  external  programs
       invoked by DDD.

       eeddiittCCoommmmaanndd ((class EEddiittCCoommmmaanndd))
              A command string to invoke an editor  on  the  spe-
              cific  file.   `@@LLIINNEE@@'  is replaced by the current
              line  number,  `@@FFIILLEE@@'  by  the  file  name.   The
              default  is to invoke $$XXEEDDIITTOORR first, then $$EEDDIITTOORR,
              then vvii:

                DDdddd**eeddiittCCoommmmaanndd:: \\
                $${{XXEEDDIITTOORR==ffaallssee}} ++@@LLIINNEE@@ @@FFIILLEE@@ \\
                |||| xxtteerrmm --ee $${{EEDDIITTOORR==vvii}} ++@@LLIINNEE@@ @@FFIILLEE@@

              This `..ddddddiinniitt' setting invokes an editing  session
              for an _X_E_m_a_c_s editor running _g_n_u_s_e_r_v:

                DDdddd**eeddiittCCoommmmaanndd:: ggnnuucclliieenntt ++@@LLIINNEE@@ @@FFIILLEE@@

              This  `..ddddddiinniitt' setting invokes an editing session
              for an _E_m_a_c_s editor running _e_m_a_c_s_s_e_r_v_e_r:

                DDdddd**eeddiittCCoommmmaanndd:: eemmaaccsscclliieenntt ++@@LLIINNEE@@ @@FFIILLEE@@


       lleessssTTiiffHHaacckkss ((class LLeessssTTiiffHHaacckkss))
              If ttrruuee, enable some hacks to make DDD run properly
              with LessTif.  The default value is ttrruuee if DDD was
              compiled with a LessTif version earlier  than  1.0,
              and ffaallssee, otherwise.

       lliissttCCoorreeCCoommmmaanndd ((class lliissttCCoorreeCCoommmmaanndd))
              The  commmand  to list all core files on the remote
              host.  The string `@@MMAASSKK@@' is replaced  by  a  file
              filter.  The default setting is:

                DDdddd**lliissttCCoorreeCCoommmmaanndd:: \\
                ffiillee @@MMAASSKK@@ || ggrreepp ''..**::..**ccoorree..**'' \\
                || ccuutt --dd:: --ff11


       lliissttDDiirrCCoommmmaanndd ((class lliissttDDiirrCCoommmmaanndd))
              The  commmand to list all directories on the remote
              host.  The string `@@MMAASSKK@@' is replaced  by  a  file
              filter.  The default setting is:

                DDdddd**lliissttDDiirrCCoommmmaanndd:: \\
                ffiillee @@MMAASSKK@@ || ggrreepp ''..**::..**ddiirreeccttoorryy..**'' \\
                || ccuutt --dd:: --ff11



DDD 2.1.1                   1 Jun 1997                         46





ddd(1)                                                     ddd(1)


       lliissttEExxeeccCCoommmmaanndd ((class lliissttEExxeeccCCoommmmaanndd))
              The  commmand  to  list all executable files on the
              remote host.  The string `@@MMAASSKK@@' is replaced by  a
              file filter.  The default setting is:

                DDdddd**lliissttEExxeeccCCoommmmaanndd:: \\
                ffiillee @@MMAASSKK@@ || ggrreepp ''..**::..**eexxeecc..**'' \\
                || ggrreepp --vv  ''..**::..**ssccrriipptt..**'' \\
                || ccuutt --dd:: --ff11 || ggrreepp --vv ''..**\\..oo$$''


       lliissttSSoouurrcceeCCoommmmaanndd ((class lliissttSSoouurrcceeCCoommmmaanndd))
              The commmand to list all source files on the remote
              host.  The string `@@MMAASSKK@@' is replaced  by  a  file
              filter.  The default setting is:

                DDdddd**lliissttSSoouurrcceeCCoommmmaanndd:: \\
                ffiillee @@MMAASSKK@@ || ggrreepp ''..**::..**tteexxtt..**'' \\
                || ccuutt --dd:: --ff11


       pprriinnttCCoommmmaanndd ((class PPrriinnttCCoommmmaanndd))
              The  command  to  print a postscript file.  Usually
              `llpp' or `llpprr'.

       rrsshhCCoommmmaanndd ((class RRsshhCCoommmmaanndd))
              The remote shell command to invoke  tty-based  com-
              mands on remote hosts.  Usually, `rreemmsshh', `rrsshh', or
              `oonn'.

       tteerrmmCCoommmmaanndd ((class TTeerrmmCCoommmmaanndd))
              The command to invoke a separate  tty  for  showing
              the input/output of the debugged program.  A bourne
              shell  command  to  run  in  the  separate  tty  is
              appended this string.  A simple value is

                DDdddd**tteerrmmCCoommmmaanndd:: xxtteerrmm --ee //bbiinn//sshh --cc

       tteerrmmTTyyppee ((class TTeerrmmTTyyppee))
              The  terminal  type  provided  by the `tteerrmmCCoommmmaanndd'
              resource--that is, the value of the  TTEERRMM  environ-
              ment variable to be passed to the debugged program.
              Default: `xxtteerrmm'.

       wwwwwwCCoommmmaanndd ((class WWWWWWCCoommmmaanndd))
              The command to invoke a WWW  browser.   The  string
              `@@UURRLL@@' is replaced by the URL to open.  Default is
              to try a running Netscape first, then to  invoke  a
              new  Netscape  process, then to let a running Emacs
              do the job, then to invoke Mosaic, then  to  invoke
              Lynx.

              To  specify `nneettssccaappee--44..00' as browser, use the set-
              ting:



DDD 2.1.1                   1 Jun 1997                         47





ddd(1)                                                     ddd(1)


                DDdddd**wwwwwwCCoommmmaanndd:: \\
                nneettssccaappee--44..00 --rreemmoottee ''ooppeennUURRLL((@@UURRLL@@))'' \\
                |||| nneettssccaappee--44..00 ''@@UURRLL@@''

              This command first tries to connect  to  a  running
              nneettssccaappee--33..00  browser;  if  this fails, it starts a
              new nneettssccaappee--33..00 process.

       wwwwwwPPaaggee ((class WWWWWWPPaaggee))
              The DDD WWW page.  Value:

                DDdddd**wwwwwwPPaaggee:: hhttttpp::////wwwwww..ccss..ttuu--bbss..ddee//ssoofftteecchh//dddddd//


   OObbttaaiinniinngg DDiiaaggnnoossttiiccss
       The following resources are used for debugging DDD and  to
       obtain specific DDD information.

       aappppDDeeffaauullttssVVeerrssiioonn ((class VVeerrssiioonn))
              The  version of the DDD app-defaults file.  If this
              string does not match the version  of  the  current
              DDD executable, DDD issues a warning.

       cchheecckkCCoonnffiigguurraattiioonn ((class CChheecckkCCoonnffiigguurraattiioonn))
              If  true, check the DDD environment (in particular,
              the X configuration), report any  possible  problem
              causes      and     exit.      See     also     the
              `----cchheecckk--ccoonnffiigguurraattiioonn' option, below.

       ddddddiinniittVVeerrssiioonn ((class VVeerrssiioonn))
              The version of the DDD executable that  last  wrote
              the `$$HHOOMMEE//..ddddddiinniitt' file.  If this string does not
              match the version of the  current  DDD  executable,
              DDD issues a warning.

       sshhoowwCCoonnffiigguurraattiioonn ((class SShhoowwCCoonnffiigguurraattiioonn))
              If  `ttrruuee',  show the DDD configuration on standard
              output and exit.  See  also  the  `----ccoonnffiigguurraattiioonn'
              option, below.

       sshhoowwIInnvvooccaattiioonn ((class SShhoowwIInnvvooccaattiioonn))
              If `ttrruuee', show the DDD invocation options on stan-
              dard  output  and  exit.   See  also  the  `----hheellpp'
              option, below.

       sshhoowwLLiicceennssee ((class SShhoowwLLiicceennssee))
              If  `ttrruuee', show the DDD license on standard output
              and exit.  See also the `----lliicceennssee' option,  below.

       sshhoowwMMaannuuaall ((class SShhoowwMMaannuuaall))
              If  `ttrruuee',  show  this DDD manual page on standard
              output and exit.  If the standard output is a  ter-
              minal, the manual page is shown in a pager ($$PPAAGGEERR,
              `lleessss' or `mmoorree').  See also the `----mmaannuuaall' option,



DDD 2.1.1                   1 Jun 1997                         48





ddd(1)                                                     ddd(1)


              below.

       sshhoowwVVeerrssiioonn ((class SShhoowwVVeerrssiioonn))
              If  `ttrruuee', show the DDD version on standard output
              and exit.  See also the `----vveerrssiioonn' option,  below.

       ttrraacceeDDiiaalloogg ((class TTrraaccee))
              If  `ttrruuee',  show  the  dialog  between DDD and the
              inferior debugger on standard output.   Default  is
              `ffaallssee'.

       ttrraacceeSShheellllCCoommmmaannddss ((class TTrraaccee))
              If  `ttrruuee',  show  the  programs  invoked by DDD on
              standard output.  Default is `ffaallssee'.

   MMoorree RReessoouurrcceess
       The `DDdddd' application defaults  file  contains  even  more
       information  about  setting DDD resources.  The `DDdddd' file
       comes with the DDD distribution.

AACCTTIIOONNSS
       The following DDD  actions  may  be  used  in  translation
       tables.

   GGeenneerraall AAccttiioonnss
       These actions are used to assign the keyboard focus.

       dddddd--nneexxtt--ttaabb--ggrroouupp (())
              Assign focus to the next tab group.

       dddddd--pprreevv--ttaabb--ggrroouupp (())
              Assign focus to the previous tab group.

       dddddd--pprreevviioouuss--ttaabb--ggrroouupp (())
              Assign focus to the previous tab group.

       dddddd--ggeett--ffooccuuss (())
              Assign  focus  to  the  element  that just received
              input.

   DDaattaa DDiissppllaayy AAccttiioonnss
       These actions are used in the DDD graph editor.

       eenndd (()) End the action initiated by  sseelleecctt.   Bound  to  a
              button up event.

       eexxtteenndd (())
              Extend  the  current  selection.  Bound to a button
              down event.

       eexxtteenndd--oorr--mmoovvee (())
              Extend the current selection.  Bound  to  a  button
              down  event.   If  the pointer is dragged, move the
              selection.



DDD 2.1.1                   1 Jun 1997                         49





ddd(1)                                                     ddd(1)


       ffoollllooww (())
              Continue the action initiated by sseelleecctt.  Bound  to
              a pointer motion event.

       hhiiddee--eeddggeess (([aannyy|bbootthh|ffrroomm|ttoo]))
              Hide  some  edges.   aannyy means to process all edges
              where either source or target  node  are  selected.
              bbootthh  means  to  process all edges where both nodes
              are selected. ffrroomm means to process all edges where
              at  least  the source node is selected. ttoo means to
              process all edges where at least the target node is
              selected.  Default is aannyy.

       llaayyoouutt (([rreegguullaarr|ccoommppaacctt],, [[++|--]_d_e_g_r_e_e_s]]))
              Layout the graph.  rreegguullaarr means to use the regular
              layout algorithm; ccoommppaacctt uses an alternate  layout
              algorithm,  where  successors  are  placed  next to
              their parents.  Default is rreegguullaarr.  _d_e_g_r_e_e_s  indi-
              cates  in  which direction the graph should be lay-
              outed.  Default is the current graph direction.

       mmoovvee--sseelleecctteedd ((_x_-_o_f_f_s_e_t,, _y_-_o_f_f_s_e_t))
              Move all selected nodes in the direction  given  by
              _x_-_o_f_f_s_e_t  and  _y_-_o_f_f_s_e_t.   _x_-_o_f_f_s_e_t and _y_-_o_f_f_s_e_t is
              either given  as  a  numeric  pixel  value,  or  as
              `++ggrriidd', or `--ggrriidd', meaning the current grid size.

       nnoorrmmaalliizzee (())
              Place all nodes on their positions and  redraw  the
              graph.

       rroottaattee (([[++|--]_d_e_g_r_e_e_s]))
              Rotate  the  graph around _d_e_g_r_e_e_s degrees.  _d_e_g_r_e_e_s
              must be a multiple of 90.  Default is ++9900.

       sseelleecctt (())
              Select the node pointed at.  Clear all other selec-
              tions.  Bound to a button down event.

       sseelleecctt--aallll (())
              Select all nodes in the graph.

       sseelleecctt--ffiirrsstt (())
              Select the first node in the graph.

       sseelleecctt--nneexxtt (())
              Select the next node in the graph.

       sseelleecctt--oorr--mmoovvee (())
              Select the node pointed at.  Clear all other selec-
              tions.  Bound  to  a  button  down  event.  If  the
              pointer is dragged, move the selected node.





DDD 2.1.1                   1 Jun 1997                         50





ddd(1)                                                     ddd(1)


       sseelleecctt--pprreevv (())
              Select the previous node in the graph.

       sshhooww--eeddggeess (([aannyy|bbootthh|ffrroomm|ttoo]))
              Show  some  edges.   aannyy means to process all edges
              where either source or target  node  are  selected.
              bbootthh  means  to  process all edges where both nodes
              are selected. ffrroomm means to process all edges where
              at  least  the source node is selected. ttoo means to
              process all edges where at least the target node is
              selected.  Default is aannyy.

       ssnnaapp--ttoo--ggrriidd (())
              Place all nodes on the nearest grid position.

       ttooggggllee (())
              Toggle  the  current selection--if the node pointed
              at is selected, it will  be  unselected,  and  vice
              versa.  Bound to a button down event.

       ttooggggllee--oorr--mmoovvee (())
              Toggle  the  current selection--if the node pointed
              at is selected, it will  be  unselected,  and  vice
              versa.   Bound  to  a  button  down  event.  If the
              pointer is dragged, move the selection.

       uunnsseelleecctt--aallll (())
              Clear the selection.

   DDeebbuuggggeerr CCoonnssoollee AAccttiioonnss
       These actions are used in the debugger console  and  other
       text fields.

       ggddbb--bbaacckkwwaarrdd--cchhaarraacctteerr (())
              Move  one  character  to the left.  Bound to CCttrrll++BB
              and LLeefftt.

       ggddbb--bbeeggiinnnniinngg--ooff--lliinnee (())
              Move cursor to the beginning of the  current  line,
              after the prompt.  Bound to CCttrrll++AA and HHoommee.

       ggddbb--ccoonnttrrooll ((_c_o_n_t_r_o_l_-_c_h_a_r_a_c_t_e_r))
              Send  the  given  _c_o_n_t_r_o_l_-_c_h_a_r_a_c_t_e_r to the inferior
              debugger.  The _c_o_n_t_r_o_l_-_c_h_a_r_a_c_t_e_r must be  specified
              in  the  form `^^_X', where _X is an upper-case letter
              or `??'.  Bound to CCttrrll++CC and CCttrrll++\\.

       ggddbb--ccoommpplleettee--aarrgg ((_c_o_m_m_a_n_d))
              Complete  current  argument  as  if   _c_o_m_m_a_n_d   was
              prepended.  Bound to CCttrrll++TT.

       ggddbb--ccoommpplleettee--ccoommmmaanndd (())
              Complete  current command line in the debugger con-
              sole.  Bound to TTAABB and CCttrrll++TT.



DDD 2.1.1                   1 Jun 1997                         51





ddd(1)                                                     ddd(1)


       ggddbb--ccoommpplleettee--ttaabb ((_c_o_m_m_a_n_d))
              If global TAB completion is enabled, complete  cur-
              rent  argument as if _c_o_m_m_a_n_d was prepended.  Other-
              wise, proceed as if the TAB key was hit.  Bound  to
              TTAABB.

       ggddbb--ddeelleettee--oorr--ccoonnttrrooll ((_c_o_n_t_r_o_l_-_c_h_a_r_a_c_t_e_r))
              Like  ggddbb--ccoonnttrrooll, but effective only if the cursor
              is at the  end  of  a  line.   Otherwise,  _c_o_n_t_r_o_l_-
              _c_h_a_r_a_c_t_e_r  is  ignored  and the character following
              the cursor is deleted.  Bound to CCttrrll++DD.

       ggddbb--eenndd--ooff--lliinnee (())
              Move cursor to the end of the current line.   Bound
              to CCttrrll++EE and EEnndd.

       ggddbb--nneexxtt--hhiissttoorryy (())
              Recall  next command from history.  Bound to CCttrrll++NN
              and DDoowwnn.

       ggddbb--pprreevv--hhiissttoorryy (())
              Recall previous command  from  history.   Bound  to
              CCttrrll++PP and UUpp.

       ggddbb--pprreevviioouuss--hhiissttoorryy (())
              Recall  previous  command  from  history.  Bound to
              CCttrrll++PP and UUpp.

       ggddbb--ffoorrwwaarrdd--cchhaarraacctteerr (())
              Move one character to the right.  Bound  to  CCttrrll++FF
              and RRiigghhtt.

       ggddbb--iinnsseerrtt--ggrraapphh--aarrgg (())
              Insert  the  contents  of the data display argument
              field `(())'.

       ggddbb--iinnsseerrtt--ssoouurrccee--aarrgg (())
              Insert the contents of the  source  argument  field
              `(())'.

       ggddbb--iisseeaarrcchh--pprreevv (())
              Enter  reverse  incremental  search mode.  Bound to
              CCttrrll++RR.

       ggddbb--iisseeaarrcchh--nneexxtt (())
              Enter incremental search mode.  Bound to CCttrrll++SS.

       ggddbb--iisseeaarrcchh--eexxiitt (())
              Exit incremental search mode.  Bound to EESSCC.

       ggddbb--sseett--lliinnee ((_v_a_l_u_e))
              Set the current line to _v_a_l_u_e.  Bound to CCttrrll++UU.





DDD 2.1.1                   1 Jun 1997                         52





ddd(1)                                                     ddd(1)


OOPPTTIIOONNSS
       You can use the following options when starting DDD.   All
       options  may be abbreviated, as long as they are unambigu-
       ous; single dashes may also be used.  DDD also understands
       the usual X options such as `--ddiissppllaayy' or `--ggeeoommeettrryy'; see
       XX((11)) for details.

       All other arguments and options are passed to the inferior
       debugger.  To pass an option to the inferior debugger that
       conflicts with an X option, or with a  DDD  option  listed
       here, use the `----ddeebbuuggggeerr' option, below.


       ----aattttaacchh--wwiinnddoowwss
              Attach  the source and data windows to the debugger
              console, creating one single big DDD window.   This
              is the default setting.

       ----aattttaacchh--ssoouurrccee--wwiinnddooww
              Attaches  only  the  source  window to the debugger
              console.

       ----aattttaacchh--ddaattaa--wwiinnddooww
              Attaches only the source  window  to  the  debugger
              console.

       ----bbuuttttoonn--ttiippss
              Enable button tips.

       ----ccoonnffiigguurraattiioonn
              Show the DDD configuration settings and exit.

       ----cchheecckk--ccoonnffiigguurraattiioonn
              Check  the  DDD  environment  (in particular, the X
              configuration), report any possible problem  causes
              and exit.

       ----ddbbxx  Run the DBX debugger as inferior debugger.

       ----ddeebbuuggggeerr _n_a_m_e
              Invoke  the inferior debugger _n_a_m_e.  This is useful
              if you have several debugger versions around, or if
              the  inferior  debugger cannot be invoked as `ggddbb',
              `ddbbxx', or `xxddbb',  respectively.   This  option  can
              also be used to pass options to the inferior debug-
              ger that would otherwise conflict with DDD options.
              For  instance,  to  pass a `--dd _d_i_r_e_c_t_o_r_y' option to
              XDB, use:

                dddddd ----ddeebbuuggggeerr ""xxddbb --dd _d_i_r_e_c_t_o_r_y""


       ----ddiissaasssseemmbbllee
              Disassemble  the  source  code.    See   also   the



DDD 2.1.1                   1 Jun 1997                         53





ddd(1)                                                     ddd(1)


              `----nnoo--ddiissaasssseemmbbllee' option, below.

       ----eexxeecc--wwiinnddooww
              Run  the  debugged  program  in a specially created
              execution window.  This is useful for programs that
              have  special terminal requirements not provided by
              the debugger window, as raw keyboard processing  or
              terminal control sequences.

       ----ffuullllnnaammee
              Enable  TTY  interface,  taking additional debugger
              commands from standard input and forwarding  debug-
              ger  output  on standard output.  Current positions
              are issued in GDB `--ffuullllnnaammee' format  suitable  for
              debugger front-ends.

       ----ggddbb  Run the GDB debugger as inferior debugger.

       ----ggllyypphhss
              Display  the  current execution position and break-
              points  as  glyphs.   See  also  the  `----nnoo--ggllyypphhss'
              option, below.

       ----hheellpp Give  a  list  of  frequently  used  options.  Show
              options of the inferior debugger as well.

       ----hhoosstt _h_o_s_t_n_a_m_e
              Invoke the inferior debugger directly on the remote
              host _h_o_s_t_n_a_m_e.  See `RREEMMOOTTEE DDEEBBUUGGGGIINNGG', above.

       ----lleessssttiiff--hhaacckkss
              Enable  some  hacks  to  make DDD run properly with
              LessTif.  See  also  the  `lleessssTTiiffHHaacckkss'  resource,
              above.

       ----lliicceennssee
              Show the DDD license and exit.

       ----llooggiinn _u_s_e_r_n_a_m_e
              Use  _u_s_e_r_n_a_m_e  as  remote  user  name.  See `RREEMMOOTTEE
              DDEEBBUUGGGGIINNGG', above.

       ----mmaannuuaall
              Show this manual page and exit.

       ----nnoo--bbuuttttoonn--ttiippss
              Disable button tips.

       ----nnoo--ddaattaa--wwiinnddooww
              Do not create the data window upon start-up.

       ----nnoo--ddeebbuuggggeerr--ccoonnssoollee
              Do not create the debugger console upon start-up.




DDD 2.1.1                   1 Jun 1997                         54





ddd(1)                                                     ddd(1)


       ----nnoo--ddiissaasssseemmbbllee
              Do not disassemble the source code.

       ----nnoo--eexxeecc--wwiinnddooww
              Do not run the debugged program in a specially cre-
              ated  execution  window;  use  the debugger console
              instead.  Useful for programs that have little ter-
              minal input/output, or for remote debugging.

       ----nnoo--ggllyypphhss
              Display  the  current execution position and break-
              points as text characters.  Do not use glyphs.

       ----nnoo--lleessssttiiff--hhaacckkss
              Disable hacks to make DDD run properly  with  Less-
              Tif.   See also the `lleessssTTiiffHHaacckkss' resource, above.

       ----nnoo--ssoouurrccee--wwiinnddooww
              Do not create the source window upon start-up.

       ----nnoo--vvaalluuee--ttiippss
              Disable value tips.

       ----nnww   Do not use the X window interface.  Start the infe-
              rior debugger on the local host.

       ----ppaannnneedd--ggrraapphh--eeddiittoorr
              Use  an  Athena  panner  to scroll the data window.
              Most people prefer panners on  scroll  bars,  since
              panners  allow two-dimensional scrolling.  However,
              the panner is off  by  default,  since  some  Motif
              implementations  do  not work well with Athena wid-
              gets.  See also ----ssccrroolllleedd--ggrraapphh--eeddiittoorr, below.

       ----rrhhoosstt _h_o_s_t_n_a_m_e
              Run the  inferior  debugger  interactively  on  the
              remote  host  _h_o_s_t_n_a_m_e.   See  `RREEMMOOTTEE  DDEEBBUUGGGGIINNGG',
              above.

       ----sseeppaarraattee--wwiinnddoowwss
              Separate the console, source and data windows.  See
              also the `----aattttaacchh' options, above.

       ----ssccrroolllleedd--ggrraapphh--eeddiittoorr
              Use  Motif  scroll  bars to scroll the data window.
              This is the default  in  most  DDD  configurations.
              See also ----ppaannnneedd--ggrraapphh--eeddiittoorr, above.

       ----ssttaattuuss--aatt--bboottttoomm
              Place  the  status line at the bottom of the source
              window.

       ----ssttaattuuss--aatt--ttoopp
              Place the status line at  the  top  of  the  source



DDD 2.1.1                   1 Jun 1997                         55





ddd(1)                                                     ddd(1)


              window.

       ----ssyynncc--ddeebbuuggggeerr
              Do not process X events while the debugger is busy.
              This may result in slightly better  performance  on
              single-processor systems.

       ----ttrraaccee--ddiiaalloogg
              Show  the  interaction between DDD and the inferior
              debugger on standard error.   This  is  useful  for
              debugging DDD.

       ----ttrraaccee--sshheellll--ccoommmmaannddss
              Show  the  shell commands issued by DDD on standard
              error.  This is useful for debugging DDD.

       ----ttrraaccee
              Show both interaction and shell commands.

       ----ttttyy  Enable TTY interface,  taking  additional  debugger
              commands  from standard input and forwarding debug-
              ger output on standard output.   Current  positions
              are issued in a format readable for humans.

       ----vvaalluuee--ttiippss
              Enable value tips.

       ----vveerrssiioonn
              Show the DDD version and exit.

       ----vvssll--lliibbrraarryy _l_i_b_r_a_r_y
              Load  the  VSL library _l_i_b_r_a_r_y instead of using the
              DDD built-in library.  This is useful for customiz-
              ing display shapes and fonts.

       ----vvssll--ppaatthh _p_a_t_h
              Search  VSL  libraries  in  _p_a_t_h (a colon-separated
              directory list).

       ----vvssll--hheellpp
              Show a list of further options controlling the  VSL
              interpreter.  These options are intended for debug-
              ging purposes and are  subject  to  change  without
              further notice.

       ----xxddbb  Run XDB as inferior debugger.

FFIILLEESS
       $$HHOOMMEE//..ddddddiinniitt      Individual  DDD  resource  file.   DDD
                           options are saved here.
       $$HHOOMMEE//..dddddd__hhiissttoorryy  Default DDD command history file.
       $$HHOOMMEE//..ggddbbiinniitt      GDB initialization file.
       $$HHOOMMEE//..ddbbxxiinniitt      DBX initialization file.
       $$HHOOMMEE//..ddbbxxrrcc        Alternate DBX initialization file.



DDD 2.1.1                   1 Jun 1997                         56





ddd(1)                                                     ddd(1)


       $$HHOOMMEE//..xxddbbrrcc        XDB initialization file.

SSEEEE AALLSSOO
       XX(1), ggddbb(1), ddbbxx(1), xxddbb(1), rreemmsshh(1), rrsshh(1)

       `ggddbb' entry in iinnffoo

       _U_s_i_n_g _G_D_B_: _A _G_u_i_d_e _t_o _t_h_e _G_N_U  _S_o_u_r_c_e_-_L_e_v_e_l  _D_e_b_u_g_g_e_r,  by
       Richard M. Stallman and Roland H. Pesch.

       _D_D_D_-_-_A  _F_r_e_e  _G_r_a_p_h_i_c_a_l  _F_r_o_n_t_-_E_n_d  _f_o_r _U_N_I_X _D_e_b_u_g_g_e_r_s, by
       Andreas Zeller and Dorothea  L"utkehaus,  Computer  Science
       Report 95-07, Technische Universit"at Braunschweig, 1995.

       _D_D_D  _-  _e_i_n  _D_e_b_u_g_g_e_r _m_i_t _g_r_a_p_h_i_s_c_h_e_r _D_a_t_e_n_d_a_r_s_t_e_l_l_u_n_g, by
       Dorothea L"utkehaus, Diploma Thesis, Technische Universit"at
       Braunschweig, 1994.

       The DDD _F_T_P _s_i_t_e_,

         ffttpp::////ffttpp..iippss..ccss..ttuu--bbss..ddee//ppuubb//llooccaall//ssoofftteecchh//dddddd//


       The DDD _W_W_W _p_a_g_e_,

         hhttttpp::////wwwwww..ccss..ttuu--bbss..ddee//ssoofftteecchh//dddddd//


       The DDD _M_a_i_l_i_n_g _L_i_s_t_,

          dddddd--uusseerrss@@iippss..ccss..ttuu--bbss..ddee

       For more information on this list, send a mail to

          dddddd--uusseerrss--rreeqquueesstt@@iippss..ccss..ttuu--bbss..ddee .



LLIIMMIITTAATTIIOONNSS
   LLiimmiittaattiioonnss uussiinngg GGDDBB
       Some GDB settings are essential for DDD to work correctly.
       These settings with their correct values are:

         sseett hheeiigghhtt 00
         sseett wwiiddtthh 00
         sseett pprriinntt rreeppeeaattss 00
         sseett vveerrbboossee ooffff
         sseett pprroommpptt ((ggddbb))

       DDD sets these values automatically when invoking GDB.

       If these values are changed, there may  be  some  malfunc-
       tions,  especially  in  the  data display.  If you want to
       display C strings (i.e., `cchhaarr  **'-fields),  it  might  be



DDD 2.1.1                   1 Jun 1997                         57





ddd(1)                                                     ddd(1)


       useful  to  change  the  settings  of  `pprriinntt rreeppeeaattss' and
       `pprriinntt eelleemmeennttss'.  But to recognize array structures  cor-
       rectly,  you  should have `pprriinntt rreeppeeaattss' set to 0.  Also,
       do not change the setting of `pprriinntt eelleemmeennttss' while  there
       are array structures in the data display.

       When debugging at the machine level with GDB 4.12 and ear-
       lier as inferior debugger, use a `ddiissppllaayy //xx $$ppcc'  command
       to  ensure  the program counter value is updated correctly
       at  each  stop.   You  may  also  enter  the  command   in
       $$HHOOMMEE//..ggddbbiinniitt  or (better yet) upgrade to the most recent
       GDB version.


   LLiimmiittaattiioonnss uussiinngg DDBBXX
       When used for debugging Modula-2 or Pascal  programs,  DDD
       always   numerates  array  elements  starting  with  zero,
       instead of using correct array subscripts.

       With some DBX versions (notably Solaris DBX),  DDD  strips
       C-style  and  C++-style  comments  from  the DBX output in
       order to interpret it properly.   This  also  affects  the
       output  of  the debugged program when sent to the debugger
       console.  Using the separate execution window avoids these
       problems.

       In  some DBX versions (notably DEC DBX and AIX DBX), there
       is no automatic data display.  As an alternative, DDD uses
       the  `pprriinntt'  command  to  access data values.  This means
       that variable names are interpreted according to the  cur-
       rent  frame; variables outside the current frame cannot be
       displayed.

   LLiimmiittaattiioonnss uussiinngg XXDDBB
       There  is  no  automatic  data  display  in  XDB.   As   a
       workaround,  DDD  uses the `pp' command to access data val-
       ues.  This  means  that  variable  names  are  interpreted
       according to the current frame; variables outside the cur-
       rent frame cannot be displayed.

   GGeenneerraall LLiimmiittaattiioonnss
       If command output is sent to the debugger console,  it  is
       impossible  for  DDD  to distinguish between the output of
       the debugged program and the output of the inferior debug-
       ger.  For instance, if your program output includes debug-
       ger prompts  or  debugger-like  output,  DDD  will  likely
       become confused.  To avoid such problems, use the separate
       execution window.

       If the inferior debugger changes the default TTY settings,
       for  instance  through a `ssttttyy' command in its initializa-
       tion file, DDD will  likely  become  confused.   The  same
       applies  to debugged programs which change the default TTY
       settings.



DDD 2.1.1                   1 Jun 1997                         58





ddd(1)                                                     ddd(1)


RREEPPOORRTTIINNGG BBUUGGSS
       If you find a bug in DDD, please send us a bug report.  We
       will  either  attempt  to  fix the bug--or include the bug
       description in the DDD `BBUUGGSS' file, such that  others  can
       attempt  to  fix it.  (Instead of sending bug reports, you
       may also send _f_i_x_e_s; DDD is an excellent tool  for  debug-
       ging itself :-)

   WWhheerree ttoo SSeenndd BBuugg RReeppoorrttss
       We  recommend  that you send bug reports for DDD via elec-
       tronic mail to

         dddddd--bbuuggss@@iippss..ccss..ttuu--bbss..ddee

       As a last resort, send bug reports on paper to:

         Technische Universit"at Braunschweig
         Institut f"ur Programmiersprachen
         und Informationssysteme
         Abteilung Softwaretechnologie
         DDD-Bugs
         B"ultenweg 88
         D-38092 Braunschweig
         GERMANY

   IIss iitt aa DDDDDD BBuugg??
       Before sending in a bug report, try to  find  out  whether
       the  problem cause really lies within DDD.  A common cause
       of problems are incomplete or missing X or Motif installa-
       tions,  for  instance,  or  bugs  in the X server or Motif
       itself.  Running DDD as

         dddddd ----cchheecckk--ccoonnffiigguurraattiioonn

       checks for common problems  and  gives  hints  on  how  to
       repair them.

       Another potential cause of problems is the inferior debug-
       ger; occasionally, they  show  bugs,  too.   To  find  out
       whether a bug was caused by the inferior debugger, run DDD
       as

         dddddd ----ttrraaccee

       This shows the dialog between DDD and the inferior  debug-
       ger  on  standard error while DDD is running.  Compare the
       debugger output to the output of DDD and  determine  which
       one is wrong.

   HHooww ttoo RReeppoorrtt BBuuggss
       Here are some guidelines for bug reports:

       +o The  fundamental principle of reporting bugs usefully is
         this: _r_e_p_o_r_t _a_l_l _t_h_e _f_a_c_t_s.  If you are not sure whether



DDD 2.1.1                   1 Jun 1997                         59





ddd(1)                                                     ddd(1)


         to state a fact or leave it out, state it!

       +o Keep  in  mind  that  the  purpose of a bug report is to
         enable someone to fix the bug if it is not known.  It is
         not  very  important  what happens if the bug is already
         known.  Therefore, always write your bug reports on  the
         assumption that the bug is not known.

       +o Your  bug report should be self-contained.  Do not refer
         to information sent in  previous  mails;  your  previous
         mail may have been forwarded to somebody else.

       +o Please  report  each  bug  in  a separate message.  This
         makes it easier for us to track  which  bugs  have  been
         fixed  and to forward your bugs reports to the appropri-
         ate maintainer.

       +o Please  report  bugs  in  English;  this  increases  the
         chances  of finding someone who can fix the bug.  Do not
         assume one  particular  person  will  receive  your  bug
         report.


   WWhhaatt ttoo IInncclluuddee iinn aa BBuugg RReeppoorrtt
       To  enable  us to fix a DDD bug, you _m_u_s_t include the fol-
       lowing information:

       +o Your DDD configuration.  Invoke DDD as

           dddddd ----ccoonnffiigguurraattiioonn

         to get the configuration information.  If this does  not
         work,  please include at least the DDD version, the type
         of machine you are using, and its operating system  name
         and version number.

       +o The  debugger  you  are  using  and  its  version (e.g.,
         `ggddbb--44..1166' or `ddbbxx aass sshhiippppeedd wwiitthh SSoollaarriiss 22..55').

       +o The compiler you used to compile  DDD  and  its  version
         (e.g., `ggcccc--22..88..00').

       +o A  description  of  what  behavior  you observe that you
         believe is incorrect.  For example, "DDD  gets  a  fatal
         signal"  or  "DDD  exits immediately after attempting to
         create the data window".

       +o If possible, include a _d_i_a_l_o_g _t_r_a_c_e showing the interac-
         tion between DDD and the inferior debugger.  Such a dia-
         log trace is created by invoking DDD with the  `----ttrraaccee'
         option.   Include  all trace output from the DDD invoca-
         tion up to the first bug occurrence.

       +o If you wish to suggest changes to the DDD  source,  send



DDD 2.1.1                   1 Jun 1997                         60





ddd(1)                                                     ddd(1)


         us  context diffs.  If you even discuss something in the
         DDD source, refer to it by context, _n_e_v_e_r by  line  num-
         ber.

       Be  sure  to  include this information in _e_v_e_r_y single bug
       report.

HHIISSTTOORRYY
       The history of DDD is a story of code recycling.  The old-
       est parts of DDD were written in 1990, when _A_n_d_r_e_a_s _Z_e_l_l_e_r
       designed VSL, a box-based visual  structure  language  for
       visualizing  data  and program structures.  The VSL inter-
       preter and the BOX library became part of Andreas' Diploma
       Thesis, a graphical syntax editor based on the Programming
       System Generator PSG.

       In 1992, the VSL and Box libraries were recycled  for  the
       NORA  project.   For NORA, an experimental inference-based
       software development tool set, Andreas wrote a graph  edi-
       tor  (based  on  VSL and the BOX libraries) and facilities
       for inter-process  knowledge  exchange.   Based  on  these
       tools, _D_o_r_o_t_h_e_a _L_"_u_t_k_e_h_a_u_s realized DDD as her Diploma The-
       sis, 1994.

       The original DDD had no source window; this was  added  by
       Dorothea  during  the  winter  of 1994/1995.  In the first
       quarter of 1995, finally, Andreas completed DDD by  adding
       command  and  execution  windows,  extensions  for DBX and
       remote debugging as well as configuration support for sev-
       eral  architectures.   Since  then,  many people have con-
       tributed to the success of DDD; see  the  file  `CCOONNTTRRIIBBUU--
       TTOORRSS' in the DDD distribution for details.

       Major DDD events:
       April, 1995         DDD 0.9: First DDD beta release
       May, 1995           DDD 1.0: First public DDD release
       December, 1995      DDD   1.4:   Machine-level  debugging,
                           glyphs, EMACS integration
       October, 1996       DDD 2.0: Color displays, XDB  support,
                           generic DBX support, command tool.
       May, 1997           DDD 2.1: Alias detection, button tips,
                           status displays.

EEXXTTEENNDDIINNGG DDDDDD
       If you have any contributions to be incorporated into DDD,
       please  send  them  to `dddddd@@iippss..ccss..ttuu--bbss..ddee'.  For sugges-
       tions on what might be done, see the file  `TTOODDOO'  in  the
       DDD distribution.

IIFF YYOOUU LLIIKKEE DDDDDD......
       If  you appreciate this software, or have any suggestions,
       please send us a picture postcard.  Our address is:

         Technische Universit"at Braunschweig



DDD 2.1.1                   1 Jun 1997                         61





ddd(1)                                                     ddd(1)


         Institut f"ur Programmiersprachen
         und Informationssysteme
         Abteilung Softwaretechnologie
         B"ultenweg 88
         D-38092 Braunschweig
         GERMANY

       You may also leave a message in the _D_D_D _G_u_e_s_t_b_o_o_k_.  It  is
       accessible via our DDD WWW page,

         hhttttpp::////wwwwww..ccss..ttuu--bbss..ddee//ssoofftteecchh//dddddd// .


PPRRIINNTTIINNGG TTHHIISS MMAANNUUAALL
       Invoke  DDD with the `----mmaannuuaall' option to show this manual
       page on standard output.  This text output is suitable for
       installation     as     formatted    manual    page    (as
       `//uussrr//llooccaall//mmaann//ccaatt11//dddddd..11' or similar) on UNIX systems.

       A PostScript copy of this manual page,  including  several
       DDD  screen  shots  and  diagrams,  is included in the DDD
       source   distribution   and   available   separately    as
       `dddddd..mmaann..ppss..ggzz' in

         ffttpp::////ffttpp..iippss..ccss..ttuu--bbss..ddee//ppuubb//llooccaall//ssoofftteecchh//dddddd//ddoocc//

       This  directory  also contains other documentation related
       to DDD.

       A ROFF copy of this manual page, suitable for installation
       as     manual     page     on     UNIX     systems     (as
       `//uussrr//llooccaall//mmaann//mmaann11//dddddd..11' or similar),  is  included  in
       the DDD source distribution.



CCOOPPYYRRIIGGHHTT
       DDD   is   Copyright   (C)  1995,  1996,  1997  Technische
       Universit"at Braunschweig, Germany.

       DDD is free software; you can redistribute it and/or  mod-
       ify  it  under the terms of the GNU General Public License
       as published by the Free Software Foundation; either  ver-
       sion  2 of the License, or (at your option) any later ver-
       sion.

       DDD is distributed in the hope that it will be useful, but
       _w_i_t_h_o_u_t _a_n_y _w_a_r_r_a_n_t_y; without even the implied warranty of
       _m_e_r_c_h_a_n_t_a_b_i_l_i_t_y or _f_i_t_n_e_s_s _f_o_r _a _p_a_r_t_i_c_u_l_a_r _p_u_r_p_o_s_e.   See
       the License for more details.

       You  should have received a copy of the License along with
       DDD.  If not, invoke DDD with the `----lliicceennssee' option; this
       will print a copy on standard output.  To read the License



DDD 2.1.1                   1 Jun 1997                         62





ddd(1)                                                     ddd(1)


       from within DDD, use the  `DDDDDD  LLiicceennssee......'  item  in  the
       `HHeellpp' menu.

       This  DDD  manual  page  is Copyright (C) 1995, 1996, 1997
       Technische Universit"at Braunschweig, Germany.

       Permission is granted  to  make  and  distribute  verbatim
       copies  of  this manual page provided the copyright notice
       and this permission notice are preserved on all copies.

       Permission is granted to copy and distribute modified ver-
       sions  of this manual page under the conditions for verba-
       tim copying, provided that the  entire  resulting  derived
       work is distributed under the terms of a permission notice
       identical to this one.

       Permission is granted to copy and distribute  translations
       of this manual page into another language, under the above
       conditions for modified versions, except that this permis-
       sion  notice  may  be included in translations approved by
       the Free Software Foundation instead of  in  the  original
       English.



































DDD 2.1.1                   1 Jun 1997                         63


