


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]
              [----sseessssiioonn _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]]
              [----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] [----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] [----nneewwss] [----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] [_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
       two, specifying an executable program as the argument:




DDD 2.2.3                   1998-01-26                          1





ddd(1)                                                     ddd(1)


         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 com-
         mands.  It is usually placed on the source window.




DDD 2.2.3                   1998-01-26                          2





ddd(1)                                                     ddd(1)


       +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.   Just
       press the `FF11' key and move 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 `EEnntteerriinngg CCoommmmaannddss', below, for  details  on  entering
       commands.

   AArree YYoouu SSttuucckk??
       In  case  you're  stuck, try `HHeellpp || WWhhaatt NNooww??' (the `WWhhaatt
       NNooww' item in the `HHeellpp' menu) or press SShhiifftt++FF11.   Depend-
       ing  on the current state, DDD will give you some hints on
       what you can do.

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



DDD 2.2.3                   1998-01-26                          3





ddd(1)                                                     ddd(1)


       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.


       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.   `CCoomm--
       mmaannddss || CCoommmmaanndd HHiissttoorryy' 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



DDD 2.2.3                   1998-01-26                          4





ddd(1)                                                     ddd(1)


       _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.


   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.



DDD 2.2.3                   1998-01-26                          5





ddd(1)                                                     ddd(1)


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

       SS      Execute next program line  (after  stopping);  step
              _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 `FFiillee || OOppeenn PPrroo--
       ggrraamm'.

       To  open  a core dump for the program, select `FFiillee || OOppeenn
       CCoorree DDuummpp' Before `OOppeenn CCoorree DDuummpp', you should  first  use
       `FFiillee  ||  OOppeenn PPrrooggrraamm' to specify the program that gener-
       ated the core dump and to load its symbol table.

       To open an arbitrary source  file,  select  `FFiillee  ||  OOppeenn
       SSoouurrccee'.   This  works  best  if  the given source file is
       actually related to the debugged program.

       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 _m_o_u_s_e _b_u_t_t_o_n _1 on the function or variable name.  The



DDD 2.2.3                   1998-01-26                          6





ddd(1)                                                     ddd(1)


       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 _m_o_u_s_e _b_u_t_-
       _t_o_n _3 on the function name and select  the  `LLooookkuupp'  item
       from the source popup menu.

       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 _m_o_u_s_e _b_u_t_t_o_n _1 on it.  The identifier 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  `SSoouurrccee  ||
       FFiinndd WWoorrddss OOnnllyy' option.

   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 locations.  The location found is underlined.


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 _m_o_u_s_e _b_u_t_t_o_n _1
       on the left of the source line and then on the  `BBrreeaakk  aatt
       (())' button.

       As  an alternative, you can simply press _m_o_u_s_e _b_u_t_t_o_n _3 on
       the left of the source line and  select  the  `SSeett  BBrreeaakk--
       p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 `SSoouurrccee || EEddiitt
       BBrreeaakkppooiinnttss'.  Click on the `NNeeww'  button  and  enter  the



DDD 2.2.3                   1998-01-26                          7





ddd(1)                                                     ddd(1)


       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.

       (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 _m_o_u_s_e _b_u_t_t_o_n _1
       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 _m_o_u_s_e _b_u_t_-
       _t_o_n _3 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 `SSssoouurrccee || EEddiitt
       BBrreeaakkppooiinnttss') 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:  Some  DBX  variants  do not support breakpoint dis-
       abling.

       To temporarily disable a breakpoint, press _m_o_u_s_e _b_u_t_t_o_n  _3
       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 `SSoouurrccee || EEddiitt BBrreeaakkppooiinnttss'.



DDD 2.2.3                   1998-01-26                          8





ddd(1)                                                     ddd(1)


       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.

       The  `DDiissaabbllee  BBrreeaakkppooiinntt' item is also accessible via the
       `CClleeaarr aatt (())' button.  Just press and hold _m_o_u_s_e _b_u_t_t_o_n  _1
       on the button to get a popup menu.

   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 _m_o_u_s_e
       _b_u_t_t_o_n  _3  on  the  left of the source line 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 left of the source line and
       immediately 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.

       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' and `CCoonnttiinnuuee  UUnnttiill  HHeerree'
       items  are  also  accessible via the `BBrreeaakk aatt (())' button.
       Just press and hold _m_o_u_s_e _b_u_t_t_o_n _1 on the button to get  a
       popup menu.

   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 _m_o_u_s_e _b_u_t_t_o_n _1 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 _m_o_u_s_e _b_u_t_t_o_n _1
       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 _m_o_u_s_e _b_u_t_-
       _t_o_n _3 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 `SSoouurrccee || EEddiitt BBrreeaakkppooiinnttss').

       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))'



DDD 2.2.3                   1998-01-26                          9





ddd(1)                                                     ddd(1)


       prompt for details.

   MMoovviinngg BBrreeaakkppooiinnttss
       To  move a breakpoint to a different location, press _m_o_u_s_e
       _b_u_t_t_o_n _1 on the stop sign and drag it to the desired loca-
       tion.   This  is  equivalent to deleting the breakpoint at
       the old location and setting a breakpoint at the new loca-
       tion.   The  new breakpoint inherits all properties of the
       old breakpoint, except the breakpoint number.

       Note: Dragging breakpoints is not possible when glyphs are
       disabled.  Delete and set breakpoints instead.

   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
       `SSoouurrccee || EEddiitt BBrreeaakkppooiinnttss || LLooookkuupp'.  After  selecting  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  `SSoouurrccee  ||
       EEddiitt BBrreeaakkppooiinnttss'), 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  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 condi-
       tion in a special dialog.


       As a faster alternative, you can also press _m_o_u_s_e _b_u_t_t_o_n _3
       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 `SSoouurrccee ||
       EEddiitt BBrreeaakkppooiinnttss'), 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 _m_o_u_s_e _b_u_t_t_o_n _3
       on  the  breakpoint in the source code and select the `SSeett



DDD 2.2.3                   1998-01-26                         10





ddd(1)                                                     ddd(1)


       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
   UUssiinngg tthhee CCoommmmaanndd TTooooll
       All functionality you need for running  and  stopping  the
       debugged program can be found on the command tool.

       The  command  tool  is  a small window containing the most
       frequently used commands.  It can be moved around  on  top
       of  the  DDD  windows,  but  it can also be placed besides
       them.  Whenever you save DDD state,  DDD  also  saves  the
       distance between command tool and source window, such that
       you can select your own individual command tool placement.
       In  case  you  want  to move the command tool to its saved
       position, use `VViieeww || CCoommmmaanndd TTooooll'.

       By default, the command tool _s_t_i_c_k_s to the DDD source win-
       dow:  Whenever you move the DDD source window, the command
       tool follows such that the distance between source  window
       and  command  tool remains the same.  By default, the com-
       mand tool also is _a_u_t_o_-_r_a_i_s_e_d, such that it stays  on  top
       of other DDD windows.


   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
       To  start  execution of the debugged program, select `PPrroo--
       ggrraamm || RRuunn'.  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
       `PPrrooggrraamm  ||  RRuunn  AAggaaiinn'  or press the `RRuunn' button on the
       command tool.  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 `PPrrooggrraamm || RRuunn  iinn  EExxeeccuu--
       ttiioonn WWiinnddooww' for details.

   AAttttaacchhiinngg ttoo aa RRuunnnniinngg PPrroocceessss
       If  the  debugged  program is already running in some pro-
       cess, you can _a_t_t_a_c_h to this process (instead of  starting
       a  new one with `RRuunn').  Select `FFiillee || AAttttaacchh ttoo PPrroocceessss'
       to choose from a list of processes.  Afterwards, press the



DDD 2.2.3                   1998-01-26                         11





ddd(1)                                                     ddd(1)


       `AAttttaacchh' button to attach to the specified process.


       The  first  thing  DDD  does  after arranging to debug the
       specified process is to stop it. You can examine and  mod-
       ify an attached process with all the DDD commands that are
       ordinarily available when you start processes with  `RRuunn'.
       You can insert breakpoints; you can step and continue; you
       can modify storage. If you would rather the  process  con-
       tinue  running, you may use `CCoonnttiinnuuee' after attaching DDD
       to the process.

       When using `AAttttaacchh ttoo PPrroocceessss', you should first use `OOppeenn
       PPrrooggrraamm' to specify the program running in the process and
       load its symbol table.

       When you have finished debugging the attached process, you
       can use the `FFiillee || DDeettaacchh PPrroocceessss' to release it from DDD
       control.  Detaching the process continues  its  execution.
       After  `DDeettaacchh  PPrroocceessss', that process and DDD become com-
       pletely independent once more, and you are ready to attach
       another process or start one with `RRuunn'.

       You  can  customize  the list of processes shown.  See the
       `ppssCCoommmmaanndd' resource for details.

   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 the `TTeemmppoorraarryy BBrreeaakkppooiinnttss'



DDD 2.2.3                   1998-01-26                         12





ddd(1)                                                     ddd(1)


       section, above, for a discussion.

   AAlltteerriinngg tthhee EExxeeccuuttiioonn PPoossiittiioonn
       To  resume  execution at a different location, press _m_o_u_s_e
       _b_u_t_t_o_n _1 on the arrow and drag it to a different location.
       The  most  common  occasion to use this feature is to back
       up--perhaps with more breakpoints set-over a portion of  a
       program that has already executed, in order to examine its
       execution in more detail.


       Moving the execution position does not change the  current
       stack  frame, or the stack pointer, or the contents of any
       memory location or any register  other  than  the  program
       counter.

       Some inferior debuggers (notably GDB) allow you to set the
       new execution position into a different function from  the
       one currently executing.  This may lead to bizarre results
       if the two functions expect different  patterns  of  argu-
       ments  or of local variables.  For this reason, moving the
       execution position requests confirmation if the  specified
       line is not in the function currently executing.

       After  moving  the  execution position, click on the `CCoonn--
       ttiinnuuee' button to resume execution.

       Note: Dragging the execution position is not possible when
       glyphs  are  disabled.   Use `SSeett EExxeeccuuttiioonn PPoossiittiioonn' from
       the breakpoint popup menu instead  to  set  the  execution
       position  to  the  current  location.   This  item is also
       accessible by pressing and holding the `BBrreeaakk aatt  (())/CClleeaarr
       aatt (())' button.

   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 `SSttaattuuss || BBaacckkttrraaccee'.

       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.






DDD 2.2.3                   1998-01-26                         13





ddd(1)                                                     ddd(1)


   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 differ from one operating system to  another,  but
       in  general  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  `SSttaattuuss  ||  TThhrreeaaddss'.  The current thread is high-
       lighted.  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.






DDD 2.2.3                   1998-01-26                         14





ddd(1)                                                     ddd(1)


   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
       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 _m_o_u_s_e _b_u_t_t_o_n _1 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 _m_o_u_s_e  _b_u_t_-
       _t_o_n  _3  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 _m_o_u_s_e _b_u_t_t_o_n _1 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 _m_o_u_s_e  _b_u_t_-
       _t_o_n  _3  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 the
       display numbered or named _d_i_s_p_l_a_y to the  new  display  is



DDD 2.2.3                   1998-01-26                         15





ddd(1)                                                     ddd(1)


       created; otherwise, no edge is created.

   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 _m_o_u_s_e _b_u_t_t_o_n _1.  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
       _m_o_u_s_e  _b_u_t_t_o_n  _1  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 mouse button 1 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 title, 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 _m_o_u_s_e _b_u_t_t_o_n _1 on its name or value and click
       on the `SShhooww (())' button.  Details are shown for the aggre-
       gate itself as well as for all contained sub-aggregates.

       To  hide  details about an aggregate, select the aggregate
       by clicking _m_o_u_s_e _b_u_t_t_o_n _1 on its name or value and  click



DDD 2.2.3                   1998-01-26                         16





ddd(1)                                                     ddd(1)


       on the `HHiiddee (())' button.

       When  pressing  and  holding  _m_o_u_s_e  _b_u_t_t_o_n _1 on the `SShhooww
       (())/HHiiddee (())' button, a menu pops up with even more alterna-
       tives:

       SShhooww MMoorree (())
              Shows  details  of all aggregates currently hidden,
              but not of their sub-aggregates.   You  can  invoke
              this item several times in a row to reveal more and
              more details of the selected aggregate.

       SShhooww JJuusstt (())
              Shows details of the selected aggregate, but  hides
              all sub-aggregates.

       SShhooww AAllll (())
              Shows  all details of the selected aggregate and of
              its sub-aggregates.  This item is equivalent to the
              `SShhooww (())' button.

       HHiiddee (())
              Hide  all  details of the selected aggregate.  This
              item is equivalent to the `HHiiddee (())' button.

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


       As  an  even faster alternative, you can also double-click
       _m_o_u_s_e _b_u_t_t_o_n _1 on a value.  If some part of the  value  is
       hidden, more details will be shown; if the entire value is
       shown, double-clicking will _h_i_d_e the value instead.   This
       way,  you  can  double-click  on a value until you get the
       right amount of details.

       If _a_l_l details of a display are  hidden,  the  display  is
       considered  _d_i_s_a_b_l_e_d.  Displays can be disabled or enabled
       via the DDD commands

         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.

   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.




DDD 2.2.3                   1998-01-26                         17





ddd(1)                                                     ddd(1)


       As a faster alternative, you can also press _m_o_u_s_e _b_u_t_t_o_n _3
       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
       `DDiissppllaayy', the new display showing _e_x_p_r is created.

       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 `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',  below,
       for details on how to examine such structures.

   DDiissppllaayy SShhoorrttccuuttss
       Each  time  you enter a new display via the prompt dialog,
       you can insert it in the `NNeeww DDiissppllaayy' Menu by  activating
       the `IInncclluuddee iinn ``NNeeww DDiissppllaayy'' MMeennuu' toggle.  The `NNeeww DDiiss--
       ppllaayy' menu allows you to repeat the  most  recent  display
       actions  over and over again.  It can be accessed in three
       ways:

       +o by pressing and holding the `NNeeww DDiissppllaayy' button, or

       +o by pressing _m_o_u_s_e _b_u_t_t_o_n _3 on some display and selecting
         `NNeeww DDiissppllaayy', or

       +o by pressing SShhiifftt and _m_o_u_s_e _b_u_t_t_o_n _3 on some display.

       As  an  example,  assume you have selected a display named
       `ffoooo' and used `NNeeww DDiissppllaayy' to cast the display `ffoooo'  to
       a new display `((cchhaarr **))ffoooo'.  If the `IInncclluuddee iinn ``NNeeww DDiiss--
       ppllaayy' Menu' toggle  was  activated,  you  can  now  simply
       choose  the  `DDiissppllaayy  ((cchhaarr **))(())' operation from the `NNeeww
       DDiissppllaayy' menu to cast  _a_n_y  selected  display  _d_i_s_p_l_a_y  to
       `((cchhaarr  **))_d_i_s_p_l_a_y'.   This  shortcut can save you a lot of
       time when examinating complex data structures.


       You can edit the contents of the  `NNeeww  DDiissppllaayy'  menu  by
       selecting its `EEddiitt MMeennuu' item.  This pops up the _S_h_o_r_t_c_u_t
       _E_d_i_t_o_r containing all shortcut expressions, which you  can
       edit  at  leisure.   Each line contains the expression for



DDD 2.2.3                   1998-01-26                         18





ddd(1)                                                     ddd(1)


       exactly one menu item.  Clicking on `AAppppllyy' re-creates the
       `NNeeww  DDiissppllaayy'  menu from the text.  If the text is empty,
       the `NNeeww DDiissppllaayy' menu will be empty, too.


       DDD also allows you to specify individual labels for user-
       defined  buttons.   You  can  write such a label after the
       expression, separated by `////'.  This feature  is  used  in
       the default contents of the `NNeeww DDiissppllaayy' menu, where each
       of the base conversions has a label:

           //dd (()) //// CCoonnvveerrtt ttoo DDeecc
           //xx (()) //// CCoonnvveerrtt ttoo HHeexx
           //oo (()) //// CCoonnvveerrtt ttoo OOcctt

       Feel free to add other conversions here.  DDD supports  up
       to 20 `NNeeww DDiissppllaayy' menu items.

       The  item  `OOtthheerr' in the `NNeeww DDiissppllaayy' menu is equivalent
       to pressing the `NNeeww DDiissppllaayy'  button--that  is,  you  can
       enter a new expression to be displayed.

   DDeerreeffeerreenncciinngg PPooiinntteerrss
       There  are  special  shortcuts for creating dependent dis-
       plays showing the value of a dereferenced  pointer.   This
       allows  for rapid examination of pointer-based data struc-
       tures.

       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 _m_o_u_s_e _b_u_t_t_o_n _3
       on the originating pointer value or name  and  select  the
       `DDiissppllaayy **' menu item.

       As  an  even faster alternative, you can also double-click
       _m_o_u_s_e _b_u_t_t_o_n _1 on the originating pointer value or name.

       The `DDiissppllaayy **(())' function is also accessible by  pressing
       and holding the `DDiissppllaayy (())' button.

   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Daattaa || DDiissppllaayy LLooccaall VVaarriiaabblleess'.  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 separate dis-
       play, 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.



DDD 2.2.3                   1998-01-26                         19





ddd(1)                                                     ddd(1)


   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.  Select `DDaattaa || SSttaattuuss
       DDiissppllaayyss' 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]]

       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.




DDD 2.2.3                   1998-01-26                         20





ddd(1)                                                     ddd(1)


   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
       _m_o_u_s_e _b_u_t_t_o_n _3 on the display and select the `DDeelleettee  DDiiss--
       p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 via `DDaattaa || EEddiitt  DDiiss--
       ppllaayyss').   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.

   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Daattaa || DDeetteecctt AAlliiaasseess'.

       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



DDD 2.2.3                   1998-01-26                         21





ddd(1)                                                     ddd(1)


       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
       simply  selecting  the  edge  hint and clicking on `DDeelleettee
       (())'.


       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



DDD 2.2.3                   1998-01-26                         22





ddd(1)                                                     ddd(1)


         examining 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
       The data window refreshes itself automatically  each  time
       the  program  stops.   Values  that have changed are high-
       lighted.

       However,  there  are  some  situations  where  you  should
       refresh  the  data  window  explicitly.   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  `DDaattaa  ||
       RReeffrreesshh DDiissppllaayyss'.

       As  an  alternative,  you  can press _m_o_u_s_e _b_u_t_t_o_n _3 on the
       background of the data window and select the `RReeffrreesshh DDiiss--
       p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 _m_o_u_s_e _b_u_t_t_o_n _1 on the dis-
       play  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.



DDD 2.2.3                   1998-01-26                         23





ddd(1)                                                     ddd(1)


       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.

   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 `DDaattaa || AAlliiggnn oonn  GGrriidd'.   This  is  useful  for
       keeping edges horizontal or vertical.

       You can enforce alignment by selecting `EEddiitt || PPrreeffeerreenncceess
       || DDaattaa || AAuuttoo--aalliiggnn ddiissppllaayyss oonn nneeaarreesstt ggrriidd  ppooiinntt'.   If
       this  feature  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
       `DDaattaa || LLaayyoouutt GGrraapphh'.

       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.  Edge hints can be
       moved around like arbitrary displays.

       To enable a more compact layout, you can set the  `EEddiitt  ||
       PPrreeffeerreenncceess  ||  DDaattaa  ||  UUssee ccoommppaacctt llaayyoouutt' option.  This
       realizes an alternate layout algorithm,  where  successors
       are placed next to their parents.  This algorithm is suit-
       able for homogeneous data structures only.

       You can enforce layout by setting `EEddiitt  ||  PPrreeffeerreenncceess  ||
       DDaattaa  || RRee--llaayyoouutt ggrraapphh aauuttoommaattiiccaallllyy'.  If automatic lay-
       out 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 `DDaattaa || RRoottaattee GGrraapphh'.

       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.





DDD 2.2.3                   1998-01-26                         24





ddd(1)                                                     ddd(1)


       To print the graph on a PostScript printer, select `FFiillee ||
       PPrriinntt GGrraapphh'.  Enter the printing command  in  the  `PPrriinntt
       CCoommmmaanndd'  field.   Click on the `OOKK' or the `AAppppllyy' button
       to start printing.

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

       As an alternative, you may also print the graph in a file.
       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 `SSoouurrccee ||  DDiissppllaayy
       MMaacchhiinnee  CCooddee'.   With machine code 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 function.  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



DDD 2.2.3                   1998-01-26                         25





ddd(1)                                                     ddd(1)


       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.

       The  `mmaaxxDDiissaasssseemmbbllee'  resource controls how much is to be
       disassembled.   If  `mmaaxxDDiissaasssseemmbbllee'  is   set   to   1024
       (default)  and  the  current  function is larger than 1024
       bytes, DDD only disassembles the first  1024  bytes  below
       the  current  location.   You can set the `mmaaxxDDiissaasssseemmbbllee'
       resource to a larger value if you prefer to have a  larger
       machine code view.

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

   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 `SSttaattuuss || RReeggiisstteerrss'.

       By  selecting  one of the registers, its name is copied to
       the argument field.  You can use it as value for  `DDiissp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 `SSoouurrccee || EEddiitt SSoouurrccee'.

       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;



DDD 2.2.3                   1998-01-26                         26





ddd(1)                                                     ddd(1)


       +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.

       If you have DDD and an editor running in parallel, you can
       also update the source code manually via `SSoouurrccee ||  RReellooaadd
       SSoouurrccee'.   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 necessary.

PPEERRSSIISSTTEENNTT SSEESSSSIIOONNSS
       Note: Session support is available with GDB running on the
       local machine only.

       If you want to interrupt your current DDD session, you can
       save its entire DDD state in a file and restore it  later.

   SSaavviinngg SSeessssiioonnss
       To  save  a session, select `FFiillee || SSaavvee SSeessssiioonn AAss'.  You
       will be asked for

       +o a symbolic session name _s_e_s_s_i_o_n and

       +o whether to include a core dump of the debugged  program.
         Including  a  core  dump is necessary for restoring data
         displays.

       After  clicking  on  `SSaavvee',  the  session  is  saved   in
       `$$HHOOMMEE//..dddddd//sseessssiioonnss//_s_e_s_s_i_o_n'.


       After  saving  the current state as a session, the session
       becomes _a_c_t_i_v_e.  This means that DDD state will  be  saved
       as session defaults:

       +o User       options       will      be      saved      in
         `$$HHOOMMEE//..dddddd//sseessssiioonnss//_s_e_s_s_i_o_n//iinniitt'      instead       of
         `$$HHOOMMEE//..dddddd//iinniitt';  see  `SSaavviinngg  OOppttiioonnss',  below,  for
         details.

       +o The   DDD   command   history   will   be    saved    in
         `$$HHOOMMEE//..dddddd//sseessssiioonnss//_s_e_s_s_i_o_n//hhiissttoorryy'     instead     of
         `$$HHOOMMEE//..dddddd//hhiissttoorryy'; see  `EEnntteerriinngg  CCoommmmaannddss',  above,



DDD 2.2.3                   1998-01-26                         27





ddd(1)                                                     ddd(1)


         for details.

       To  make  the  current  session inactive, open the _d_e_f_a_u_l_t
       _s_e_s_s_i_o_n named `[[NNoonnee]]'; see below for details  on  opening
       sessions.

       If  a core file is to be included in the session, DDD uses
       the `ggccoorree' command specified in  `EEddiitt  ||  PPrreeffeerreenncceess  ||
       HHeellppeerrss  ||  GGeett  CCoorree  FFiillee'.  Since `ggccoorree' automatically
       resumes debuggee execution, and since some time may elapse
       until  DDD can stop the debuggee again, the current execu-
       tion position may change after saving state.   If  you  do
       not  want  this,  leave the entry in `EEddiitt || PPrreeffeerreenncceess ||
       HHeellppeerrss || GGeett CCoorree FFiillee' empty.

       If no `ggccoorree' command is  specified,  DDD  must  kill  the
       debugged  program in order to get a core file.  This means
       that you cannot resume program execution  after  saving  a
       session.

   OOppeenniinngg SSeessssiioonnss
       To  resume a previously saved session, select `FFiillee || OOppeenn
       SSeessssiioonn' and choose a session name from the  list.   After
       clicking  on `OOppeenn', the entire DDD state will be restored
       from the given session.

       The session named `[[NNoonnee]]' is the _d_e_f_a_u_l_t _s_e_s_s_i_o_n which is
       active  when  starting  DDD.   To save options for default
       sessions, open the default session and save  options;  see
       `SSaavviinngg OOppttiioonnss' below for details.


       If  a  the restored session includes a core dump, the pro-
       gram being debugged will be in the same state at the  time
       the  session was saved; in particular, you can examine the
       program data.  However, you will not  be  able  to  resume
       program  execution  since  the  environment  (open  files,
       resources, etc.) will be lost.  However, you  can  restart
       the  program,  re-using  the restored breakpoints and data
       displays.

   DDeelleettiinngg SSeessssiioonnss
       To delete sessions that are no longer needed, select `FFiillee
       || OOppeenn SSeessssiioonn' or `FFiillee || SSaavvee SSeessssiioonn'.  Select the ses-
       sions you want to delete and click on `DDeelleettee'.

       The default session cannot be deleted.

   SSttaarrttiinngg DDDDDD wwiitthh aa SSeessssiioonn
       To start-up DDD with a given session named _s_e_s_s_i_o_n instead
       of the default session, use

         dddddd ----sseessssiioonn _s_e_s_s_i_o_n




DDD 2.2.3                   1998-01-26                         28





ddd(1)                                                     ddd(1)


       There  is  also  a shortcut that opens the session _s_e_s_s_i_o_n
       and also invokes the inferior debugger  on  an  executable
       named _s_e_s_s_i_o_n (in case _s_e_s_s_i_o_n cannot be opened):

         dddddd ==_s_e_s_s_i_o_n

       There is no need to give further command-line options when
       restarting a session, as they will be  overridden  by  the
       options saved in the session.

QQUUIITTTTIINNGG DDDDDD
       To  exit DDD, select `FFiillee || EExxiitt'.  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 (usu-
       ally 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.

       Furthermore, the inferior debugger may support debugging a
       program  on  a remote host.  This is useful when the infe-
       rior debugger is not available  on  the  remote  host--for
       instance,  because  the remote system does not have a gen-
       eral purpose operating system powerful  enough  to  run  a
       full-featured debugger.

   UUssiinngg DDDDDD wwiitthh aa RReemmoottee DDeebbuuggggeerr
       In  order  to  run the inferior debugger on a remote host,



DDD 2.2.3                   1998-01-26                         29





ddd(1)                                                     ddd(1)


       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

         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

       or

         dddddd ----hhoosstt _u_s_e_r_n_a_m_e@@_h_o_s_t_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 2.2.3                   1998-01-26                         30





ddd(1)                                                     ddd(1)


         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.

   UUssiinngg DDDDDD wwiitthh aa RReemmoottee PPrrooggrraamm
       The GDB debugger allows you to run the _d_e_b_u_g_g_e_d _p_r_o_g_r_a_m on
       a remote machine (called _r_e_m_o_t_e _t_a_r_g_e_t), while GDB runs on
       the local machine.

       The  section  `RReemmoottee  ddeebbuuggggiinngg' in the GDB documentation
       contains all the details.  Basically, the following  steps
       are required:

       +o Transfer the executable to the remote target.

       +o Start `ggddbbsseerrvveerr' on the remote target.

       +o Start  DDD  using GDB on the local machine, and load the
         same executable using the 'ffiillee' command.

       +o Attach to  the  remote  `ggddbbsseerrvveerr'  using  the  'ttaarrggeett
         rreemmoottee' command.

       The  local `..ggddbbiinniitt' file is useful for setting up direc-
       tory search paths, etc.

       Of course, you can also combine DDD remote  mode  and  GDB
       remote  mode,  running  DDD, GDB, and the debugged program
       each on a different machine.

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;   DDD  invokes  shell  commands  and  even  shell
       scripts, such that all  known  problems  of  setuid  shell
       scripts apply.  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

         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



DDD 2.2.3                   1998-01-26                         31





ddd(1)                                                     ddd(1)


       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  detects
       an  EOF condition on its standard input.  Also, do not try
       to run DDD with DDD as inferior debugger.

       Using DDD in TTY mode automatically disables some DDD win-
       dows, because it is assumed that their facilities are pro-
       vided by the remote program:

       +o If DDD is invoked with the `----ttttyy' option, the  debugger
         console  is  initially  disabled,  as its facilities are
         supposed to be provided by the integrating front-end.

       +o If DDD is  invoked  with  the  `--ffuullllnnaammee'  option,  the
         debugger  console  and  the  source window are initially
         disabled, as their facilities are supposed  to  be  pro-
         vided by the integrating front-end.

       In  case of need, you can use the `VViieeww' menu to re-enable
       these windows.

   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
       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



DDD 2.2.3                   1998-01-26                         32





ddd(1)                                                     ddd(1)


       earlier):

         ((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)) ''


UUSSEERR--DDEEFFIINNEEDD CCOOMMMMAANNDDSS
       If   your  debugger  allows  you  to  define  own  command
       sequences, you can also use  these  _u_s_e_r_-_d_e_f_i_n_e_d  _c_o_m_m_a_n_d_s
       within  DDD; just enter them at the debugger prompt.  How-
       ever, you may encounter some problems:

       +o In contrast to the well-documented commands of the infe-
         rior debugger, DDD does not know what your specific com-
         mand does.  This may lead to inconsistencies between DDD
         and  the  inferior  debugger.  For instance, if your own
         command `bbpp' sets a breakpoint, DDD may not  display  it
         immediately, because DDD does not know that `bbpp' changes
         the breakpoint state.

       +o You cannot use DDD ggrraapphh  commands  within  user-defined
         commands.   This  is  only natural, because user-defined
         commands are interpreted by the inferior debugger, which
         does not know about DDD commands.

       As a solution, DDD provides a simple facility called _a_u_t_o_-
       _c_o_m_m_a_n_d_s.  If DDD receives any output  from  the  inferior
       debugger  in  the  form  `dddddd:: _c_o_m_m_a_n_d', it will interpret
       _c_o_m_m_a_n_d as if it had been entered at the debugger  prompt.

       Suppose  you  want  to define a GDB command `ddiissppffoooo' that
       creates a data display containing the variable  _f_o_o.   All
       ddiissppffoooo has to do is to issue a string

         dddddd:: ggrraapphh ddiissppllaayy ffoooo

       In  GDB,  this can be achieved using the eecchhoo command.  In
       your $$HHOOMMEE//..ggddbbiinniitt file, insert the lines

         ddeeffiinnee ddiissppffoooo
           eecchhoo dddddd:: ggrraapphh ddiissppllaayy ffoooo
         eenndd

       Entering ddiissppffoooo will now have the same effect as entering
       ggrraapphh ddiissppllaayy ffoooo at the debugger prompt.

       Unfortunately,   auto-commands   also   raise  a  security



DDD 2.2.3                   1998-01-26                         33





ddd(1)                                                     ddd(1)


       problem, since arbitrary commands can be  executed.   Just
       imagine some malicuous program issuing a string like `dddddd::
       sshheellll rrmm --ffrr $$HHOOMMEE' when  being  debugged!   Consequently,
       auto-commands  are _d_i_s_a_b_l_e_d by default and must be enabled
       explicitly.

       To enable auto-commands, write in  your  `$$HHOOMMEE//..dddddd//iinniitt'
       file:

         DDdddd**aauuttooCCoommmmaannddss:: oonn

       The  default  prefix of auto-commands is `dddddd:: '.  You are
       encouraged to change this value in your `..dddddd//iinniitt'  file.
       To use a prefix of, say, `mmaaggiicc112233:: ', write:

         DDdddd**aauuttooCCoommmmaannddPPrreeffiixx:: mmaaggiicc112233::\\

       Leave  a  space  after  the  final `\\'.  Be sure to enable
       auto-commands only if you have defined  own  commands;  be
       sure  to set up an individual auto-command prefix to avoid
       security problems.

PPRREEFFEERREENNCCEESS
       You can set up your personal DDD preferences by using  the
       `EEddiitt  || PPrreeffeerreenncceess' menu from the menu bar.  These pref-
       erences affect your running DDD process only,  unless  you
       save  these  preferences for a later DDD invocation.  Fre-
       quently used preferences can also be found in the individ-
       ual menus.

   FFrreeqquueennttllyy UUsseedd 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 `PPrrooggrraamm || RRuunn iinn  EExxeeccuuttiioonn
       WWiinnddooww'.   This  is  useful for programs that have special
       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 `SSoouurrccee ||
       FFiinndd WWoorrddss OOnnllyy'.

       By default, DDD find is case-sensitive.   This  is  conve-
       nient  for  case-sensitive  programming languages.  If you
       want to find all occurrences, regardless  of  case,  unset
       `SSoouurrccee || FFiinndd CCaassee SSeennssiittiivvee'.

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

       Through  `EEddiitt  ||  PPrreeffeerreenncceess',  you  can set up more DDD
       preferences, which are dicussed here.



DDD 2.2.3                   1998-01-26                         34





ddd(1)                                                     ddd(1)


   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.

       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  want to keep DDD off your desktop during a longer
       computation, you may  like  to  set  the  `UUnniiccoonniiffyy  wwhheenn
       rreeaaddyy'  option.  This way, you can iconify DDD while it is
       busy on a command (e.g. running a program); DDD will auto-
       matically  pop  up  again after becoming ready (e.g. after
       the debugged program has stopped at a breakpoint).

       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



DDD 2.2.3                   1998-01-26                         35





ddd(1)                                                     ddd(1)


       your display.

       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.


       In contrast to previous releases, DDD 2.2 and later do not
       display  line  numbers in the source code.  If you want to
       see each source line prefixed with its respective  number,
       set the `DDiissppllaayy ssoouurrccee lliinnee nnuummbbeerrss' option.

       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  `FFiinndd  wwoorrddss
       oonnllyy'.

       By  default,  DDD  find is case-sensitive.  This is conve-
       nient for case-sensitive programming  languages.   If  you
       want  to  find  all occurrences, regardless of case, unset
       `FFiinndd ccaassee sseennssiittiivvee'.

       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
       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.

       If your source code uses a tab width different from 8 (the
       default), you can set an alternate width  using  the  `TTaabb
       wwiiddtthh' slider.

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




DDD 2.2.3                   1998-01-26                         36





ddd(1)                                                     ddd(1)


   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.

       By default, DDD displays two-dimensional arrays as tables,
       aligning the array elements in rows and columns.   If  you
       prefer  viewing  two-dimensional  arrays  as  nested  one-
       dimensional arrays, you  can  disable  the  `DDiissppllaayy  ttwwoo--
       ddiimmeennssiioonnaall aarrrraayyss aass ttaabbllees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,
       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') of the source.  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



DDD 2.2.3                   1998-01-26                         37





ddd(1)                                                     ddd(1)


       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.

       If  you  want  the  DDD  logo  shown upon startup, you can
       select between different versions.  The `ccoolloorr' version is
       the  nicest, but requires several color cells.  The `ggrreeyy'
       version requires some grey color  cells,  which  are  also
       used  by  DDD.   The  `ggrreeyy44'  version needs no additional
       color cells.  Selecting  `nnoonnee'  disables  the  logo  com-
       pletely.

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

   HHeellppeerrss
       DDD relies on some external applications (called  _h_e_l_p_e_r_s)
       for  specific tasks.  Through the `HHeellppeerrss' panel, you can
       choose and customize these applications.

       In `EEddiitt SSoouurrcceess', you  can  select  an  X  editor  to  be
       invoked  via  the DDD `EEddiitt' button.  `@@FFIILLEE@@' is replaced
       by the current file name; `@@LLIINNEE@@' is replaced by the cur-
       rent line.  Typical values include `xxeeddiitt @@FFIILLEE@@' or `ggnnuu--
       cclliieenntt  ++@@LLIINNEE@@  @@FFIILLEE@@'.   See  also  the   `eeddiittCCoommmmaanndd'
       resource, below.

       In  `GGeett CCoorree FFiillee', you can enter a command to get a core
       file from a running process.  `@@FFIILLEE@@' is replaced by  the
       name  of  the target core file; `@@PPIIDD@@' is replaced by the
       process ID.  A typical value is `ggccoorree --oo  @@FFIILLEE@@  @@PPIIDD@@'.
       If you don't have an appropriate command, leave this value
       empty: DDD will then kill the debuggee in order to  get  a
       core file.  See also the `ggeettCCoorreeCCoommmmaanndd' resource, below.




DDD 2.2.3                   1998-01-26                         38





ddd(1)                                                     ddd(1)


       `LLiisstt PPrroocceesssseess' is a command to get a list of  processes,
       like  `ppss'.   The  output  of this command is shown in the
       `FFiillee || AAttttaacchh ttoo PPrroocceessss' dialog.  See also  the  `ppssCCoomm--
       mmaanndd' resource, below.

       In  `EExxeeccuuttiioonn WWiinnddooww', you can enter a command to start a
       terminal emulator.  To this command,  DDD  appends  bourne
       shell commands to be executed within the execution window.
       A simple value is `xxtteerrmm --ee //bbiinn//sshh  --cc'.   See  also  the
       `tteerrmmCCoommmmaanndd' resource, below.


       `UUnnccoommpprreessss'  is  the uncompression command used by DDD to
       uncompress the DDD license and manual pages.   The  uncom-
       pression command should be invoked such that it reads from
       standard input and writes to standard output.   A  typical
       value  is  `gguunnzziipp  --cc'.  See also the `uunnccoommpprreessssCCoommmmaanndd'
       resource, below.

       Finally, `WWeebb BBrroowwsseerr' is the  command  to  invoke  a  WWW
       browser  for the DDD WWW page.  `@@UURRLL@@' is replaced by the
       URL to be shown.  A simple value is `nneettssccaappee @@UURRLL@@'.  See
       also the `wwwwwwCCoommmmaanndd' resource, below.

   DDeeffiinniinngg BBuuttttoonnss
       To facilitate interaction, you can add own command buttons
       to DDD.  These buttons can be  added  below  the  debugger
       console  (`CCoonnssoollee  BBuuttttoonnss'),  the source window (`SSoouurrccee
       BBuuttttoonnss'), or the data window (`DDaattaa BBuuttttoonnss').

       To define  individual  buttons,  use  the  _B_u_t_t_o_n  _E_d_i_t_o_r,
       invoked  via `CCoommmmaannddss || EEddiitt BBuuttttoonnss'.  The button editor
       displays a text, where each line contains the command  for
       exactly  one  button.   Clicking  on  `AAppppllyy'  creates the
       appropriate buttons from the text.  If the text  is  empty
       (the default), no button is created.

       As a simple example, assume you want to create a `pprriinntt ii'
       button.  Invoke `CCoommmmaannddss || EEddiitt BBuuttttoonnss' and enter a line
       saying  `pprriinntt  ii'  in  the  button editor.  Then click on
       `AAppppllyy'.  A button named `PPrriinntt ii' will now  appear  below
       the debugger console--try it!  To remove the button, clear
       the `pprriinntt ii' line and press `AAppppllyy' again.

       By default, DDD disables buttons whose  commands  are  not
       supported  by  the inferior debugger.  To enable such but-
       tons, unset the `EEnnaabbllee ssuuppppoorrtteedd bbuuttttoonnss oonnllyy' toggle  in
       the button editor.

       DDD  also allows you to specify control sequences and spe-
       cial labels for user-defined buttons.  See the examples in
       `UUsseerr--ddeeffiinneedd  BBuuttttoonnss' in the `RREESSOOUURRCCEESS' section, below.





DDD 2.2.3                   1998-01-26                         39





ddd(1)                                                     ddd(1)


   SSaavviinngg OOppttiioonnss
       You can save the  current  option  settings  by  selecting
       `EEddiitt  || SSaavvee OOppttiioonnss'.  Options are saved in a file named
       `..dddddd//iinniitt' in your home directory.  If a session  _s_e_s_s_i_o_n
       is     active,     options     will     be     saved    in
       `$$HHOOMMEE//..dddddd//sseessssiioonnss//_s_e_s_s_i_o_n//iinniitt' instead.

   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d//i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 via `EEddiitt || SSeett--
       ttiinnggss'.  See the `DDEEBBUUGGGGEERR SSEETTTTIINNGGSS' section, below.

DDEEBBUUGGGGEERR SSEETTTTIINNGGSS
       If you use GDB (or some DBX flavor) as inferior  debugger,
       you  can  change  its  settings  using  `EEddiitt || SSeettttiinnggss'.
       Using the settings editor, you can determine  whether  C++
       names  are to be demangled, how many array elements are to
       print, and so on.

       The capabilities of the  settings  editor  depend  on  the
       capabilities  of your inferior debugger--that is, your GDB
       or DBX 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' and `ddbbxxIInniittCCoommmmaannddss' resources
       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.

       Whether the hacks are included at run-time depends on  the
       setting  of  the  `lleessssTTiiffVVeerrssiioonn' resource.  `lleessssTTiiffVVeerr--
       ssiioonn' indicates the LessTif version against which  DDD  is
       linked.   For  LessTif  version _x_._y, its value is _x multi-
       plied by 1000 plus _y--for instance, the  value  8888  stands
       for  LessTif  0.88  and  the value 11000000 stands for LessTif
       1.0.  To specify the version number of the LessTif library



DDD 2.2.3                   1998-01-26                         40





ddd(1)                                                     ddd(1)


       at DDD invocation, you can also use the option `----lleessssttiiff--
       vveerrssiioonn _v_e_r_s_i_o_n'.

       The default value  of  the  `lleessssTTiiffVVeerrssiioonn'  resource  is
       derived  from the LessTif library DDD was compiled against
       (or 11000000 when compiled  against  OSF/Motif).   Hence,  you
       normally  don't  need  to  worry  about  the value of this
       resource.  However, if you use a  dynamically  linked  DDD
       binary  with a library other than the one DDD was compiled
       against, you  must  specify  the  version  number  of  the
       library  using  this resource.  (Unfortunately, DDD cannot
       detect this at run-time.)

       Here are a few scenarios to illustrate this scheme:

       +o Your DDD binary was compiled against OSF/Motif, but  you
         use  a LessTif 0.81 dynamic library instead.  Invoke DDD
         with `----lleessssttiiff--vveerrssiioonn 8811'.

       +o Your DDD binary was compiled against  LessTif,  but  you
         use  a  OSF/Motif dynamic library instead.    Invoke DDD
         with `----lleessssttiiff--vveerrssiioonn 11000000'.

       +o Your DDD binary was compiled against LessTif  0.81,  and
         you  have  upgraded  to  LessTif  0.90.  Invoke DDD with
         `----lleessssttiiff--vveerrssiioonn 9900'.

       To find out the LessTif or OSF/Motif version DDD was  com-
       piled  against,  invoke  DDD  with  the  `----ccoonnffiigguurraattiioonn'
       option.

       In the DDD source, LessTif-specific hacks  are  controlled
       by the string `lleessssttiiff__vveerrssiioonn'.

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.

   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




DDD 2.2.3                   1998-01-26                         41





ddd(1)                                                     ddd(1)


       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d//i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,,\\
         --**--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



DDD 2.2.3                   1998-01-26                         42





ddd(1)                                                     ddd(1)


         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d//i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

       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




DDD 2.2.3                   1998-01-26                         43





ddd(1)                                                     ddd(1)


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

   GGeenneerraall PPrreeffeerreenncceess
       The following resources determine DDD general behavior.

       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').

       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', (un)iconifying any DDD window
              causes all other  DDD  windows  to  (un)iconify  as
              well.   Default  is  `ffaallssee', meaning that each DDD
              window can be iconified on its own.

       uunniiccoonniiffyyWWhheennRReeaaddyy ((class UUnniiccoonniiffyyWWhheennRReeaaddyy))
              If this is `ttrruuee' (default), the  DDD  windows  are
              uniconified   automatically  whenever  GDB  becomes
              ready.  This way, you can iconify DDD  during  some
              longer  operation  and  have it uniconify itself as
              soon as the program stops.  Setting this to `ffaallssee'
              leaves the DDD windows iconified.

       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.

       sshhoowwSSttaarrttuuppLLooggoo ((class SShhoowwSSttaarrttuuppLLooggoo))
              If non-empty, show a DDD logo upon start-up.   Pos-
              sible  values  include: `cc' for a color visual, `gg'
              for a multi-level  greyscale  visual,  `gg44'  for  a
              4-level   greyscale  visual,  `mm'  for  a  dithered
              monochrome visual, and `' (the empty string) for no
              logo  at  all.   The  value `bbeesstt' chooses the best
              visual available  for  your  display.   Default  is
              `gg44'.
              Note:  if  DDD  runs on a monochrome display, or if
              DDD was compiled without the XPM library, only  the
              monochrome version (`mm') can be shown.




DDD 2.2.3                   1998-01-26                         44





ddd(1)                                                     ddd(1)


       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'.

       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',  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.  The  default  setting  is  `ffaallssee',
              since  this feature is known to interfere with some
              Motif versions (popup menus won't work).

       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').

   SSoouurrccee WWiinnddooww
       The following resources determine the DDD source window.

       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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
              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.





DDD 2.2.3                   1998-01-26                         45





ddd(1)                                                     ddd(1)


       ddiissppllaayyLLiinneeNNuummbbeerrss ((class DDiissppllaayyLLiinneeNNuummbbeerrss))
              If this is `ttrruuee', lines in  the  source  text  are
              prefixed  with  their  respective line number.  The
              default is `ffaallssee'.

       ffiinnddCCaasseeSSeennssiittiivvee ((class FFiinnddCCaasseeSSeennssiittiivvee))
              If this is `ttrruuee' (default),  the  `FFiinndd'  commands
              are  case-sensitive.   Otherwise,  occurrences  are
              found regardless of case.

       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.

       iinnddeennttCCooddee ((class IInnddeenntt))
              The number of columns to indent the  machine  code,
              such  that  there is enough place to display break-
              point locations.  Default: 44.

       iinnddeennttSSoouurrccee ((class IInnddeenntt))
              The number of columns to indent  the  source  code,
              such  that  there is enough place to display break-
              point locations.  Default: 44.

       lliinneeNNuummbbeerrWWiiddtthh ((class LLiinneeNNuummbbeerrWWiiddtthh))
              The number of columns to use for line  numbers  (if
              displaying  line numbers is enabled).  Line numbers
              wider than this value extend  into  the  breakpoint
              space.  Default: 44.

       lliinneessAAbboovveeCCuurrssoorr ((class LLiinneessAAbboovveeCCuurrssoorr))
              The minimum number of lines to show before the cur-
              rent location.  Default is 22.

       lliinneessBBeelloowwCCuurrssoorr ((class LLiinneessBBeelloowwCCuurrssoorr))
              The minimum number of lines to show after the  cur-
              rent location.  Default is 33.

       mmaaxxDDiissaasssseemmbbllee ((class MMaaxxDDiissaasssseemmbbllee))
              Maximum  number  of  bytes to disassemble (default:
              1024).  If this is zero, the entire  current  func-
              tion is disassembled.

       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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
              names.  If this is `ttrruuee' (default), DDD  uses  the
              full source code paths.




DDD 2.2.3                   1998-01-26                         46





ddd(1)                                                     ddd(1)


   WWiinnddooww CCrreeaattiioonn aanndd LLaayyoouutt
       The  following resources determine DDD window creation and
       layout as well as the interaction with the X  window  man-
       ager.

       aauuttooRRaaiisseeTTooooll ((class AAuuttooRRaaiisseeTTooooll))
              If  `ttrruuee' (default), DDD will always keep the com-
              mand tool on top of other  DDD  windows.   If  this
              setting  interferes with your window manager, or if
              your window manager keeps the command tool  on  top
              anyway, set this resource to `ffaallssee'.

       aauuttooRRaaiisseeMMeennuu ((class AAuuttooRRaaiisseeMMeennuu))
              If `ttrruuee' (default), DDD will always keep the pull-
              down menu on top of the DDD main window.   If  this
              setting  interferes with your window manager, or if
              your window manager does  not  auto-raise  windows,
              set this resource to `ffaallssee':

                DDdddd**aauuttooRRaaiisseeMMeennuu:: ffaallssee


       ccoolloorrIIccoonnss ((class CCoolloorrIIccoonnss))
              If  `ttrruuee'  (default),  DDD uses multi-color icons.
              If your window manager has trouble with multi-color
              icons,  set  this  resource to `ffaallssee' and DDD will
              use black-and-white icons instead.

       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eccoorraatteeTTooooll ((class DDeeccoorraatteeTTooooll))
              This  resource  controls the decoration of the com-
              mand tool.

              +o If this is `ffaallssee', the command tool  is  created
                as  a  _t_r_a_n_s_i_e_n_t _w_i_n_d_o_w.  Several window managers
                keep transient windows automatically  on  top  of
                their  parents, which is appropriate for the com-
                mand tool.  However, your window manager  may  be
                configured  not  to  decorate  transient windows,
                which means that you cannot easily move the  com-
                mand tool around.

              +o If  this is `ttrruuee', DDD realizes the command tool
                as a _t_o_p_-_l_e_v_e_l _w_i_n_d_o_w.  Such windows  are  always
                decorated  by  the window manager.  However, top-
                level windows are not automatically kept  on  top
                of  other  windows, such that you may wish to set
                the `aauuttooRRaaiisseeTTooooll' resource, too.

              +o If this is `aauuttoo' (default), DDD  checks  whether
                the window manager decorates transients.  If yes,



DDD 2.2.3                   1998-01-26                         47





ddd(1)                                                     ddd(1)


                the command tool is realized as a transient  win-
                dow (as in the ffaallssee setting); if no, the command
                tool is realized as a top-level window (as in the
                ttrruuee setting).  Hence, the command tool is always
                decorated using the "best" method, but the  extra
                check takes some time.


       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.

       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
              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sttiicckkyyTTooooll ((class SSttiicckkyyTTooooll))
              If `ttrruuee' (default), the command tool automatically
              follows every movement of the source window.  When-
              ever  the  source window is moved, the command tool
              is moved by the same offset such that its  position
              relative  to  the  source window remains unchanged.
              If `ffaallssee', the command tool does not follow source
              window movements.




DDD 2.2.3                   1998-01-26                         48





ddd(1)                                                     ddd(1)


   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.

       aauuttooCCoommmmaannddss ((class AAuuttooCCoommmmaannddss))
              If this is `ttrruuee', each line output by the inferior
              debugger beginning with the value of the  `aauuttooCCoomm--
              mmaannddPPrreeffiixx'  resource  (see below) will be taken as
              DDD command and executed.  Useful for  user-defined
              commands;  see  `UUSSEERR--DDEEFFIINNEEDD CCOOMMMMAANNDDSS', above.  By
              default, `ffaallssee'.

       aauuttooCCoommmmaannddPPrreeffiixx ((class AAuuttooCCoommmmaannddPPrreeffiixx))
              The prefix for auto-commands.  By default, `dddddd:: '.

       bblloocckkTTTTYYIInnppuutt ((class BBlloocckkTTTTYYIInnppuutt))
              Whether DDD should block when reading data from the
              inferior debugger  via  the  pseudo-tty  interface.
              Some  systems _r_e_q_u_i_r_e this, such as Linux with libc
              5.4.33 and earlier; set it to `ttrruuee'.   Some  other
              systems  _p_r_o_h_i_b_i_t this, such as Linux with GNU libc
              6 and later; set it to `ffaallssee'.  The  value  `aauuttoo'
              (default)  will  always  select  the  "best" choice
              (that is, the best choice known to the DDD develop-
              ers).

       ddbbxxIInniittCCoommmmaannddss ((class I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 S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.

       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



DDD 2.2.3                   1998-01-26                         49





ddd(1)                                                     ddd(1)


              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 DDEEBBUUGG--
              G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' for-
              mat.   As  a side effect, the source window is dis-
              abled  by  default.   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 I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 S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



DDD 2.2.3                   1998-01-26                         50





ddd(1)                                                     ddd(1)


                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 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.

       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.  As a side
              effect,  the  debugger  console  is   disabled   by
              default.   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 I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 SSeettttiinnggss))
              This  string  contains  a list of newline-separated



DDD 2.2.3                   1998-01-26                         51





ddd(1)                                                     ddd(1)


              commands that are also initially sent to  XDB.   By
              default, it is empty.


   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
       buttons.

       ccoonnssoolleeBBuuttttoonnss ((class BBuuttttoonnss))
              A newline-separated list of  buttons  to  be  added
              under the debugger console.  Each button issues the
              command 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 `()'.

              +o The  string  specified  in  the  `llaabbeellDDeelliimmiitteerr'
                resource  (usually  `////')  separates  the command
                name from the button label.  If no  button  label
                is  specified,  the  capitalized  command will be
                used as button label.

              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



DDD 2.2.3                   1998-01-26                         52





ddd(1)                                                     ddd(1)


                        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  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d//i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nNNoo\\nnb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nNNoo\\nnrruunn\\nnCClleeaarr\\nnPPrreevv\\nnNNeexxtt\\nnAAppppllyy\\nnb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 BBuuttttoonnss))
              A  newline-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t--
              ttoonnss' resource, above, for details on  button  syn-
              tax.

              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 BBuuttttoonnss))
              A newline-separated list of  buttons  to  be  added
              under the debugger console.  Each button issues the
              command given by its name.   See  the  `ccoonnssoolleeBBuutt--
              ttoonnss'  resource,  above, for details on button syn-
              tax.

              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d//i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\\nnsstteepp\\nnnneexxtt\\nnsstteeppii\\nnnneexxttii\\nnccoonntt\\nn\\
                ffiinniisshh\\nnkkiillll\\nnuupp\\nnddoowwnn\\nn\\
                BBaacckk\\nnFFoorrwwaarrdd\\nnEEddiitt\\nniinntteerrrruupptt^^CC




DDD 2.2.3                   1998-01-26                         53





ddd(1)                                                     ddd(1)


              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:: \\
                pprriinntt **(())\\nnggrraapphh ddiissppllaayy **(())\\nnpprriinntt //xx (())\\nn\\
                wwhhaattiiss (())\\nnppttyyppee (())\\nnwwaattcchh (())\\nnuunnttiill\\nns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 **(((()))) //// PPrriinntt **(())\\nn\\
                ggrraapphh ddiissppllaayy **(((()))) //// DDiissppllaayy **(())\\nn\\
                pprriinntt //xx (())\\nn\\
                wwhhaattiiss (()) //// WWhhaatt iiss (())\\nn\\
                ppttyyppee (())\\nn\\
                wwaattcchh (())\\nn\\
                uunnttiill\\nn\\
                sshheellll

              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 BBuuttttoonnss))
              A  newline-separated list of buttons to be included
              in the command tool or the tool bar (see the `ttooooll--
              BBaarr' resource, above).  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

                DDdddd**ttoooollBBuuttttoonnss:: \\
                rruunn\\nniinntteerrrruupptt^^CC\\nnsstteepp\\nnsstteeppii\\nn\\
                nneexxtt\\nnnneexxttii\\nnccoonntt\\nnffiinniisshh\\nn\\
                uupp\\nnddoowwnn\\nnBBaacckk\\nnFFoorrwwaarrdd\\nnEEddiitt\\nnk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:




DDD 2.2.3                   1998-01-26                         54





ddd(1)                                                     ddd(1)


                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

                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 ttrruuee (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 ffaallssee, no checking
              is done: all commands are accepted "as is".

   DDaattaa DDiissppllaayy
       The following resources control the data display.

       aalliiggnn22ddAArrrraayyss ((class AAlliiggnn22ddAArrrraayyss))
              If ttrruuee (default),  DDD  lays  out  two-dimensional
              arrays  as tables, such that all array elements are
              aligned with each other.  If ffaallssee,  DDD  treats  a
              two-dimensional   array   as   an   array  of  one-
              dimensional arrays, each aligned on its own.





DDD 2.2.3                   1998-01-26                         55





ddd(1)                                                     ddd(1)


       bbuummppDDiissppllaayyss ((class BBuummppDDiissppllaayyss))
              If some display _D changes size and this resource is
              ttrruuee  (default),  DDD assigns new positions to dis-
              plays below and on the right of  _D  such  that  the
              distance  between  displays  remains  constant.  If
              this is ffaallssee, other displays are not rearranged.

       ddeetteeccttAAlliiaasseess ((class DDeetteeccttAAlliiaasseess))
              If ttrruuee, DDD  attempts  to  recognize  shared  data
              structures.   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c--
              ttuurreess', above, for a discussion.   The  default  is
              ffaallssee,  meaning that shared data structures are not
              recognized.

       ddiissppllaayySShhoorrttccuuttss ((class DDiissppllaayySShhoorrttccuuttss))
              A newline-separated list of display expressions  to
              be  included  in the `NNeeww DDiissppllaayy' menu.  If a line
              contains a label delimiter (the string `////'; can be
              changed  via  the  `llaabbeellDDeelliimmiitteerr'  resource), the
              string before the delimiter is used as  _e_x_p_r_e_s_s_i_o_n,
              and  the  string  after  the  delimiter  is used as
              label.  Otherwise, the label  is  `DDiissppllaayy  _e_x_p_r_e_s_-
              _s_i_o_n'.  Upon activation, the string `(())' in _e_x_p_r_e_s_-
              _s_i_o_n is replaced  by  the  name  of  the  currently
              selected display.

       hhiiddeeIInnaaccttiivveeDDiissppllaayyss ((class HHiiddeeIInnaaccttiivveeDDiissppllaayyss))
              If some display gets out of scope and this resource
              is ttrruuee (default), DDD removes  it  from  the  data
              display.   If this is ffaallssee, it is simply disabled.

       llaabbeellDDeelliimmiitteerr ((class LLaabbeellDDeelliimmiitteerr))
              The string used to separate  labels  from  commands
              and shortcuts.  Default is `////'.

       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'.

       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.




DDD 2.2.3                   1998-01-26                         56





ddd(1)                                                     ddd(1)


              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:

              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"",, ""wwhhiittee""))

              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""))

              cchhaannggeedd__ccoolloorr((_b_o_x))
                        The   color   used  for  changed  values.
                        Default: ccoolloorr((_b_o_x,, ""bbllaacckk"",, ""##ffffffffcccc""))

              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).




DDD 2.2.3                   1998-01-26                         57





ddd(1)                                                     ddd(1)


              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
                        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



DDD 2.2.3                   1998-01-26                         58





ddd(1)                                                     ddd(1)


              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
              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.

   DDeebbuuggggeerr CCoonnssoollee
       The following resources control the debugger console.

       lliinneeBBuuffffeerreeddCCoonnssoollee ((class LLiinneeBBuuffffeerreedd))
              If  this  is  `ttrruuee'  (default), each line from the
              inferior is output on each own, such that the final
              line  is  placed at the bottom of the debugger con-
              sole.  If this is `ffaallssee', all lines are output  as
              a  whole.   This is faster, but results in a random
              position of the last line.


   CCuussttoommiizziinngg HHeellppeerrs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d//i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d//i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@@





DDD 2.2.3                   1998-01-26                         59





ddd(1)                                                     ddd(1)


       ggeettCCoorreeCCoommmmaanndd ((class GGeettCCoorreeCCoommmmaanndd))
              A  command  to get a core dump of a running process
              (typically, `ggccoorree') `@@FFIILLEE@@' is  replaced  by  the
              base  name  of  the  file  to  create;  `@@PPIIDD@@'  is
              replaced by the process id.   The  output  must  be
              written to `@@FFIILLEE@@..@@PPIIDD@@'.
              Leave  this  entry  empty if you have no `ggccoorree' or
              similar command.

       lleessssTTiiffVVeerrssiioonn ((class LLeessssTTiiffVVeerrssiioonn))
              Indicates  the  LessTif  version  DDD  is   running
              against.   For  LessTif version _x_._y, the value is _x
              multiplied by 1000 plus _y--for instance, the  value
              7799  stands  for  LessTif  0.79  and  the value 11000055
              stands for LessTif 1.5.
              If the value of this resource is  less  than  1000,
              indicating  LessTif  0.99  or  earlier, DDD enables
              version-specific hacks  to  make  DDD  work  around
              LessTif bugs and deficiencies.
              If  DDD  was  compiled against LessTif, the default
              value is the value of the `LLeessssTTiiffVVeerrssiioonn' macro in
              <<XXmm//XXmm..hh>>.   If DDD was compiled against OSF/Motif,
              the default value is 11000000, disabling  all  LessTif-
              specific hacks.

       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


       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$$''



DDD 2.2.3                   1998-01-26                         60





ddd(1)                                                     ddd(1)


       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'.

       ppssCCoommmmaanndd ((class PPssCCoommmmaanndd))
              The command to get a list  of  processes.   Usually
              `ppss'.   Depending  on your system, useful alternate
              values include `ppss --eeff' and `ppss  --uuxx'.   The  first
              line  of  the  output  must  either contain a `PPIIDD'
              title, or each line must begin with a process ID.
              Note that the output of this command is filtered by
              DDD;  a process is only shown if it can be attached
              to.  The DDD process itself as well as the  process
              of the inferior debugger are suppressed, too.

       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

       uunnccoommpprreessssCCoommmmaanndd ((class UUnnccoommpprreessssCCoommmmaanndd))
              The command to uncompress the built-in DDD  manual,
              the  DDD  license,  and the DDD news.  Takes a com-
              pressed text from standard  input  and  writes  the
              uncompressed  text to standard output.  The default
              value is  `ggzziipp  --dd  --cc';  typical  values  include
              `zzccaatt' and `gguunnzziipp --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



DDD 2.2.3                   1998-01-26                         61





ddd(1)                                                     ddd(1)


              `@@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:

                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--44..00  browser;  if  this fails, it starts a
              new nneettssccaappee--44..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d//iinniitt'  file.   If this string does
              not match the  version  of  the  current  DDD  exe-
              cutable, 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.




DDD 2.2.3                   1998-01-26                         62





ddd(1)                                                     ddd(1)


       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,
              below.

       sshhoowwNNeewwss ((class SShhoowwNNeewwss))
              If `ttrruuee', show the DDD news on standard output and
              exit.  See also the `----nneewwss' option, 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.





DDD 2.2.3                   1998-01-26                         63





ddd(1)                                                     ddd(1)


   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.

       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.

       ggrraapphh--sseelleecctt (())
              Equivalent to sseelleecctt, but also updates the  current
              argument.

       ggrraapphh--sseelleecctt--oorr--mmoovvee (())
              Equivalent  to sseelleecctt--oorr--mmoovvee, but also updates the
              current argument.

       ggrraapphh--eexxtteenndd (())
              Equivalent to eexxtteenndd, but also updates the  current
              argument.

       ggrraapphh--eexxtteenndd--oorr--mmoovvee (())
              Equivalent  to eexxtteenndd--oorr--mmoovvee, but also updates the
              current argument.

       ggrraapphh--ttooggggllee (())
              Equivalent to ttooggggllee, but also updates the  current
              argument.

       ggrraapphh--ttooggggllee--oorr--mmoovvee (())
              Equivalent  to ttooggggllee--oorr--mmoovvee, but also updates the
              current argument.

       ggrraapphh--ppooppuupp--mmeennuu (([ggrraapphh|nnooddee|sshhoorrttccuutt]))
              Pops up a menu.  ggrraapphh pops up a menu  with  global
              graph  operations,  nnooddee  pops  up a menu with node
              operations, and sshhoorrttccuutt pops up a menu  with  dis-
              play shortcuts.  If no argument is given, pops up a
              menu depending on the context: when pointing  on  a
              node  with  the  SShhiifftt  key  pressed,  behaves like
              sshhoorrttccuutt; when pointing on a without the SShhiifftt  key
              pressed,  behaves  like nnooddee; otherwise, behaves as
              if ggrraapphh was given.




DDD 2.2.3                   1998-01-26                         64





ddd(1)                                                     ddd(1)


       ggrraapphh--ddeerreeffeerreennccee (())
              Dereference the selected display.

       ggrraapphh--ddeettaaiill (())
              Show or hide detail of the selected display.

       ggrraapphh--rroottaattee (())
              Rotate the selected display.

       ggrraapphh--ddeeppeennddeenntt (())
              Pop up a dialog to create a dependent display.

       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.





DDD 2.2.3                   1998-01-26                         65





ddd(1)                                                     ddd(1)


       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.

       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++\\.



DDD 2.2.3                   1998-01-26                         66





ddd(1)                                                     ddd(1)


       ggddbb--ccoommmmaanndd ((_c_o_m_m_a_n_d))
              Execute _c_o_m_m_a_n_d in the debugger console.

       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.

       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 TTAABB completion is enabled, complete cur-
              rent argument as if _c_o_m_m_a_n_d was prepended.   Other-
              wise,  proceed as if the TTAABB 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--pprroocceessss (())
              Process  the  given  event in the debugger console.
              Bound to key events in the source and data  window.

       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
              `(())'.



DDD 2.2.3                   1998-01-26                         67





ddd(1)                                                     ddd(1)


       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.

   SSoouurrccee WWiinnddooww AAccttiioonnss
       These actions are used in the source and code windows.

       ssoouurrccee--ppooppuupp--mmeennuu (())
              Pop up a menu, depending on the location.

       ssoouurrccee--ssttaarrtt--sseelleecctt--wwoorrdd (())
              Start selecting a word.

       ssoouurrccee--eenndd--sseelleecctt--wwoorrdd (())
              End selecting a word.

       ssoouurrccee--uuppddaattee--ggllyypphhss (())
              Update all visible glyphs.  Usually invoked after a
              scrolling operation.

       ssoouurrccee--ddrraagg--ggllyypphh (())
              Initiate a drag on the glyph at cursor position.

       ssoouurrccee--ffoollllooww--ggllyypphh (())
              Continue a drag on the glyph  at  cursor  position.
              Usually bound to some motion event.

       ssoouurrccee--ddrroopp--ggllyypphh (())
              Drop the dragged glyph at cursor position.

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



DDD 2.2.3                   1998-01-26                         68





ddd(1)                                                     ddd(1)


              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""

              If  you  use  the `----ddeebbuuggggeerr' option, be sure that
              the type of inferior debugger is specified as well.
              That  is,  use one of the options `----ggddbb', `----ddbbxx',
              or `----xxddbb'--unless the default setting works  fine.

       ----ddiissaasssseemmbbllee
              Disassemble  the  source code.  See also the `----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



DDD 2.2.3                   1998-01-26                         69





ddd(1)                                                     ddd(1)


              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.  By default, both the debugger
              console and source window are disabled.

       ----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 [_u_s_e_r_n_a_m_e@@]_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.   If  _u_s_e_r_n_a_m_e  is  given  and  the
              `----llooggiinn' option  is  not  used,  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.

       ----lleessssttiiff--hhaacckkss
              Equivalent  to  `----lleessssttiiff--vveerrssiioonn  _v_e_r_s_i_o_n', where
              _v_e_r_s_i_o_n is the version of the most  recent  LessTif
              release.  Deprecated.

       ----lleessssttiiff--vveerrssiioonn _v_e_r_s_i_o_n
              Enable  some  hacks  to  make DDD run properly with
              LessTif.  See  the  `lleessssTTiiffVVeerrssiioonn'  resource  and
              `UUSSIINNGG  DDDDDD WWIITTHH LLEESSSSTTIIFF', above, for a discussion.

       ----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neewwss Show the DDD news 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.2.3                   1998-01-26                         70





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
              Equivalent  to  `----lleessssttiiff--vveerrssiioonn  11000000'.   Depre-
              cated.

       ----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 [_u_s_e_r_n_a_m_e@@]_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.  If _u_s_e_r_n_a_m_e is given and the
              `----llooggiinn' option  is  not  used,  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.

       ----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.





DDD 2.2.3                   1998-01-26                         71





ddd(1)                                                     ddd(1)


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

       ----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.   By
              default, the debugger console is disabled.

       ----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.

EENNVVIIRROONNMMEENNTT
       DDD is controlled by the following environment variables:
       DDDDDD__NNOO__SSIIGGNNAALL__HHAANNDDLLEERRSS
                           If  set,  DDD  does  not  catch  fatal



DDD 2.2.3                   1998-01-26                         72





ddd(1)                                                     ddd(1)


                           errors.  This is sometimes useful when
                           debugging DDD.
       DDDDDD__SSTTAATTEE           Root  of DDD state directory.  Default
                           is `$$HHOOMMEE//..dddddd//'.
       DDDDDD__SSEESSSSIIOONN         If set, indicates a session to  start,
                           overriding  all options.  This is used
                           by DDD when restarting itself.
       DDDDDD__SSEESSSSIIOONNSS        DDD  session  directory.   Default  is
                           `$$DDDDDD__SSTTAATTEE//sseessssiioonnss//'.
       VVSSLL__IINNCCLLUUDDEE         Where to search for VSL include files.
                           Default is the current directory.  The
                           following  environment  variables  are
                           set by DDD:
       DDDDDD__NNAAMMEE            Set to a  string  indicating  the  DDD
                           version.   By testing whether DDDDDD__NNAAMMEE
                           is set, a debuggee (or inferior debug-
                           ger)  can  determine  whether  it  was
                           invoked by DDD.
       TTEERRMM                Set to `dduummbb', the DDD terminal  type.
                           This  is set for the inferior debugger
                           only.  If the debuggee runs in a sepa-
                           rate  execution window, the debuggee's
                           TTEERRMM value is  set  according  to  the
                           `tteerrmmTTyyppee' ressource (see `RREESSOOUURRCCEESS',
                           above).
       TTEERRMMCCAAPP             Set to `'  (none),  the  DDD  terminal
                           capabilities.
       PPAAGGEERR               Set to `ccaatt', the preferred DDD pager.

FFIILLEESS
       $$HHOOMMEE//..dddddd//         DDD state directory.
       $$HHOOMMEE//..dddddd//i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//..dddddd//lloocckk     DDD lock file; indicates that a DDD is
                           running.
       $$HHOOMMEE//..dddddd//lloogg      Trace  of  the   current   interaction
                           between DDD and the inferior debugger.
       $$HHOOMMEE//..dddddd//sseessssiioonnss//
                           DDD session directory.  One  subdirec-
                           tory per session.
       $$HHOOMMEE//..dddddd//sseessssiioonnss//_s_e_s_s_i_o_n//ddddddccoorree
                           DDD core file for _s_e_s_s_i_o_n.
       $$HHOOMMEE//..dddddd//sseessssiioonnss//_s_e_s_s_i_o_n//iinniitt
                           DDD resource file for _s_e_s_s_i_o_n.
       $$HHOOMMEE//..dddddd//sseessssiioonnss//_s_e_s_s_i_o_n//hhiissttoorryy
                           DDD command history for _s_e_s_s_i_o_n.
       $$HHOOMMEE//..dddddd//sseessssiioonnss//..dddddd//
                           The DDD `restart' session.
       $$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.
       $$HHOOMMEE//..xxddbbrrcc        XDB initialization file.
       $$HHOOMMEE//..ddddddiinniitt      Old-style   DDD  initialization  file;



DDD 2.2.3                   1998-01-26                         73





ddd(1)                                                     ddd(1)


                           used only if $$HHOOMMEE//..dddddd//iinniitt does  not
                           exist.

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 Ltkehaus, Computer Science
       Report 95-07, Technische Universitt 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 Ltkehaus, Diploma Thesis, Technische Universitt
       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 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  malfunctions,
       especially in the data display.

       When  debugging  at  the  machine  level with GDB 4.12 and



DDD 2.2.3                   1998-01-26                         74





ddd(1)                                                     ddd(1)


       earlier as inferior debugger, use a `ddiissppllaayy //xx $$ppcc'  com-
       mand  to  ensure the program counter value is updated cor-
       rectly 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.   This  problem can be avoided by running the program
       in the separate execution window.

       Output that confuses DDD includes:

       +o Primary debugger prompts (e.g. `((ggddbb)) ' or `((ddbbxx)) ')

       +o Secondary debugger prompts (e.g. `>>')

       +o Confirmation prompts (e.g. `((yy oorr nn)) ')

       +o Prompts for more output  (e.g.  `PPrreessss  RREETTUURRNN  ttoo  ccoonn--
         ttiinnuuee')

       +o Display output (e.g. `$$ppcc == 00xx11223344')

       If  your  program outputs any of these strings, you should



DDD 2.2.3                   1998-01-26                         75





ddd(1)                                                     ddd(1)


       run it in 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.

FFRREEQQUUEENNTTLLYY AASSKKEEDD QQUUEESSTTIIOONNSS ((FFAAQQ))
   WWhhiicchh ddeebbuuggggeerrss ddooeess DDDDDD ssuuppppoorrtt??
       DDD has been tested with the following debuggers:

       +o GDB (GNU debugger) from the Free Software Foundation

       +o DBX as found on SunOS 4.x (aka Solaris 1.x)

       +o DBX as found on Solaris 2.x (aka SunOS 5.x)

       +o DBX as found on DEC systems (some variants only)

       +o DBX as found on AIX systems (some variants only)

       +o DBX as found on SGI systems (some variants only)

       +o XDB as found on HP-UX systems

       DDD functionality largely depends on the  capabilities  of
       the  underlying  debugger;  best results are obtained with
       GDB.

       To cope with the large variety of DBX flavors, DDD  deter-
       mines  the  DBX  capabilities dynamically at run-rime; DDD
       should thus adapt automatically  to  other  DBX  variants.
       Please  let us know your experiences; use `dddddd ----ttrraaccee' to
       see the DDD/DBX interaction.

   CCaann II uussee DDDDDD wwiitthh AAddaa??
       Matthew Majka  <mmmmaajjkkaa@@ccss55..ddaassdd..hhoonneeyywweellll..ccoomm>  says:   It
       works  very  well.   You just need an Ada-aware version of
       GDB.      You     can     get     the     patches     from
       `ffttpp::////ccss..nnyyuu..eedduu//ppuubb//ggnnaatt//ggddbb//'.

   IIss tthheerree aann AAtthheennaa WWiiddggeettss ppoorrtt ooff DDDDDD??
       No.   If  you want DDD running with a free widget set, you
       should support the Hungry Programmer's Team - they develop
       LessTif,  a  free  Motif-compliant  widget set.  Check out
       their WWW page at `hhttttpp::////wwwwww..lleessssttiiff..oorrgg//'.

   WWiillll DDDDDD wwoorrkk wwiitthh LLeessssTTiiff??
       As of LessTif 0.81, the resulting DDD executable is  quite
       usable;  there  are  several DDD users who use a DDD built
       with LessTif.  See the file `PROBLEMS' for a  recent  list
       of problems and fixes.




DDD 2.2.3                   1998-01-26                         76





ddd(1)                                                     ddd(1)


   SShhoouulldd II ccoommppiillee DDDDDD mmyysseellff oorr sshhoouulldd II uussee aann eexxeeccuuttaabbllee??
       Compiling  DDD  on  your  machine  is  the  preferred way,
       because the resulting DDD  executable  will  be  perfectly
       adapted to your system.  However, if your production envi-
       ronment is buggy, or if you lack the resources for compil-
       ing  DDD,  a  thoroughly tested precompiled DDD executable
       may be a better choice.

   HHooww ccaann II ddiissppllaayy aa vvaarriiaabbllee--lleennggtthh aarrrraayy??
       The problem is that GDB does not know the actual length of
       the  array;  you have to supply it by hand (i.e. using the
       keyboard).  You can use the DDD "display successive  array
       elements" or the GDB "artificial array" mechanism.  If you
       have a pointer, say:

         iinntt **ppii;;

       pointing to an array of 10 ints, you can see the  integers
       by entering

         ggrraapphh ddiissppllaayy ppii[[00....99]]

       at the debugger prompt (or entering `ppii[[00....99]]` in the `NNeeww
       DDiissppllaayy' dialog).

       As an alternative, you can use the GDB "artificial  array"
       mechanism by entering

         ggrraapphh ddiissppllaayy ppii[[00]]@@1100

       This  will  create  an  array starting with ppii showing the
       first 10 elements.

   MMyy wwiinnddooww mmaannaaggeerr ccrraasshheess wwhheenn rruunnnniinngg DDDDDD!!
       This is due to a bug in the window manager.  You  may  try
       the  following resources in your `$$HHOOMMEE//..dddddd//iinniitt' file to
       minimize interference with the window manager;  the  first
       ones  listed  are  the  ones that are most likely to cause
       interferences.

         DDdddd**ccoolloorrIIccoonnss::         ffaallssee
         DDdddd**aauuttooRRaaiisseeMMeennuu::      ffaallssee
         DDdddd**ggrroouuppIIccoonniiffyy::       ffaallssee
         DDdddd**uunniiccoonniiffyyWWhheennRReeaaddyy:: ffaallssee
         DDdddd**sshhoowwSSttaarrttuuppLLooggoo::
         DDdddd**aauuttooRRaaiisseeTTooooll::      ffaallssee
         DDdddd**ssttiicckkyyTTooooll::         ffaallssee
         DDdddd**ddeeccoorraatteeddTTooooll::      ffaallssee

       See  `RREESSOOUURRCCEESS',  above,  for  a  discussion   of   these
       resources.






DDD 2.2.3                   1998-01-26                         77





ddd(1)                                                     ddd(1)


   MMyy XX ddiissppllaayy ffrreeeezzeess wwhheenn rruunnnniinngg DDDDDD!!
       This  is due to a bug in Motif.  You may try the following
       resources  in  your  `$$HHOOMMEE//..dddddd//iinniitt'  file  to  minimize
       interference with Motif:

         DDdddd**aauuttooRRaaiisseeMMeennuu::      ffaallssee
         DDdddd**uunnggrraabbMMoouusseePPooiinntteerr:: ffaallssee

       See   `RREESSOOUURRCCEESS',   above,  for  a  discussion  of  these
       resources.


   HHooww ddoo II ppaassss ^^CC ttoo tthhee ddeebbuuggggeedd pprrooggrraamm??
       Assuming you use GDB as inferior debugger, typing  `signal
       2'  at  the  `((ggddbb))'  prompt will resume program execution
       with a SSIIGGIINNTT signal.

       If it's the character rather than the signal you're inter-
       ested  in, run your program in the separate execution win-
       dow (via `VViieeww || EExxeeccuuttiioonn WWiinnddooww') and type CCttrrll++CC there.

   IInn CC++++,, hhooww ddoo II sseeee tthhee _a_c_t_u_a_l ttyyppee ooff aann oobbjjeecctt??
       When  using  a  generic  pointer,  you may wish to see the
       _a_c_t_u_a_l type of an object rather than  the  _d_e_c_l_a_r_e_d  type.
       In  the  GDB settings (`EEddiitt || GGDDBB SSeettttiinnggss'), enable `SSeett
       pprriinnttiinngg ooff oobbjjeecctt''ss ddeerriivveedd ttyyppee bbaasseedd oonn vvttaabbllee iinnffoo' or
       enter `sseett pprriinntt oobbjjeecctt oonn' at the `((ggddbb))' prompt.

   II  wwaanntt ttoo uussee DDDDDD iinntteerrpprroocceessss ccoommmmuunniiccaattiioonn iinn mmyy oowwnn aappppllii--
       ccaattiioonn!!
       There is a demonstration program named  `ttttyytteesstt'  in  the
       DDD package.  Just type `mmaakkee ttttyytteesstt'.  It should be rel-
       atively easy to customize this application.

       Here are some pointers: If you want to talk with  a  sepa-
       rate  process,  use  the  `TTTTYYAAggeenntt'  class, as defined in
       `TTTTYYAAggeenntt..CC'.  Using the  `wwrriittee'  method,  you  can  send
       arbitrary  data  to the process; you can define an `IInnppuutt'
       handler that will be called each time  the  process  sends
       data  to  you.   The  header  files  of `TTTTYYAAggeenntt' and its
       superclasses should contain  sufficient  information.   As
       all communication is handled asynchronously, you can real-
       ize a usual Xt-based interface using Athena widgets, Motif
       widgets, or another Xt-based toolkit.

   II wwaanntt ttoo uussee tthhee DDDDDD ggrraapphh eeddiittoorr iinn mmyy oowwnn aapppplliiccaattiioonn!!
       There is a demonstration program named `tteesstt--ggrraapphh' in the
       DDD source distribution.  Just type `make tteesstt--ggrraapphh'.  It
       should be relatively easy to customize this application.

       Here are some pointers: The `GGrraapphhEEddiitt' widget, as defined
       in `GGrraapphhEEddiitt..hh' contains the DDD graph editor.   Variants
       with  Athena  panners  and  Motif  scrollbars are found in
       `PPaannnneeddGGEE..hh'  and   `SSccrroolllleeddGGEE..hh',   respectively.    The



DDD 2.2.3                   1998-01-26                         78





ddd(1)                                                     ddd(1)


       `GGrraapphhEEddiitt'  widget works on a `GGrraapphh' structure, which is
       defined in `GGrraapphh..hh'; a graph is  composed  of  nodes  and
       edges,  both  forming  class hierarchies whose top classes
       are defined in `GGrraapphhNNooddee..hh'  and  `GGrraapphhEEddggee..hh',  respec-
       tively.   The  graph  nodes  in  DDD  are Box graph nodes,
       defined in `BBooxxGGrraapphhNN..hh'; a box is a (possibly structured)
       rectangular  entity  holding  strings,  lines, or figures.
       See also the DDD paper `ddoocc//dddddd--ppaappeerr..ppss' for  details  on
       boxes and how they are composed.

   HHooww ccaann II ssppeeeedd uupp DDDDDD??
       To get the maximum DDD performance,

       +o Use  the  latest DDD version, compiled with optimization
         enabled.

       +o Enable caching of source code and machine code.

       +o Disable glyphs.

       +o Disable machine code.

       +o Disable alias detection.

       +o Disable all status displays.

       +o Delete all displays you do not need.

       +o Do not use remote debugging.


   HHooww ccaann II rreedduuccee DDDDDD mmeemmoorryy ssiizzee??
       To get a minimal DDD memory usage,

       +o Use DDD 2.2 or later (30% memory savings)

       +o Hack DDD such that this manual and  the  resource  files
         are  stored  externally.  (Make it configurable and send
         us your changes)


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



DDD 2.2.3                   1998-01-26                         79





ddd(1)                                                     ddd(1)


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

         Technische Universitt Braunschweig
         Institut fr Programmiersprachen
         und Informationssysteme
         Abteilung Softwaretechnologie
         DDD-Bugs
         Bltenweg 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 interaction between DDD  and  the  inferior
       debugger  on  standard  error while DDD is running.  (This
       interaction is also logged in  `$$HHOOMMEE//..dddddd//lloogg'.)  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
         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



DDD 2.2.3                   1998-01-26                         80





ddd(1)                                                     ddd(1)


         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 A  _l_o_g  _f_i_l_e showing the interaction between DDD and the
         inferior  debugger.   This  interaction  is  logged   by
         default  in  `$$HHOOMMEE//..dddddd//lloogg'.  Include all trace output
         from the DDD invocation up to the first bug  occurrence.

       +o If  you  wish to suggest changes to the DDD source, send
         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



DDD 2.2.3                   1998-01-26                         81





ddd(1)                                                     ddd(1)


       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___t_k_e_h_a_u_s (now _D_o_r_o_t_h_e_a _K_r_a_b_i_e_l_l) realized
       DDD as her Diploma Thesis, 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 comments in the DDD
       source 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
       November, 1997      DDD  2.2: Persistent sessions, display
                           shortcuts.

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.

DDDDDD NNEEEEDDSS YYOOUURR SSUUPPPPOORRTT!!
       DDD  needs  your support!  If you have any success stories
       related to DDD, please write them down on a picture  post-
       card and send them to us:

         Technische Universitt Braunschweig
         Institut fr Programmiersprachen
         und Informationssysteme
         Abteilung Softwaretechnologie
         Bltenweg 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// .



DDD 2.2.3                   1998-01-26                         82





ddd(1)                                                     ddd(1)


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,  1998  Technische
       Universitt 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
       from within DDD, use `HHeellpp || DDDDDD LLiicceennssee'.

       This  DDD  manual  page is Copyright (C) 1995, 1996, 1997,
       1998 Technische Universitt 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.



DDD 2.2.3                   1998-01-26                         83





ddd(1)                                                     ddd(1)


       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.2.3                   1998-01-26                         84


