


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    [----ggddbb] [----ddbbxx] [----xxddbb] [----jjd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 [_u_s_e_r_n_a_m_e@@]_h_o_s_t_n_a_m_e]]
              [----rrhhoosstt [_u_s_e_r_n_a_m_e@@]_h_o_s_t_n_a_m_e]] [----ttrraaccee] [----nnww]
              [----ttttyy] [----ffuullllnnaammee] [----hheellpp] [----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
       comfortable _g_r_a_p_h_i_c_a_l _u_s_e_r _i_n_t_e_r_f_a_c_e  around  an  inferior
       GDB, DBX, XDB, or JDB debugger.

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:

         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:




DDD 3.0                     1998-06-17                          1





ddd(1)                                                     ddd(1)


         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_r_o_g_r_a_m

       or

         dddddd ----xxddbb _p_r_o_g_r_a_m

       or

         dddddd ----jjddbb _c_l_a_s_s

       to run DBX or XDB or JDB 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
   TThhee DDDDDD MMaaiinn 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 places these main windows stacked into one
       single top-level 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 3.0                     1998-06-17                          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.

   UUssiinngg tthhee CCoommmmaanndd TTooooll
       The command tool is a small window  containing  frequently
       used  DDD  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.  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  is also _a_u_t_o_-_r_a_i_s_e_d, such that it stays on top
       of other DDD windows.

       The command tool can be configured to appear as a  command
       tool     bar     above     the    source    window;    see
       `EEddiitt-->>PPrreeffeerreenncceess-->>SSoouurrccee-->>TTooooll  BBuuttttoonnss  LLooccaattiioonn'   for
       details.


   UUssiinngg tthhee TTooooll BBaarr
       Some  DDD  commands require an _a_r_g_u_m_e_n_t.  This argument is
       specified in the _a_r_g_u_m_e_n_t  _f_i_e_l_d,  labeled  `(())::'.   Basi-
       cally, there are four ways to set arguments:

       +o You can _k_e_y _i_n the argument manually.

       +o You  can  _p_a_s_t_e  the current selection into the argument
         field (typically using _m_o_u_s_e _b_u_t_t_o_n _2).   To  clear  old
         contents beforehand, click on the `(())::' label.

       +o You can _s_e_l_e_c_t _a_n _i_t_e_m from the source and data windows.
         This will automatically copy the item  to  the  argument
         field.

       +o You can select a _p_r_e_v_i_o_u_s_l_y _u_s_e_d _a_r_g_u_m_e_n_t from the drop-
         down menu at the right of the argument field.

       Using GDB, the argument field provides a completion mecha-
       nism.   You  can enter the first few characters of an item
       an press the `TAB' key to  complete  it.   Pressing  `TAB'
       again shows alternative completions.



DDD 3.0                     1998-06-17                          3





ddd(1)                                                     ddd(1)


       After  having  entered  an argument, you can select one of
       the buttons on the right.  Most of these buttons also have
       menus  associated  with them; this is indicated by a small
       arrow in the upper right  corner.   Pressing  and  holding
       _m_o_u_s_e  _b_u_t_t_o_n  _1  on such a button will pop up a menu with
       further operations.


GGEETTTTIINNGG HHEELLPP
       DDD has an extensive on-line help system.  Here's  how  to
       get help while working with DDD.

   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
       point  on  the  item you want help and press the `FF11' key.
       This 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 debugger commands by entering `hheellpp'
       at the debugger 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 CCttrrll++FF11.  Depending
       on the current state, DDD will give you some hints on what
       you can do.

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



DDD 3.0                     1998-06-17                          4





ddd(1)                                                     ddd(1)


       In JDB, select `FFiillee-->>OOppeenn CCllaassss' instead.  This gives you
       a list of available classes to choose from.

       To re-open a recently debugged program  or  class,  select
       `FFiillee-->>OOppeenn RReecceenntt' and choose a program or class from the
       list.

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

       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 generated
       the core dump and to load its symbol table.

       To  open  a  source  file  of the debugged program, select
       `FFiillee-->>OOppeenn SSoouurrccee'.

       +o Using GDB, this gives you a list of the sources used for
         compiling your program.

       +o Using other inferior debuggers, this gives you a list of
         accessible source files, which may or may not be related
         to your program.


LLOOOOKKIINNGG UUPP IITTEEMMSS
       As  soon  as  the source of the debugged program is avail-
       able, 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 `EEddiitt-->>GGDDBB SSeett--
       ttiinnggss' 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
       name  is  copied to the argument field.  Alter the name if
       desired and click on the `LLooookkuupp (())' button  to  find  its
       definition.


       As a faster 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.

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



DDD 3.0                     1998-06-17                          5





ddd(1)                                                     ddd(1)


       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
       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 a faster 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kppooiinntt' item from the line popup menu.


       As an even faster alternative, you can sinply double-click
       on the left of the source line to set a breakpoint.

       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 `BBrreeaakk' button and  enter  the
       location.

       (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.  A greyed out
       stop sign (or `___n__') indicates a disabled  breakpoint.   A
       stop sign with a question mark (or `??_n??') indicates a con-
       ditional breakpoint or a breakpoint with an  ignore  count
       set.

       Note:  We  have  received reports that some Motif versions
       fail to display stop signs correctly.   If  this  happens,
       try writing in your `$$HHOOMMEE//..dddddd//iinniitt' file:




DDD 3.0                     1998-06-17                          6





ddd(1)                                                     ddd(1)


         DDdddd**ccaacchheeGGllyypphhIImmaaggeess:: ooffff

       and restart DDD.  See also the `ccaacchheeGGllyypphhIImmaaggeess' resource
       in the `RREESSOOUURRCCEESS' section, below.

   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  yet  another  alternative, you can click on `NNeeww' from
       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') and enter the function name.

   SSeettttiinngg RReeggeexxpp BBrreeaakkppooiinnttss
       Using  GDB, you can also set a breakpoint on all functions
       that match a given string.  `BBrreeaakk aatt (())-->>SSeett  BBrreeaakkppooiinnttss
       aatt  RReeggeexxpp  (())'  sets  a breakpoint on all functions whose
       name matches the _r_e_g_u_l_a_r _e_x_p_r_e_s_s_i_o_n given in  `(())'.   Here
       are some examples:

       +o To  set  a breakpoint on every function that starts with
         `XXmm', set `(())' to `^^XXmm'.

       +o To set a breakpoint on every member of class `DDaattee', set
         `(())' to `^^DDaattee::::'.

       +o To  set  a  breakpoint on every function whose name con-
         tains `__ffuunn', set `(())' to `__ffuunn'.

       +o To set a breakpoint  on  every  function  that  ends  in
         `__tteesstt', set `(())' to `__tteesstt$$'.

       Once  these multiple breakpoints are set, they are treated
       just like the breakpoints set with the `BBrreeaakk aatt (())'  but-
       ton.  You can delete them, disable them, or make them con-
       ditional the  same  way  as  any  other  breakpoint.   Use
       `SSoouurrccee-->>EEddiitt  BBrreeaakkppooiinnttss'  to  view and edit the list of
       breakpoints.

   DDiissaabblliinngg BBrreeaakkppooiinnttss
       To temporarily disable a breakpoint, press _m_o_u_s_e _b_u_t_t_o_n  _3
       on  the  breakpoint  symbol and select the `DDiissaabbllee BBrreeaakk--
       p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



DDD 3.0                     1998-06-17                          7





ddd(1)                                                     ddd(1)


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

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

       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.

       Note: JDB does not support breakpoint disabling.

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

       Note: JDB does not support temporary breakpoints.

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

   EEddiittiinngg BBrreeaakkppooiinntt PPrrooppeerrttiieess
       You  can change all properties of a breakpoint by pressing



DDD 3.0                     1998-06-17                          8





ddd(1)                                                     ddd(1)


       _m_o_u_s_e _b_u_t_t_o_n _3 on the breakpoint symbol and select  `PPrroopp--
       eerrttiieess'  from the breakpoint popup menu.  This will pop up
       a dialog showing the current properties  of  the  selected
       breakpoint.

       As an even faster alternative, you can sinply double-click
       on the breakpoint.



       +o Click on `LLooookkuupp' to move the cursor to the breakpoint's
         location.

       +o Click on `EEnnaabbllee' to enable the breakpoint.

       +o Click on `DDiissaabbllee' to disable the breakpoint.

       +o Click on `TTeemmpp' to make the breakpoint temporary.  Note:
         GDB+2 provides no way to  make  a  temporary  breakpoint
         non-temporary.

       +o Click on `DDeelleettee' to delete the breakpoint.


   BBrreeaakkppooiinntt CCoonnddiittiioonnss
       In  the  field  `CCoonnddiittiioonn' of the `BBrreeaakkppooiinntt PPrrooppeerrttiieess'
       panel, you can  specify  a  _b_r_e_a_k_p_o_i_n_t  _c_o_n_d_i_t_i_o_n.   If  a
       breakpoint condition is set, the breakpoint stops the pro-
       gram only if the associated condition is met--that is,  if
       the condition expression evaluates to a non-zero value.

       Note: JDB does not support breakpoint conditions.

   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
       In the field `IIggnnoorree CCoouunntt' of the `BBrreeaakkppooiinntt PPrrooppeerrttiieess'
       panel, you can specify a _b_r_e_a_k_p_o_i_n_t _i_g_n_o_r_e _c_o_u_n_t.  If  the
       ignore  count is set to some value _N, the next _N crossings
       of the breakpoint will be ignored: Each  crossing  of  the
       breakpoint  decrements the ignore count; the program stops
       only if the ignore count is zero.

       Note: JDB and some DBX variants do not support  breakpoint
       ignore counts.

   BBrreeaakkppooiinntt CCoommmmaannddss
       Note:  Breakpoint  commands are currently available on GDB
       only.

       Using the `CCoommmmaannddss' buttons of  the  `BBrreeaakkppooiinntt  PPrrooppeerr--
       ttiieess'  panel,  you can record and edit commands to be exe-
       cuted when the breakpoint is hit.

       To record a command sequence, follow these steps:




DDD 3.0                     1998-06-17                          9





ddd(1)                                                     ddd(1)


       +o Click on `RReeccoorrdd' to begin the recording of  the  break-
         point commands.

       +o Now  interact  with  DDD.  While recording, DDD does not
         execute commands, but simply records them to be executed
         when  the breakpoint is hit.  The recorded debugger com-
         mands are shown in the debugger console.

       +o To stop the recording, click on `EEnndd' or enter `eenndd'  at
         the  GDB  prompt.   To  _c_a_n_c_e_l  the  recording, click on
         `IInntteerrrruupptt' or press EEsscc.

       +o Click on `EEddiitt >>>>' to edit the recorded commands.   When
         done  with editing, click on `EEddiitt <<<<' to close the com-
         mands editor.


   MMoovviinngg aanndd CCooppyyi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.

       To  copy  a  breakpoint to a new location, press the SShhiifftt
       key while dragging.

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

   LLooookkiinngg uupp 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.

   EEddiittiinngg aallll BBrreeaakkppooiinnttss
       To  view  and  edit  all  breakpoints  at   once,   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'.   This  will popup the _B_r_e_a_k_-
       _p_o_i_n_t _E_d_i_t_o_r which displays the state of all  breakpoints.


       In the breakpoint editor, you can select individual break-
       points by clicking on them.  Pressing CCttrrll while  clicking
       toggles  the  selection.   To  edit  the properties of all
       selected breakpoints, click on `PPrrooppss'.

   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
       Using GDB, a few more commands related to breakpoints  can



DDD 3.0                     1998-06-17                         10





ddd(1)                                                     ddd(1)


       be invoked through the debugger console:

       hhbbrreeaakk _p_o_s_i_t_i_o_n
                 Sets a hardware-assisted breakpoint at _p_o_s_i_t_i_o_n.
                 This command requires hardware support and  some
                 target  hardware may not have this support.  The
                 main purpose of this is  EPROM/ROM  code  debug-
                 ging, so you can set a breakpoint at an instruc-
                 tion without changing the instruction.

       tthhbbrreeaakk _p_o_s
                 Set a temporary hardware-assisted breakpoint  at
                 _p_o_s.

       See the GDB documentation for details on these commands.

WWAATTCCHHPPOOIINNTTSS
       You  can  make  the  program stop as soon as some variable
       value changes, or when some variable is read  or  written.
       This is called `setting a _w_a_t_c_h_p_o_i_n_t on a variable'.

       Watchpoints  have much in common with breakpoints: in par-
       ticular, you can enable and disable them.   You  can  also
       set conditions, ignore counts, and commands to be executed
       when a watched variable changes its value.

       Please note: on architectures without  special  watchpoint
       support,  watchpoints  currently  make the program execute
       two orders of magnitude more slowly.  This is  so  because
       the  inferior  debugger  must  interrupt the program after
       each machine instruction in order to examine  whether  the
       watched  value  has  changed.   However, this delay can be
       well worth it to catch errors when you have no  clue  what
       part of your program is the culprit.

       Note:  Watchpoints are available in GDB and some DBX vari-
       ants only.  In XDB, a similar feature is available via XDB
       _a_s_s_e_r_t_i_o_n_s; see the XDB documentation for details.

   SSeettttiinngg WWaattcchhppooiinnttss
       If the variable name is visible, click with _m_o_u_s_e _b_u_t_t_o_n _1
       on the variable name.  The variable name is copied to  the
       argument field.  Otherwise, enter the variable name in the
       argument field.  Click on the `WWaattcchh (())' button to  set  a
       watchpoint there.

       Using  GDB,  you  can  set different types of watchpoints.
       Click and hold _m_o_u_s_e _b_u_t_t_o_n _1 on the `WWaattcchh (())' button  to
       get a menu.

   EEddiittiinngg WWaattcchhppooiinntt PPrrooppeerrttiieess
       To  change  the properties of a watchpoint, enter the name
       of the watched variable in the argument field.  Click  and
       hold  _m_o_u_s_e  _b_u_t_t_o_n  _1 on the `WWaattcchh (())' button and select



DDD 3.0                     1998-06-17                         11





ddd(1)                                                     ddd(1)


       `WWaattcchhppooiinntt PPrrooppeerrttiieess'.

       The WWaattcchhppooiinntt PPrrooppeerrttiieess panel has the same functionality
       as  the  BBrreeaakkppooiinntt  PPrrooppeerrttiieess panel; see `EEddiittiinngg BBrreeaakk--
       ppooiinntt PPrrooppeerrttiieess', above, for details.  As  an  additional
       feature,  you  can  click on `PPrriinntt (())' to see the current
       value of a watched variable.

   EEddiittiinngg aallll WWaattcchhppooiinnttss
       To  view  and  edit  all  watchpoints  at   once,   select
       `DDaattaa-->>EEddiitt  WWaattcchhppooiinnttss'.  This will popup the _W_a_t_c_h_p_o_i_n_t
       _E_d_i_t_o_r which displays the state of all watchpoints.

       The _W_a_t_c_h_p_o_i_n_t _E_d_i_t_o_r has the same  functionality  as  the
       _B_r_e_a_k_p_o_i_n_t  _E_d_i_t_o_r;  see `EEddiittiinngg AAllll BBrreeaakkppooiinnttss', above,
       for details.  As an additional feature, you can  click  on
       `PPrriinntt (())' to see the current value of a watched variable.

   DDeelleettiinngg WWaattcchhppooiinnttss
       To delete a watchpoint, enter  the  name  of  the  watched
       variable  in the argument field and click the `UUnnwwaattcchh (())'
       button.

RRUUNNNNIINNGG TTHHEE PPRROOGGRRAAMM
   SSttaarrttiinngg PPrrooggrraamm EExxeeccuuttiioonn
       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 pass 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 com-
       mand  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ut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
       `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



DDD 3.0                     1998-06-17                         12





ddd(1)                                                     ddd(1)


       modify 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  con-
       tinue;  you  can  modify  storage. If you would rather the
       process continue 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 by  defining
       an    alternate    command   to   list   processes.    See
       `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-->>LLiisstt PPrroocceesssseess'.

       Note: JDB does not support attaching to processes.

   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 EEssc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'
       section, above, for a discussion.




DDD 3.0                     1998-06-17                         13





ddd(1)                                                     ddd(1)


   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.

       Note:  JDB  does  not support altering the execution posi-
       tion.

   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 3.0                     1998-06-17                         14





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

       Using JDB, additional functionality is available:

       +o Select a  _t_h_r_e_a_d_g_r_o_u_p  to  switch  between  viewing  all
         threads and the threads of the selected threadgroup;

       +o Click  on `SSuussppeenndd' to suspend execution of the selected
         threads;

       +o Click on `RReessuummee' to resume execution  of  the  selected
         threads.

       For more information on threads, see the JDB and GDB docu-
       mentation.

   HHaannddlliinngg SSiiggnnaallss
       Note: Signal support is available with GDB only.

       A signal is an asynchronous event that  can  happen  in  a
       program.   The operating system defines the possible kinds
       of signals, and gives each kind a name and a number.   For
       example,  in Unix SSIIGGIINNTT is the signal a program gets when
       you type an interrupt; SSIIGGSSEEGGVV is  the  signal  a  program
       gets  from referencing a place in memory far away from all
       the areas in use; SSIIGGAALLRRMM  occurs  when  the  alarm  clock
       timer  goes  off  (which  happens only if your program has
       requested an alarm).

       Some signals, including SSIIGGAALLRRMM, are a normal part of  the
       functioning  of  your  program.   Others, such as SSIIGGSSEEGGVV,
       indicate errors; these signals are _f_a_t_a_l (kill  your  pro-
       gram  immediately)  if  the  program  has not specified in



DDD 3.0                     1998-06-17                         15





ddd(1)                                                     ddd(1)


       advance some other way to handle the signal.  SSIIGGIINNTT  does
       not  indicate an error in your program, but it is normally
       fatal so it can carry out the purpose of the interrupt: to
       kill the program.

       GDB  has  the ability to detect any occurrence of a signal
       in your program.  You can tell GDB in advance what  to  do
       for each kind of signal.

       Normally,  DDD  is  set up to ignore non-erroneous signals
       like SSIIGGAALLRRMM (so as not to interfere with  their  role  in
       the  functioning of your program) but to stop your program
       immediately whenever an error signal happens.  In DDD, you
       can change these settings via `SSttaattuuss-->>SSiiggnnaallss'.


       `SSttaattuuss-->>SSiiggnnaallss' pops up a panel showing all the kinds of
       signals and how GDB has been told to handle each one.  The
       settings available for each signal are:

       SSttoopp      If  set,  GDB should stop your program when this
                 signal happens.  This also implies `PPrriinntt' being
                 set.

                 If  unset, GDB should not stop your program when
                 this signal happens.  It may still print a  mes-
                 sage telling you that the signal has come in.

       PPrriinntt     If  set,  GDB  should  print a message when this
                 signal happens.

                 If unset, GDB should not mention the  occurrence
                 of  the signal at all.  This also implies `SSttoopp'
                 being unset.

       PPaassss      If set, GDB should allow  your  program  to  see
                 this signal; your program can handle the signal,
                 or else it may terminate if the signal is  fatal
                 and not handled.

                 If  unset,  GDB should not allow your program to
                 see this signal.

       When a signal stops your program, the signal is not  visi-
       ble  until  you  continue.   Your  program sees the signal
       then, if `PPaassss' is in effect for the signal in question _a_t
       _t_h_a_t  _t_i_m_e.   In  other words, after GDB reports a signal,
       you can change the  `SSttaattuuss-->>SSiiggnnaallss'  `PPaassss'  setting  to
       control  whether  your  program  sees that signal when you
       continue.

       You can also cause your program to see a  signal  it  nor-
       mally would not see, or to give it any signal at any time.
       The `SSeenndd' button will resume execution where your program



DDD 3.0                     1998-06-17                         16





ddd(1)                                                     ddd(1)


       stopped, but immediately give it the signal shown.

       On  the other hand, you can also prevent your program from
       seeing a signal.  For example, if your program stopped due
       to  some  sort  of memory reference error, you might store
       correct values into the erroneous variables and  continue,
       hoping to see more execution; but your program would prob-
       ably terminate immediately as a result of the fatal signal
       once  it  saw the signal.  To prevent this, you can resume
       execution using `CCoommmmaannddss-->>CCoonnttiinnuuee WWiitthhoouutt SSiiggnnaall'.

EEXXAAMMIINNIINNGG DDAATTAA
       DDD provides four 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.

       MMeemmoorryy DDuummppss
                 This  feature,  available using GDB only, allows
                 you to dump memory contents in  any  of  several
                 formats,  independently  of  your program's data
                 types.  This is described  under  `MMAACCHHIINNEE--LLEEVVEELL
                 DDEEBBUUGGGGIINNGG', below.


   SShhoowwiinngg SSiimmppllee VVaalluueess uussiinngg VVaalluuee HHiinntts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.






DDD 3.0                     1998-06-17                         17





ddd(1)                                                     ddd(1)


   PPrriinnttiinngg SSiimmppllee VVaalluueess iinn tthhee DDeebbuuggggeerr CCoonnssoollee
       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,  the  value  is  printed  in the debugger console.
       Note that the value is also shown in the status line.

       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 iinn tthhee DDaattaa WWiinnddooww
       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.
       The  data window opens automatically as soon as you create
       a display.


       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 an even faster alternative, you can  also  double-click
       on the variable name.

       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.

       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]
       [[nnooww oorr]wwhheenn iinn _s_c_o_p_e]

       at the debugger prompt.  The options  have  the  following
       meaning:

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

       +o 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 created.  Otherwise, no edge is created.



DDD 3.0                     1998-06-17                         18





ddd(1)                                                     ddd(1)


       +o If the suffix `wwhheenn iinn _s_c_o_p_e' is given, display creation
         is _d_e_f_e_r_r_e_d until execution reaches the given  _s_c_o_p_e  (a
         function name, as in the backtrace output).

       +o If  the  suffix  `nnooww  oorr  wwhheenn  iinn _s_c_o_p_e' is given, DDD
         attempts to create the display immediately.  If  display
         creation  fails,  it is _d_e_f_e_r_r_e_d until execution reaches
         the given _s_c_o_p_e (a function name, as  in  the  backtrace
         output).

       +o If  no  `wwhheenn  iinn'  suffix or `nnooww oorr wwhheenn iinn' suffix is
         given, the display is created immediately.

   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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
       Aggregate  values  (i.e.  records,  structs,  classes, and
       arrays) can be shown _e_x_p_a_n_d_e_d,  that  is,  displaying  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.




DDD 3.0                     1998-06-17                         19





ddd(1)                                                     ddd(1)


       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
       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
       called _d_i_s_a_b_l_e_d; this is indicated by  the  string  `_(_D_i_s_-
       _a_b_l_e_d_)'.  Displays can also 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  wither  a  space-
       separated  list of display numbers to disable or enable or
       a single display name.





DDD 3.0                     1998-06-17                         20





ddd(1)                                                     ddd(1)


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

       As a faster alternative, you can also press _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 enter the dependent expression in
       the  `(())::'  argument  field.   Then click on the `DDiissppllaayy'
       button.

       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
       DDD  maintains  a _s_h_o_r_t_c_u_t _m_e_n_u of frequently used display
       expressions.  This menu is activated

       +o by pressing and holding the `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.

       By  default,  the  shortcut  menu contains frequently used
       base conversions.

       The `OOtthheerr' entry in the shortcut menu lets you  create  a
       new  display  that _e_x_t_e_n_d_s the shortcut menu.  As an exam-
       ple, assume you have selected a display named  `ddaattee__ppttrr'.
       Selecting  `DDiissppllaayy-->>OOtthheerr'  pops  up a dialog that allows
       you to enter a new  expression  to  be  displayed  --  for
       instance,  you  can  cast  the display `ddaattee__ppttrr' to a new
       display `((cchhaarr **))ddaattee__ppttrr'.  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, the shortcut menu will
       then contain a new entry `DDiissppllaayy ((cchhaarr  **))(())'  that  will
       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'.
       Such shortcuts can save you a lot of time  when  examining



DDD 3.0                     1998-06-17                         21





ddd(1)                                                     ddd(1)


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

   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 using DBX, XDB, or
       JDB, this displays  all  local  variables,  including  the
       arguments  of the current function.  When using GDB, func-
       tion arguments are contained in a separate display,  acti-
       vated by `DDiissppllaayy AArrgguummeennttss'.




DDD 3.0                     1998-06-17                         22





ddd(1)                                                     ddd(1)


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



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

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

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

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

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

       If  you are using GDB, DDD provides a panel from which you
       can choose useful status displays.   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 VVaalluuees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,



DDD 3.0                     1998-06-17                         23





ddd(1)                                                     ddd(1)


       you can specify the number of array elements  to  be  dis-
       played.

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

   RReeppeeaatteedd AArrrraayy VVaalluueess
       Using GDB, an array value that  is  repeated  10  or  more
       times  is  displayed only once.  The value is shown with a
       `<<_Nxx>>' postfix added, where _N is the number of  times  the
       value  is  repeated.  Thus, the display `00xx00 <<3300xx>>' stands
       for 30 array elements, each  with  the  value  00xx00.   This
       saves  a lot of display space, especially with homogeneous
       arrays.


       The default GDB threshold for repeated array values is 10.
       You  can  change it via `EEddiitt-->>GGDDBB SSeettttiinnggss-->>TThhrreesshhoolldd ffoorr
       rreeppeeaatteedd pprriinntt eelleemmeennttss'.  Setting the threshold to 00 will
       cause GDB (and DDD) to display each array element individ-
       ually.   Be  sure  to  refresh   the   data   window   via
       `DDaattaa-->>RReeffrreesshh DDiissppllaayyss' after a change in GDB settings.

       You  can  also configure DDD to display each array element
       individually,  regardless  of  GDB   settings;   see   the
       `eexxppaannddRReeppeeaatteeddVVaalluueess' resource for details.

   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.


       Note: Altering variable values is not supported in JDB.

   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 may be situations where you should  refresh
       the  data  window explicitly.  This is especially the case
       whenever you changed debugger settings that  could  affect
       the data format, and want the data window to reflect these
       settings.

       You   can   refresh   the   data   window   by   selecting



DDD 3.0                     1998-06-17                         24





ddd(1)                                                     ddd(1)


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

   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  or  a  single
       display name.

       If  you  are using stacked windows, deleting the last dis-
       play from the data window also  automatically  closes  the
       data window.

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




DDD 3.0                     1998-06-17                         25





ddd(1)                                                     ddd(1)


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

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

       Each  edge  hint  is a placeholder for a suppressed alias;
       selecting an edge hint  is  equivalent  to  selecting  the
       alias.  This way, you can easily delete display aliases by
       simply selecting the edge hint and clicking on  `UUnnddiissppllaayy
       (())'.


       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,  you may verify the correct function of your
         inferior debugger by comparing the values of  _p  and  &&_p
         (unless  _p  actually  points  to  itself).  You can also
         examine the data display addresses, as shown in the Dis-
         play Editor.




DDD 3.0                     1998-06-17                         26





ddd(1)                                                     ddd(1)


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

   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.

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



DDD 3.0                     1998-06-17                         27





ddd(1)                                                     ddd(1)


       `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 succes-
       sors are placed next to their parents.  This algorithm  is
       suitable 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  layout  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.


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




DDD 3.0                     1998-06-17                         28





ddd(1)                                                     ddd(1)


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
       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 256 (default)
       and  the  current  function  is larger than 256 bytes, DDD
       only disassembles the first 256 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.



DDD 3.0                     1998-06-17                         29





ddd(1)                                                     ddd(1)


   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Exxaammiinniinngg MMeemmoorryy
       Using DDD, you can examine memory in any of  several  for-
       mats,  independently  of  your  program's data types.  The
       item `DDaattaa-->>EExxaammiinnee MMeemmoorryy' pops up a panel where you  can
       choose the format to be shown.


       You can enter

       +o a  _r_e_p_e_a_t  _c_o_u_n_t,  a  decimal integer that specifies how
         much memory (counting by units) to display

       +o a _d_i_s_p_l_a_y _f_o_r_m_a_t--one of

         ooccttaall     Print as integer in octal

         hheexx       Regard the bits of the value  as  an  integer,
                   and print the integer in hexadecimal.

         ddeecciimmaall   Print as integer in signed decimal.

         uunnssiiggnneedd  Print as integer in unsigned decimal.

         bbiinnaarryy    Print as integer in binary.

         ffllooaatt     Regard  the  bits  of  the value as a floating
                   point number and print using typical  floating
                   point syntax.

         aaddddrreessss   Print as an address, both absolute in hexadec-
                   imal and as an offset from the nearest preced-
                   ing symbol.

         iinnssttrruuccttiioonn
                   Print  as machine instructions.  The _u_n_i_t _s_i_z_e
                   is ignored for this display format.

         cchhaarr      Regard as an integer and print it as a charac-
                   ter constant.

         ssttrriinngg    Print  as  null-terminated  string.   The _u_n_i_t
                   _s_i_z_e is ignored for this display format.




DDD 3.0                     1998-06-17                         30





ddd(1)                                                     ddd(1)


       +o a _u_n_i_t _s_i_z_e--one of

         bbyytteess     Bytes.

         hhaallffwwoorrddss Halfwords (two bytes).

         wwoorrddss     Words (four bytes).

         ggiiaannttss    Giant words (eight bytes).

       +o an _a_d_d_r_e_s_s--the starting display address.   The  expres-
         sion  need  not have a pointer value (though it may); it
         is always interpreted as an integer address of a byte of
         memory.

       There are two ways to examine the values:

       +o You  can  dump the memory in the debugger console (using
         `PPrriinntt').  If you repeat the resulting  `xx'  command  by
         pressing  RReettuurrnn, the following area of memory is shown.

       +o You can also display the memory dump in the data  window
         (using `DDiissppllaayy').  If you choose to display the values,
         the values will be updated automatically each  time  the
         program stop.


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.  Instead, DDD allows you to invoke a _t_e_x_t  _e_d_i_-
       _t_o_r.  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;

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

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

       (You      can      change      this      setting       via
       `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-->>EEddiitt SSoouurrcceess'.)

       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



DDD 3.0                     1998-06-17                         31





ddd(1)                                                     ddd(1)


       source  file.   Since DDD automatically reloads the source
       code if the debugged program  has  been  recompiled,  this
       should seldom be necessary.

EENNTTEERRIINNGG CCOOMMMMAANNDDSS
       In the _d_e_b_u_g_g_e_r _c_o_n_s_o_l_e, you can interact with the command
       interface of the inferior debugger.  Enter commands at the
       _d_e_b_u_g_g_e_r  _p_r_o_m_p_t--that  is,  `((ggddbb))'  for GDB, `((ddbbxx))' for
       DBX, `>>' for XDB, and `>>' or `_t_h_r_e_a_d[[_d_e_p_t_h]]' for JDB.  You
       can use arbitrary debugger commands; 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++BB'.
       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++BB' again to repeat the search, or `CCttrrll++FF' 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.

CCUUSSTTOOMMIIZZIINNGG DDDDDD
       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 prefer-
       ences 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



DDD 3.0                     1998-06-17                         32





ddd(1)                                                     ddd(1)


       `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 functions,
       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 pref-
       erences, which are discussed here.

   GGeenneerraall PPrreeffeerreenncceess
       By default, when you move the pointer over a  button,  DDD
       gives  a  hint  on the button's meaning in a small window.
       This feature is known as _b_u_t_t_o_n _t_i_p_s (also known  as  _t_o_o_l
       _t_i_p_s  or  _b_a_l_l_o_o_n _h_e_l_p).  Experienced users may find these
       hints disturbing; this is why  you  can  disable  them  by
       unsetting  the `AAuuttoom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).



DDD 3.0                     1998-06-17                         33





ddd(1)                                                     ddd(1)


       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  `CCoonnttiinnuuee  aauuttoommaattiiccaallllyy wwhheenn
       mmoouussee ppooiinntteerr iiss ffrroozzeenn' option is  set,  DDD  will  check
       after each interaction whether the pointer is grabbed.  If
       this is so, DDD will continue the  debugged  program  such
       that you can continue to use 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.


       DDD can locate the tool buttons in the command tool (`CCoomm--
       mmaanndd TTooooll') or in a _c_o_m_m_a_n_d _t_o_o_l  _b_a_r  above  the  program
       source (`SSoouurrccee WWiinnddooww').  Pick your choice.

       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.

       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.



DDD 3.0                     1998-06-17                         34





ddd(1)                                                     ddd(1)


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

       You  can  instruct  DDD to indent the source code, leaving
       more room for breakpoints and execution glyphs.   This  is
       done  using  the `SSoouurrccee iinnddeennttaattiioonn' slider.  The default
       value is 00 for no  indentation  at  all.   If  the  source
       indentation  is  55 or higher, DDD will also show line num-
       bers.

       Finally, you can instruct DDD to indent the machine  code,
       leaving  room  for breakpoints and execution glyphs.  This
       is done using the `MMaacchhiinnee ccooddee iinnddeennttaattiioonn' slider.   The
       default value is 44.

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

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

       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.





DDD 3.0                     1998-06-17                         35





ddd(1)                                                     ddd(1)


   SSttaarrttuupp PPrreeffeerreenncceess
       If you change one of the  resources  in  this  panel,  the
       change will not take effect immediately.  Instead, you can

       +o save options (using `EEddiitt'->`SSaavvee OOppttiioonnss') to make  the
         change effective for future DDD sessions,

       +o or  restart DDD (using `FFiillee'->`RReessttaarrtt DDDDDD') to make it
         effective for the restarted DDD session.

       After having made changes in the panel, DDD will automati-
       cally  offer  you to restart itself, such that you can see
       the changes taking effect.  Note that even after  restart-
       ing,  you still must save options to make the changes per-
       manent.


       By default, DDD stacks commands, source, and data  in  one
       single  top-level window.  To have separate top-level win-
       dows for source, data, and debugger console, set the `WWiinn--
       ddooww  LLaayyoouutt'  option  to `SSeeppaarraattee WWiinnddoowwss'.  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.

       To  cut,  copy,  and paste text, DDD supports two types of
       key bindings, each in accordance  with  a  specific  style
       guide.

       KKDDEE--ssttyyllee bbiinnddiinnggss
              This   binds   the   Cut/Copy/Paste  operations  to
              CCttrrll++XX/CCttrrll++CC/CCttrrll++VV.  These key bindings are  con-
              formant  to  the  KDE  style guide.  Note that this
              means  that  CCttrrll++CC  no   longer   interrupts   the
              debuggee; use EEsscc instead.

       MMoottiiff--ssttyyllee bbiinnddiinnggss
              This  (default)  setting  binds  Cut/Copy/Paste  to
              SShhiifftt++DDeell/CCttrrll++IInnss/SShhiifftt++IInnss.  This  is  conformant
              to the Motif style guide.

       The  DDD  tool  bar  buttons  can  appear  in a variety of
       styles:

       IImmaaggeess This lets each toolbar button show an image  illus-
              trating the action.

       CCaappttiioonnss
              This shows the action name below the image.

       The default is to have images as well as captions, but you
       can choose to have only images (saving space) or only cap-
       tions.   If  neither of these two options is set, tool bar
       buttons are labeled like other  buttons,  as  in  DDD  2.x
       (with  the  exception  of the common tool bar, which never



DDD 3.0                     1998-06-17                         36





ddd(1)                                                     ddd(1)


       shows ordinary labels).

       If you enable `FFllaatt'  buttons  (default),  the  border  of
       toolbar  buttons  will appear only if the mouse pointer is
       over them.  This latest-and-greatest GUI invention can  be
       disabled, such that the button border is always shown.

       If you enable `CCoolloorr' buttons, toolbar images will be col-
       ored.  Don't expect too much--even  color  toolbar  images
       have a large amount of grey.

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

       By  default, DDD uses Motif scroll bars to scroll the data
       window.  Many people find this inconvenient, since you can
       scroll  in  the horizontal or vertical direction only.  As
       an alternative, DDD provides a  panner  (a  kind  of  two-
       dimensional  scroll  bar).  This is much more comfortable,
       but may be incompatible with your Motif toolkit.   To  set
       up DDD such that it uses panners by default, set the `DDaattaa
       SSccrroolllliinngg' option to `PPaannnneerr'.  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.  See also the `----ggddbb', `----ddbbxx', `----xxddbb',
       and `----jjddbb' options, below.

       If  you  want  the  DDD  splash screen shown upon startup,
       enable `DDDDDD SSppllaasshh SSccrreeeenn'.

       If you want  the  DDD  tips  of  the  day  displayed  upon
       startup, enable `TTiipp ooff tthhee DDaayy'.

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

   FFoonnttss
       You can configure the basic DDD fonts at  run-time.   Each
       font is specified using two members:

       +o The  _f_o_n_t  _f_a_m_i_l_y is an X font specifications, where the
         initial specification  after  `_F_a_m_i_l_y'.   Thus,  a  pair
         `_f_a_m_i_l_y--_w_e_i_g_h_t' usually suffices.

       +o The  _f_o_n_t _s_i_z_e is given as (resolution-independent) 1/10
         points.

       The `BBrroowwssee' button opens a font selection program,  where



DDD 3.0                     1998-06-17                         37





ddd(1)                                                     ddd(1)


       you can select fonts and attributes interactively.  Click-
       ing `qquuiitt' or `sseelleecctt' in the  font  selector  causes  all
       non-default values to be transferred to the DDD font pref-
       erences panel.


       The following fonts  can  be  set  using  the  preferences
       panel:

       DDeeffaauulltt FFoonntt
              The  default DDD font to use for labels, menus, and
              buttons.  Default value is `hheellvveettiiccaa--bboolldd'.

       VVaarriiaabbllee WWiiddtthh
              The variable width DDD font to use for  help  texts
              and messages.  Default value is `hheellvveettiiccaa--mmeeddiiuumm'.

       FFiixxeedd WWiiddtthh
              The fixed width DDD font to use  for  source  code,
              the  debugger  console, text fields, data displays,
              and the execution window.  Default value is  `lluuccii--
              ddaattyyppeewwrriitteerr--mmeeddiiuumm'.

       Just  like startup preferences, changes in this panel will
       not take effect immediately.  Instead, you can

       +o save options (using `EEddiitt'->`SSaavvee OOppttiioonnss') to make  the
         change effective for future DDD sessions,

       +o or  restart DDD (using `FFiillee'->`RReessttaarrtt DDDDDD') to make it
         effective for the restarted DDD session.

       After having made changes in the panel, DDD will automati-
       cally  offer  you to restart itself, such that you can see
       the changes taking effect.  Note that even after  restart-
       ing,  you still must save options to make the changes per-
       manent.

       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.




DDD 3.0                     1998-06-17                         38





ddd(1)                                                     ddd(1)


       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.

       `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  (web  page) 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.

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



DDD 3.0                     1998-06-17                         39





ddd(1)                                                     ddd(1)


       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SEERR--DDEEFFIINNEEDD AACCTTIIOONNSS
   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 `OOKK' creates  the  appro-
       priate  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
       `OOKK'.   A button named `PPrriinntt ii' will now appear below the
       debugger console--try it!  To remove  the  button,  reopen
       the button editor, clear the `pprriinntt ii' line and press `OOKK'
       again.

       If a button command contains `(())', the  string  `(())'  will
       automatically  be replaced by the contents of the argument
       field.  For instance, a button named `rreettuurrnn (())' will exe-
       cute  the GDB `rreettuurrnn' command with the current content of
       the argument field as argument.

       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 3.0                     1998-06-17                         40





ddd(1)                                                     ddd(1)


   DDeeffiinniinngg CCoommmmaannddss wwiitthh GGDDBB
       Aside from breakpoint commands (see `BBrreeaakkppooiinntt ccoommmmaannddss',
       above), DDD also allows you to store sequences of commands
       as a user-defined GDB command.  A _u_s_e_r_-_d_e_f_i_n_e_d _c_o_m_m_a_n_d  is
       a  sequence of GDB commands to which you assign a new name
       as a command.  Using DDD, this is  done  via  the  _C_o_m_m_a_n_d
       _E_d_i_t_o_r, invoked via `CCoommmmaannddss-->>DDeeffiinnee CCoommmmaanndd'.


       A GDB command is created in three steps:

       +o Enter  the  name  of the command in the `CCoommmmaanndd' field.
         Use the drop-down list  on  the  right  to  select  from
         already defined commands.

       +o Click  on `RReeccoorrdd' to begin the recording of the command
         sequence.

       +o Now interact with DDD.  While recording,  DDD  does  not
         execute commands, but simply records them to be executed
         when the breakpoint is hit.  The recorded debugger  com-
         mands are shown in the debugger console.

       +o To  stop the recording, click on `EEnndd' or enter `eenndd' at
         the GDB prompt.   To  _c_a_n_c_e_l  the  recording,  click  on
         `IInntteerrrruupptt' or press EEsscc.

       +o Click  on `EEddiitt >>>>' to edit the recorded commands.  When
         done with editing, click on `EEddiitt <<<<' to close the  com-
         mands editor.

       After  the command is defined, you can enter it at the GDB
       prompt.  You may also click on `AAppppllyy' to apply the  given
       user-defined command.

       For  convenience,  you  can assign a button to the defined
       command.  Enabling one of the `BBuuttttoonn' locations will  add
       a button with the given command to the specified location.
       If you want to edit  the  button,  select  `CCoommmmaannddss-->>EEddiitt
       BBuuttttoonnss'; see also `DDeeffiinniinngg BBuuttttoonnss', above.

       When  user-defined GDB commands are executed, the commands
       of the definition are not printed.  An error in  any  com-
       mand stops execution of the user-defined command.

       If used interactively, commands that would ask for confir-
       mation proceed without asking when  used  inside  a  user-
       defined  command.   Many  GDB commands that normally print
       messages to say what they are doing omit the messages when
       used in a user-defined command.

       To save all command definitions, use `EEddiitt-->>SSaavvee OOppttiioonnss'.





DDD 3.0                     1998-06-17                         41





ddd(1)                                                     ddd(1)


   DDeeffiinniinngg CCoommmmaannddss wwiitthh DDBBXX,, XXDDBB aanndd JJDDBB
       If your DBX, XDB, or JDB debugger allows you to define own
       command  sequences,  you  can  also use these user-defined
       commands within DDD;  just  enter  them  at  the  debugger
       prompt.

       However, you may encounter some problems:

       +o In contrast to the well-documented commands of the infe-
         rior debugger, DDD does not  know  what  a  user-defined
         command  does.  This may lead to inconsistencies between
         DDD and the inferior debugger.  For  instance,  if  your
         the user-defined 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 `_p_r_e_f_i_x _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.
       _p_r_e_f_i_x is a user-defined string, for example `dddddd::

       Suppose you want to define a command `ggdd' that  serves  as
       abbreviation  for `ggrraapphh ddiissppllaayy'.  All the command ggdd 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 _a_r_g_u_m_e_n_t

       where _a_r_g_u_m_e_n_t is the argument given to `ggdd'.  Using  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 ggdd
           eecchhoo dddddd:: ggrraapphh ddiissppllaayy $$aarrgg00\\nn
         eenndd

       To complete the setting, you must also set  the  `aauuttooCCoomm--
       mmaannddPPrreeffiixx'  resource  to  the  `dddddd:: ' prefix you gave in
       your command.  In `$$HHOOMMEE//..dddddd//iinniitt', write:

         DDdddd**aauuttooCCoommmmaannddPPrreeffiixx:: dddddd::\\

       (Be sure to leave a space after the trailing backslash.)

       Entering `ggdd ffoooo' will now have the same effect as  enter-
       ing `ggrraapphh ddiissppllaayy ffoooo' at the debugger prompt.

       Please  note:  In  your  commands,  you should choose some
       other prefix than `dddddd:: '.  This is because  auto-commands



DDD 3.0                     1998-06-17                         42





ddd(1)                                                     ddd(1)


       raise  a security problem, since arbitrary commands can be
       executed.  Just imagine some malicious program  issuing  a
       string  like  `_p_r_e_f_i_x  sshheellll  rrmm  --ffrr  $$HHOOMMEE'  when  being
       debugged!  As a consequence, be sure to  choose  your  own
       _p_r_e_f_i_x; it must be at least three characters long.

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  or  press  CCttrrll++QQ.
       GDB  and XDB also accept the `qq' command or an end-of-file
       character (usually CCttrrll++DD).  Closing the last  DDD  window
       will also exit DDD.

       An  interrupt  (EEssc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 or
       even exit 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 typing the interrupt  character
       (usually  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 inter-
       rupts any DDD action; the inferior debugger is interrupted
       as well.  Since this interrupt signal can result in inter-
       nal inconsistencies, use this as a last resort in emergen-
       cies only; save your work as soon as possible and  restart
       DDD.

PPEERRSSIISSTTEENNTT SSEESSSSIIOONNSS
       Note:  Persistent  sessions are supported with GDB running
       on the local machine only.  Support for  other  DBX,  XDB,
       and JDB is partially implemented; your mileage may vary.

       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 memory
         contents and the current execution position.



DDD 3.0                     1998-06-17                         43





ddd(1)                                                     ddd(1)


       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,
         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  your  program is running, or if you have opened a core
       file, DDD can include a core file in the session such that
       the debuggee data will be restored when re-opening it.  To
       get a core file, DDD typically  must  kill  the  debuggee.
       This  means that you cannot resume program execution after
       saving a session.  Depending on your  architecture,  other
       options for getting a core file may also be available.

       If  a  core file is _n_o_t to be included in the session, DDD
       data displays are saved as _d_e_f_e_r_r_e_d; that is, they will be
       restored as soon as program execution reaches the scope in
       which they were created.

   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



DDD 3.0                     1998-06-17                         44





ddd(1)                                                     ddd(1)


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

       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.

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

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

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

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



DDD 3.0                     1998-06-17                         45





ddd(1)                                                     ddd(1)


       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  ear-
       lier):

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

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

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

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


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 _l_e_s_s_t_i_f _h_a_c_k_s can be enabled  and  disabled
       at run time.

       Whether the _l_e_s_s_t_i_f _h_a_c_k_s 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s--
       TTiiffVVeerrssiioonn'  indicates  the  LessTif version against which
       DDD is linked.  For LessTif version _x_._y, its  value  is  _x
       multiplied  by  1000  plus  _y--for  instance, the value 9955



DDD 3.0                     1998-06-17                         46





ddd(1)                                                     ddd(1)


       stands for LessTif 0.95 and  the  value  11000000  stands  for
       LessTif 1.0.  To specify the version number of the LessTif
       library 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.85 dynamic library instead.  Invoke  DDD
         with `----lleessssttiiff--vveerrssiioonn 8855'.

       +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.85, 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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,
       you  need  `rreemmsshh' (called `rrsshh' on BSD systems) access on
       the remote host.




DDD 3.0                     1998-06-17                         47





ddd(1)                                                     ddd(1)


       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 with the `----ttrraaccee' option.  This  prints  the  shell
         commands issued by DDD on standard error.




DDD 3.0                     1998-06-17                         48





ddd(1)                                                     ddd(1)


   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.

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
       DDD uses the following resources to set up its fonts:




DDD 3.0                     1998-06-17                         49





ddd(1)                                                     ddd(1)


       ddeeffaauullttFFoonntt ((class Font)
              The default DDD font to use for labels, menus, but-
              tons, etc.  The font is  specified  as  an  X  font
              spec,  where  the initial specification after `_F_a_m_-
              _i_l_y'.  Default value is `hheellvveettiiccaa--bboolldd'.

              To set the default  DDD  font  to,  say,  hheellvveettiiccaa
              mmeeddiiuumm, insert a line

                DDdddd**ddeeffaauullttFFoonntt:: hheellvveettiiccaa--mmeeddiiuumm

              in your `$$HHOOMMEE//..dddddd//iinniitt' file.

       ddeeffaauullttFFoonnttSSiizzee  ((class FontSize)
              The  size  of the default DDD font, in 1/10 points.
              This resource overrides any font size specification
              in  the  `ddeeffaauullttFFoonntt'  resource  (see above).  The
              default value is 112200 for a 12.0 point font.

       vvaarriiaabblleeWWiiddtthhFFoonntt ((class Font)
              The variable width DDD font to use for  help  texts
              and  messages.   The font is specified as an X font
              spec, where the initial specification  after  `_F_a_m_-
              _i_l_y'.  Defaults to `hheellvveettiiccaa--mmeeddiiuumm--rr'.

              To  set the variable width DDD font family to, say,
              ttiimmeess, insert a line

                DDdddd**ffiixxeeddWWiiddtthhFFoonntt:: ttiimmeess--mmeeddiiuumm

              in your `$$HHOOMMEE//..dddddd//iinniitt' file.

       vvaarriiaabblleeWWiiddtthhFFoonnttSSiizzee  ((class FontSize)
              The size of the variable width DDD  font,  in  1/10
              points.   This  resource  overrides  any  font size
              specification in the  `vvaarriiaabblleeWWiiddtthhFFoonntt'  resource
              (see  above).   The default value is 112200 for a 12.0
              point font.

       ffiixxeeddWWiiddtthhFFoonntt ((class Font)
              The fixed width DDD font to use  for  source  code,
              the  debugger  console, text fields, data displays,
              and the execution window.  The font is specified as
              an  X  font  spec,  where the initial specification
              after  `_F_a_m_i_l_y'.   Defaults  to  `lluucciiddaattyyppeewwrriitteerr--
              mmeeddiiuumm'.

              To  set  the  fixed  width DDD font family to, say,
              ccoouurriieerr, insert a line

                DDdddd**ffiixxeeddWWiiddtthhFFoonntt:: ccoouurriieerr--mmeeddiiuumm

              in your `$$HHOOMMEE//..dddddd//iinniitt' file.




DDD 3.0                     1998-06-17                         50





ddd(1)                                                     ddd(1)


       ffiixxeeddWWiiddtthhFFoonnttSSiizzee  ((class FontSize)
              The size of the  fixed  width  DDD  font,  in  1/10
              points.   This  resource  overrides  any  font size
              specification in the `ffiixxeeddWWiiddtthhFFoonntt' resource (see
              above).   The default value is 112200 for a 12.0 point
              font.

       As all font size resources have the  same  class  (and  by
       default the same value), you can easily change the default
       DDD font size to, say, 9.0 points by inserting a line

         DDdddd**FFoonnttSSiizzee:: 9900

       in your `$$HHOOMMEE//..dddddd//iinniitt' file.

       To find out  your  favorite  font  size,  try  `----ffoonnttssiizzee
       _S_I_Z_E'.  This also sets all font sizes to _S_I_Z_E.

       If  you  want  to set the fonts of specific items, see the
       `DDdddd' application defaults file for instructions.

   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966

       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966

       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966

       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966

       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

       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 dis-
       play,  things  are  slightly  more  complicated--see   the
       `vvssllDDeeffss' resource, below.





DDD 3.0                     1998-06-17                         51





ddd(1)                                                     ddd(1)


   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 (`oonn', default) or
              not (`ooffff').  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 (`oonn', default) or not (`ooffff').

       cchheecckkGGrraabbss ((class CChheecckkGGrraabbss))
              When debugging  a  modal  X  application,  DDD  may
              interrupt it while it has grabbed the pointer, mak-
              ing further interaction  impossible.   If  this  is
              `oonn'  (default), DDD will check after each interac-
              tion whether the pointer is grabbed.   If  this  is
              so,  DDD  will  automatically continue execution of
              debugged program.

       cchheecckkGGrraabbDDeellaayy ((class CChheecckkGGrraabbDDeellaayy))
              The time to wait (in ms) after a  debugger  command
              before checking for a grabbed pointer.  If DDD sees
              some pointer event within this delay,  the  pointer
              cannot  be  grabbed  and  an  explicit  check for a
              grabbed pointer is unnecessary.  Default  is  55000000,
              or 5 seconds.

       ccuuttCCooppyyPPaasstteeBBiinnddiinnggss ((class BBiinnddiinnggSSttyyllee))
              Controls  the key bindings for cut, copy, and paste
              operations.

              +o If this is `MMoottiiff' (default),  Cut/Copy/Paste  is
                on SShhiifftt++DDeell/CCttrrll++IInnss/SShhiifftt++IInnss.  This is confor-
                mant to the Motif style guide.

              +o If  this   is   `KKDDEE',   Cut/Copy/Paste   is   on
                CCttrrll++XX/CCttrrll++CC/CCttrrll++VV.   This is conformant to the
                KDE style  guide.   Note  that  this  means  that
                CCttrrll++CC no longer interrupts the debuggee; use EEsscc
                instead.

       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 `oonn' (default), the  TTAABB  key  completes
              arguments  in  all  windows.  If this is `ooffff', the
              TTAABB key completes arguments in the debugger console
              only.

       ggrraabbAAccttiioonn ((class ggrraabbAAccttiioonn))
              The  action to take after having detected a grabbed
              mouse pointer.  This is a list of newline-separated
              commands.   Default  is `ccoonntt', meaning to continue
              the  debuggee.   Other  possible  choices   include



DDD 3.0                     1998-06-17                         52





ddd(1)                                                     ddd(1)


              `kkiillll'  (killing  the  debuggee) or `qquuiitt' (exiting
              DDD).

       ggrraabbAAccttiioonnDDeellaayy ((class ggrraabbAAccttiioonnDDeellaayy))
              The time to wait (in ms) before  taking  an  action
              due  to  having detected a grabbed pointer.  During
              this delay, a working dialog pops  up  telling  the
              user  about  imminent  execution of the grab action
              (see the `ggrraabbAAccttiioonn'  resource,  above).   If  the
              pointer  grab  is  released  within this delay, the
              working dialog pops down and no  action  is  taken.
              This  is done to exclude pointer grabs from sources
              other than the debugged  program  (including  DDD).
              Default is 1100000000, or 10 seconds.

       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  `oonn',  (un)iconifying  any DDD window
              causes all other  DDD  windows  to  (un)iconify  as
              well.  Default is `ooffff', meaning that each DDD win-
              dow can be iconified on its own.

       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 `oonn' (default), the command history is automati-
              cally saved when DDD exits.

       ssppllaasshhSSccrreeeenn ((class SSppllaasshhSSccrreeeenn))
              If  `oonn'  (default),  show a DDD splash screen upon
              start-up.

       ssppllaasshhSSccrreeeennCCoolloorrKKeeyy ((class CCoolloorrKKeeyy))
              The color key to use for  the  DDD  splash  screen.
              Possible values include:

              +o `cc' (default) for a color visual,

              +o `gg' for a multi-level greyscale visual,

              +o `gg44' for a 4-level greyscale visual, and

              +o `mm' for a dithered monochrome visual.

              +o `bbeesstt' chooses the best visual available for your
                display.

              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.

       ssttaarrttuuppTTiippss ((class SSttaarrttuuppTTiippss))
              Whether a tip of the day is to be shown at  startup
              (`oonn', default) or not (`ooffff').

       ssttaarrttuuppTTiippCCoouunntt ((class SSttaarrttuuppTTiippCCoouunntt))
              The  number  _n of the tip of the day to be shown at



DDD 3.0                     1998-06-17                         53





ddd(1)                                                     ddd(1)


              startup.  See also the `ttiipp_n' resources.

       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 `oonn', X warnings are suppressed.  This is  some-
              times  useful  for executables that were built on a
              machine with a different X or Motif  configuration.
              By default, this is `ooffff'.

       ttiipp_n (_c_l_a_s_s TTiipp))
              The tip of the day numbered _n (a string).

       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 `oonn' (default), the DDD windows are uni-
              conified 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 `ooffff' leaves
              the DDD windows iconified.

       vvaalluueeTTiippss ((class TTiippss))
              Whether value tips are enabled (`oonn',  default)  or
              not (`ooffff').  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 (`oonn', default) or not (`ooffff').

   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eGGllyypphhIImmaaggeess ((class CCaacchheeMMaacchhiinneeCCooddee))
              Whether to cache (share) glyph images (`oonn') or not
              (`ooffff').   Caching  glyph  images  requires  less X
              resources, but has been reported to fail with Motif
              2.1 on XFree86 servers.  Default is `ooffff' for Motif
              2.1 or later on Linux machines, and `oonn' otherwise.

       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 (`oonn',
              default) or  not  (`ooffff').   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 (`oonn', default) or
              not (`ooffff').  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 `oonn', the source code is automatically
              disassembled.  The default is `ooffff'.  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.




DDD 3.0                     1998-06-17                         54





ddd(1)                                                     ddd(1)


       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 `oonn', the current execution position and
              breakpoints  are  displayed  as  glyphs; otherwise,
              they are shown through characters in the text.  The
              default  is  `oonn'.   See  also  the  `----ggllyypphhss' and
              `----nnoo--ggllyypphhss' options, below.

       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 `oonn', lines in the source text are  pre-
              fixed  with  their  respective  line  number.   The
              default is `ooffff'.

       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 `oonn' (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 `oonn' (default), the `FFiinndd' commands find
              complete  words  only.  Otherwise, arbitrary occur-
              rences are found.

       ggllyypphhUUppddaatteeDDeellaayy ((class GGllyypphhUUppddaatteeDDeellaayy))
              A delay (in ms) that says how  much  time  to  wait
              before  updating  glyphs while scrolling the source
              text.   A  small  value  results  in  glyphs  being
              scrolled  with  the  text,  a  large value disables
              glyphs while scrolling and makes scrolling  faster.
              Default: 1100.

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

       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.




DDD 3.0                     1998-06-17                         55





ddd(1)                                                     ddd(1)


       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:
              225566).  If this is zero, the entire current function
              is disassembled.

       mmaaxxGGllyypphhss ((class MMaaxxGGllyypphhss))
              The  maximum  number  of  glyphs  to  be  displayed
              (default:  1100).   Raising  this  value  causes more
              glyphs to be allocated, possibly wasting  resources
              that are never needed.

       ssoouurrcceeEEddiittiinngg ((class SSoouurrcceeEEddiittiinngg))
              If  this is `oonn', the displayed source code becomes
              editable.  This is an experimental feature and  may
              become obsolete in future DDD releases.  Default if
              `ooffff'.

       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 `ooffff' (default), the inferior debugger
              refers to source code locations only by their  base
              names.   If  this  is  `oonn' (default), DDD uses the
              full source code paths.

   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 `oonn' (default), DDD will always keep the command
              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 any-
              way, set this resource to `ooffff'.

       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 `oonn' (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 `ooffff':

                DDdddd**aauuttooRRaaiisseeMMeennuu:: ooffff


       ccoolloorrWWMMIIccoonnss ((class CCoolloorrWWMMIIccoonnss))
              If `oonn' (default), DDD uses multi-color icons.   If
              your  window  manager  has trouble with multi-color
              icons, set this resource to `ooffff' and DDD will  use
              black-and-white icons instead.



DDD 3.0                     1998-06-17                         56





ddd(1)                                                     ddd(1)


       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 `ooffff', 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 command
                tool.  However, your window manager may  be  con-
                figured  not to decorate transient windows, which
                means that you cannot  easily  move  the  command
                tool around.

              +o If this is `oonn', 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 dec-
                orated 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,
                the command tool is realized as a transient  win-
                dow (as in the `ooffff' setting); if no, the command
                tool is realized as a top-level window (as in the
                `oonn' setting).  Hence, the command tool is always
                decorated using the "best" method, but the  extra
                check takes some time.


       ooppeennDDaattaaWWiinnddooww ((class WWiinnddooww))
              If  `ooffff' (default), the data window is closed upon
              start-up.

       ooppeennDDeebbuuggggeerrCCoonnssoollee ((class WWiinnddooww))
              If `ooffff',  the  debugger  console  is  closed  upon
              start-up.

       ooppeennSSoouurrcceeWWiinnddooww ((class WWiinnddooww))
              If  `ooffff',  the source window is closed 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 `oonn', the data window and the  debugger  console
              are  realized  in  different top-level windows.  If
              `ooffff' (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 `oonn', the debugged program is executed in a sep-
              arate  execution  window.   If `ooffff' (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'



DDD 3.0                     1998-06-17                         57





ddd(1)                                                     ddd(1)


              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 `oonn', the source window and the debugger console
              are  realized  in  different top-level windows.  If
              `ooffff' (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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 `oonn' (default), the status line is placed at the
              bottom of the DDD source  window.   If  `ooffff',  the
              status  line is placed at the top of the DDD source
              window (as in DDD 1.x).  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  `oonn'  (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 `ooffff', the command tool does not  follow  source
              window movements.

       ttrraannssiieennttDDiiaallooggss ((class TTrraannssiieennttDDiiaallooggss))
              If `oonn' (default), all dialogs are created as tran-
              sient windows--that is, they always stay on top  of
              the main DDD windows, and they iconify with it.  If
              `ooffff', the important selection dialogs, such as the
              breakpoint and display editors, are created as top-
              level windows on their own, and may be obscured  by
              the DDD main windows.


   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 `oonn' (default), each line output by the
              inferior debugger beginning with the value  of  the
              `aauuttooCCoommmmaannddPPrreeffiixx'  resource  (see  below) will be
              interpreted 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M--
              MMAANNDDSS', above.

       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, an empty
              string,  meaning  to generate a new prefix for each
              DDD session.  If this is set to `dddddd:: ', for  exam-
              ple,  each  GDB  output  in the form `dddddd:: _c_o_m_m_a_n_d'
              will cause DDD to execute _c_o_m_m_a_n_d.




DDD 3.0                     1998-06-17                         58





ddd(1)                                                     ddd(1)


       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 `oonn'.  Some other
              systems _p_r_o_h_i_b_i_t this, such as Linux with GNU  libc
              6  and  later;  set  it to `ooffff'.  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',
              `xxddbb',  or  `jjddbb').   Default value is `ggddbb'.  This
              resource  is  usually  set  through  the   `----ggddbb',
              `----ddbbxx',  `----xxddbb',  and  `----jjddbb' options; see below
              for details.

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

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

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



DDD 3.0                     1998-06-17                         59





ddd(1)                                                     ddd(1)


              `ddeebbuuggggeerrH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GG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  `oonn',  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

                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.

       jjd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 JDB.  This
              resource may be used to customize JDB.  By default,
              it is empty.




DDD 3.0                     1998-06-17                         60





ddd(1)                                                     ddd(1)


       jjd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  JDB.   By
              default, it is empty.

              This  resource  is  used by DDD to save and restore
              JDB 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soouurrcceeIInniittCCoommmmaannddss ((class SSoouurrcceeIInniittCCoommmmaannddss))
              If `oonn' (default), DDD writes all  GDB  initializa-
              tion  commands  into a temporary file and makes GDB
              read this file, rather than sending  each  initial-
              ization command separately.  This results in faster
              startup  (especially  if  you  have  several  user-
              defined commands).  If `ooffff', DDD makes GDB process
              each command separately.

       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 `oonn', 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teerrmmiinnaatteeOOnnEEOOFF ((class TTeerrmmiinnaatteeOOnnEEOOFF))
              If  `oonn', DDD terminates the inferior debugger when
              DDD detects an EOF condition (that is, as  soon  as
              the  inferior  debugger closes its output channel).
              This was the default behavior in DDD 2.x  and  ear-
              lier.   If  `ooffff'  (default),  DDD takes no special
              action.

       ttttyyMMooddee ((class TTTTYYMMooddee))
              If `oonn', 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.



DDD 3.0                     1998-06-17                         61





ddd(1)                                                     ddd(1)


       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  `oonn', use the GDB `ttttyy' command for redirecting
              input/output to the separate execution window.   If
              `ooffff', use explicit redirection through shell redi-
              rection operators `<<'  and  `>>'.   The  default  is
              `ooffff'  (explicit  redirection),  since on some sys-
              tems, the `ttttyy' command does not work  properly  on
              some GDB versions.

       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
              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 and control
       tool bars and user-defined buttons.

       bbuuttttoonnCCaappttiioonnss ((class BBuuttttoonnCCaappttiioonnss))
              Whether the tool bar buttons should be shown  using
              captions  (`oonn',  default) or not (`ooffff').  If nei-
              ther captions nor images are enabled, tool bar but-
              tons  are  shown  using  ordinary labels.  See also
              `bbuuttttoonnIImmaaggeess', below.

       bbuuttttoonnCCaappttiioonnGGeeoommeettrryy ((class BBuuttttoonnCCaappttiioonnGGeeoommeettrryy))
              The geometry of the  caption  subimage  within  the
              button icons.  Default is `2299xx77++00--00'.

       bbuuttttoonnIImmaaggeess ((class BBuuttttoonnIImmaaggeess))
              Whether  the tool bar buttons should be shown using
              images (`oonn', default) or not (`ooffff').  If  neither
              captions  nor  images are enabled, tool bar buttons
              are shown using ordinary labels.  See also `bbuuttttoonn--
              CCaappttiioonnss', above.

       bbuuttttoonnIImmaaggeeGGeeoommeettrryy ((class BBuuttttoonnIImmaaggeeGGeeoommeettrryy))
              The  geometry  of the image within the button icon.
              Default is `2255xx2211++22++00'.

       bbuuttttoonnCCoolloorrKKeeyy ((class CCoolloorrKKeeyy))
              The XPM color key to use for buttons  images.   `cc'
              means  color,  `gg'  (default)  means  grey, and `mm'
              means monochrome.




DDD 3.0                     1998-06-17                         62





ddd(1)                                                     ddd(1)


       ccoommmmaannddT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
              above the source window (`oonn') or within  the  com-
              mand  tool  (`ooffff', default).  Enabling the command
              tool bar disables the command tool and vice  versa.

       ccoommmmoonnTToooollBBaarr ((class TToooollBBaarr))
              Whether the tool bar buttons should be shown in one
              common tool bar at the top of the common DDD window
              (`oonn',  default),  or whether they should be placed
              in two separate tool bars, one for  data,  and  one
              for source operations, as in DDD 2.x (`ooffff').

       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:

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

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

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

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

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

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

              MMaakkee      Invoke the `mmaakkee' program, using the most
                        recently given arguments.



DDD 3.0                     1998-06-17                         63





ddd(1)                                                     ddd(1)


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

              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.

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

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

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


              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.

       ffllaattTToooollbbaarrBBuuttttoonnss ((class FFllaattBBuuttttoonnss))
              If `oonn' (default), all tool bar buttons with images
              or captions are given a `flat' appearance - the 3-D
              border only shows up when the pointer is  over  the
              icon.   If  `ooffff',  the 3-D border is shown all the
              time.

       ffllaattDDiiaallooggBBuuttttoonnss ((class FFllaattBBuuttttoonnss))
              If `oonn' (default), all dialog buttons  with  images
              or captions are given a `flat' appearance - the 3-D
              border only shows up when the pointer is  over  the



DDD 3.0                     1998-06-17                         64





ddd(1)                                                     ddd(1)


              icon.   If  `ooffff',  the 3-D border is shown all the
              time.

       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

              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rssAAttBBoottttoomm ((class TToooollbbaarrssAAttBBoottttoomm))
              Whether  source and data tool bars should be placed
              above  source  and   data,   respectively   (`ooffff',
              default),  or  below,  as  in  DDD 2.x (`oonn').  ,TP
              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 command tool bar (see  the  `ccoommmmaannddTToooollBBaarr'
              resource,  above).   Each button issues the command



DDD 3.0                     1998-06-17                         65





ddd(1)                                                     ddd(1)


              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nbbrreeaakk^^CC\\nnsstteepp\\nnsstteeppii\\nnnneexxtt\\nnnneexxttii\\nn\\
                uunnttiill\\nnffiinniisshh\\nnccoonntt\\nn\\kkiillll\\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nMMaakkee

              For  each  button, its location in the command tool
              must   be   specified   using   XXmmFFoorrmm   constraint
              resources.  See the `DDdddd' application defaults file
              for instructions.

              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  `oonn'  (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 `ooffff',  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  `oonn'  (default),  DDD  lays out two-dimensional
              arrays as tables, such that all array elements  are
              aligned  with  each  other.  If `ooffff', DDD treats a
              two-dimensional  array  as   an   array   of   one-
              dimensional arrays, each aligned on its own.

       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
              `oonn' (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 `ooffff', other displays are not rearranged.

       ddeelleetteeAAlliiaassDDiissppllaayyss ((class DDeelleetteeAAlliiaassDDiissppllaayyss))
              If  this  is  `oonn'  (default),  the  `UUnnddiissppllaayy (())'



DDD 3.0                     1998-06-17                         66





ddd(1)                                                     ddd(1)


              button also deletes all  aliases  of  the  selected
              displays.  If this is `ooffff', only the selected dis-
              plays are deleted; the aliases remain, and  one  of
              the aliases will be unsuppressed.

       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  `oonn',  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
              `ooffff', 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.

       eexxppaannddRReeppeeaatteeddVVaalluueess ((class EExxppaannddRReeppeeaatteeddVVaalluueess))
              GDB can print repeated  array  elements  as  `_V_A_L_U_E
              <<rreeppeeaatteedd  _N ttiimmeess>>'.  If `eexxppaannddRReeppeeaatteeddVVaalluueess' is
              `oonn',  DDD  will  display  _N  instances  of   _V_A_L_U_E
              instead.    If   `eexxppaannddRReeppeeaatteeddVVaalluueess'   is  `ooffff'
              (default),  DDD  will  display  _V_A_L_U_E  with  `<<_Nxx>>''
              aappppeennddeedd ttoo iinnddiiccaattee tthhee rreeppeettiittiioonn..

       hhiiddeeIInnaaccttiivveeDDiissppllaayyss ((ccllaassss 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 `oonn' (default), DDD removes  it  from  the  data
              display.   If this is `ooffff', 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))
              The control to scroll the graph.

              +o If this is `oonn', an Athena panner is used (a kind
                of two-directional scrollbar).

              +o If this is `ooffff' (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.





DDD 3.0                     1998-06-17                         67





ddd(1)                                                     ddd(1)


       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lBBaasseeD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
              is prepended to the `vvssllDDeeffss'  resource  below  and
              set  in  the  DDD  application defaults file; don't
              change it.

       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.  The default
              value is an empty string.   This  resource  can  be
              used  to  override  specific  VSL  definitions that
              affect the data display.

              The general pattern to replace a  function  defini-
              tion _f_u_n_c_t_i_o_n with a new definition _n_e_w___d_e_f is:

              ##pprraaggmmaa rreeppllaaccee _f_u_n_c_t_i_o_n
              _f_u_n_c_t_i_o_n((_a_r_g_s...)) == _n_e_w___d_e_f;;

              The following VSL functions are frequently used:

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



DDD 3.0                     1998-06-17                         68





ddd(1)                                                     ddd(1)


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

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

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

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



DDD 3.0                     1998-06-17                         69





ddd(1)                                                     ddd(1)


                ssttddffoonnttffaammiillyy(()) == ffaammiillyy__ccoouurriieerr(());;\\nn

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


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

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

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

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

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

              Instead  of  supplying  another  VSL library, it is
              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 `oonn' (default), each line from the infe-
              rior  is  output  on  each own, such that the final
              line is placed at the bottom of the  debugger  con-
              sole.   If this is `ooffff', 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



DDD 3.0                     1998-06-17                         70





ddd(1)                                                     ddd(1)


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


       ffoonnttSSeelleeccttCCoommmmaanndd ((class FFoonnttSSeelleeccttCCoommmmaanndd))
              A command to select from  a  list  of  fonts.   The
              string  `@@FFOONNTT@@'  is  replaced  by  the current DDD
              default font; the string `@@TTYYPPEE@@' is replaced by  a
              symbolic name of the DDD font to edit.  The program
              must either place the name of the selected font  in
              the PRIMARY selection or print the selected font on
              standard output.  A typical value is:

                DDdddd**ffoonnttSSeelleeccttCCoommmmaanndd:: xxffoonnttsseell --pprriinntt


       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.



DDD 3.0                     1998-06-17                         71





ddd(1)                                                     ddd(1)


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


       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



DDD 3.0                     1998-06-17                         72





ddd(1)                                                     ddd(1)


              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  to  this  string.  The string `@@FFOONNTT@@' is
              replaced by the name of the fixed width  font  used
              by DDD.  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 --ffnn @@FFOONNTT@@ --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
              `@@UURRLL@@' is replaced by the URL to open.  Default is
              to  try a running Netscape first, then $$WWWWWWBBRROOWWSSEERR,
              then to invoke a new Netscape process, then to  let
              a  running Emacs do the job, then to invoke Mosaic,
              then to invoke Lynx in an xterm.

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



DDD 3.0                     1998-06-17                         73





ddd(1)                                                     ddd(1)


   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 `oonn', 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.

       rroouulleettttee ((class RRoouulleettttee))
              If `oonn', load a random  program  from  one  of  the
              directories  in  the  user's PPAATTHH environment vari-
              able.

       rruussssiiaannRRoouulleettttee ((class RRoouulleettttee))
              Like `rroouulleettttee', but also run the program with  the
              arguments `--ffrr $$HHOOMMEE'.

       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  `oonn',  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wFFoonnttss ((class SShhoowwFFoonnttss))
              If  `oonn', show the DDD font definitions on standard
              output and exit.  See also  the  `----ffoonnttss'  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  `oonn',  show the DDD invocation options on stan-
              dard  output  and  exit.   See  also  the  `----hheellpp'
              option, below.

       sshhoowwLLiicceennssee ((class SShhoowwLLiicceennssee))
              If  `oonn',  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 `oonn', show this DDD manual page on standard out-
              put and exit.  If the standard output is  a  termi-
              nal,  the  manual page is shown in a pager ($$PPAAGGEERR,
              `lleessss' or `mmoorree').  See also the `----mmaannuuaall' option,



DDD 3.0                     1998-06-17                         74





ddd(1)                                                     ddd(1)


              below.

       sshhoowwNNeewwss ((class SShhoowwNNeewwss))
              If  `oonn',  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 `oonn', 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e ((class TTrraaccee))
              If `oonn', show the dialog between DDD and the  infe-
              rior  debugger  on  standard  output.   Default  is
              `ooffff'.

   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.

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

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


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

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

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

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

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

       ----cchheecckk--ccoonnffiigguurraattiioonn
              Check  the  DDD  environment  (in particular, the X



DDD 3.0                     1998-06-17                         75





ddd(1)                                                     ddd(1)


              configuration), report any possible problem  causes
              and exit.

       ----ddaattaa--wwiinnddooww
              Create the data window upon start-up.

       ----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', `xxddbb', or `jjddbb', respectively.  This  option
              can  also  be  used to pass options to the inferior
              debugger 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',
              `----xxddbb',  or  `----jjddbb'--unless  the  default setting
              works fine.

       ----ddeebbuuggggeerr--ccoonnssoollee
              Create the debugger console upon start-up.

       ----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foonnttss
              Show  the  font definitions used by DDD on standard
              output.

       ----ffoonnttssiizzee _s_i_z_e
              Set the default font size to _s_i_z_e 1/10 points.   To
              use 12-point fonts, say `----ffoonnttssiizzee 112200'.

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



DDD 3.0                     1998-06-17                         76





ddd(1)                                                     ddd(1)


              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.

       ----jjddbb  Run JDB as inferior debugger.

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

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




DDD 3.0                     1998-06-17                         77





ddd(1)                                                     ddd(1)


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

       ----rroouulleettttee
              Load a random program from one of  the  directories
              in the user's PPAATTHH environment variable.

       ----rruussssiiaann--rroouulleettttee
              Like  `----rroouulleettttee',  but  run  the program with the
              arguments `--ffrr $$HHOOMMEE'.

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




DDD 3.0                     1998-06-17                         78





ddd(1)                                                     ddd(1)


       ----ssoouurrccee--wwiinnddooww
              Create the source window upon start-up.

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

       ----ssttaattuuss--aatt--ttoopp
              Place the status line at the top of the source 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
              Show  the  interaction between DDD and the inferior
              debugger on standard error.   This  is  useful  for
              debugging DDD.  If `----ttrraaccee' is not specified, this
              information is written into `$$HHOOMMEE//..dddddd//lloogg',  such
              that you can also do a post-mortem debugging.

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

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



DDD 3.0                     1998-06-17                         79





ddd(1)                                                     ddd(1)


       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--ggeett--ffooccuuss (())
              Assign focus to  the  element  that  just  received
              input.

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





DDD 3.0                     1998-06-17                         80





ddd(1)                                                     ddd(1)


       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.

       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.




DDD 3.0                     1998-06-17                         81





ddd(1)                                                     ddd(1)


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

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

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

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

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

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

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

       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.



DDD 3.0                     1998-06-17                         82





ddd(1)                                                     ddd(1)


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

       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.  The  fol-
              lowing replacements are performed on _c_o_m_m_a_n_d:

              +o If  _c_o_m_m_a_n_d  has the form '_n_a_m_e......', insert _n_a_m_e,
                followed by a space, in the debugger console.

              +o All occurrences of `(())' are replaced by the  cur-
                rent contents of the argument field `()'.

       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.

       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 EEnndd.

       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 RRiigghhtt.




DDD 3.0                     1998-06-17                         83





ddd(1)                                                     ddd(1)


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

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

       ggddbb--iinntteerrrruupptt (())
              If DDD is in incremental search mode, exit it; oth-
              erwise call ggddbb--ccoonnttrrooll((^^CC)).

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

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

       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--nneexxtt--hhiissttoorryy (())
              Recall next command from history.  Bound to 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 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 UUpp.

       ggddbb--pprroocceessss (([[_a_c_t_i_o_n[[,, _a_r_g_s_._._.]]]]))
              Process the given event in  the  debugger  console.
              Bound  to key events in the source and data window.
              If this action is bound to the source  window,  and
              the    source    window    is   editable,   perform
              _a_c_t_i_o_n((_a_r_g_s_._._.)) on the source  window  instead;  if
              _a_c_t_i_o_n is not given, perform `sseellff--iinnsseerrtt(())'.

       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--ddeelleettee--ggllyypphh (())
              Delete  the breakpoint related to the glyph at cur-
              sor position.

       ssoouurrccee--ddoouubbllee--cclliicckk (([[_t_e_x_t_-_a_c_t_i_o_n [,_l_i_n_e_-_a_c_t_i_o_n]])
              The double-click action in the source window.

              +o If this action is taken on  a  breakpoint  glyph,
                edit the breakpoint properties.



DDD 3.0                     1998-06-17                         84





ddd(1)                                                     ddd(1)


              +o If  this  action is taken in the breakpoint area,
                invoke  `ggddbb--ccoommmmaanndd((_l_i_n_e_-_a_c_t_i_o_n))'.    If   _l_i_n_e_-
                _a_c_t_i_o_n is not given, it defaults to `bbrreeaakk (())'.

              +o Otherwise, invoke `ggddbb--ccoommmmaanndd((_t_e_x_t_-_a_c_t_i_o_n))'.  If
                _t_e_x_t_-_a_c_t_i_o_n is not given, it defaults  to  `ggrraapphh
                ddiissppllaayy (())'.

       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--ddrroopp--ggllyypphh (([[_a_c_t_i_o_n])
              Drop  the dragged glyph at cursor position.  _a_c_t_i_o_n
              is either  `mmoovvee',  meaning  to  move  the  dragged
              glyph,  or  `ccooppyy',  meaning  to  copy  the dragged
              glyph.  If no _a_c_t_i_o_n is given, `mmoovvee' is assumed.

       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--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--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--uuppddaattee--ggllyypphhss (())
              Update all visible glyphs.  Usually invoked after a
              scrolling operation.

IIMMAAGGEESS
       DDD installs a number of  pixmaps  that  may  be  used  as
       pixmap  resources,  simply by giving a symbolic name.  For
       button pixmaps, two variants are also installed:

       +o The suffix  `--xxxx'  indicates  a  disabled  (insensitive)
         variant.

       +o The  suffix `--aarrmm' indicates an armed variant (Button is
         pushed).

       bbrreeaakk__aatt
         `BBrreeaakk aatt (())' button.

       cclleeaarr__aatt
         `CClleeaarr aatt (())' button.

       dddddd
         DDD icon.




DDD 3.0                     1998-06-17                         85





ddd(1)                                                     ddd(1)


       ddeelleettee
         `DDeelleettee (())' button.

       ddiissaabbllee
         `DDiissaabbllee' button.

       ddiisspprreeff
         `DDiissppllaayy ** (())' button.

       ddiissppllaayy
         `DDiissppllaayy (())' button.

       ddrraagg__aarrrrooww
         The execution pointer (being dragged).

       ddrraagg__ccoonndd
         A conditional breakpoint (being dragged).

       ddrraagg__ssttoopp
         A breakpoint (being dragged).

       ddrraagg__tteemmpp
         A temporary breakpoint (being dragged).

       eennaabbllee
         `EEnnaabbllee' button.

       ffiinndd__ffoorrwwaarrdd
         `FFiinndd>>>> (())' button.

       ffiinndd__bbaacckkwwaarrdd
         `FFiinndd<<<< (())' button.

       ggrreeyy__aarrrrooww
         The execution pointer (not in lowest frame).

       ggrreeyy__ccoonndd
         A conditional breakpoint (disabled).

       ggrreeyy__ssttoopp
         A breakpoint (disabled).

       ggrreeyy__tteemmpp
         A temporary breakpoint (disabled).

       hhiiddee
         `HHiiddee (())' button.

       llooookkuupp
         `LLooookkuupp (())' button.

       mmaakkeetteemmpp
         `MMaakkee TTeemmppoorraarryy' button.




DDD 3.0                     1998-06-17                         86





ddd(1)                                                     ddd(1)


       nneeww__bbrreeaakk
         `NNeeww BBrreeaakkppooiinntt' button.

       nneeww__ddiissppllaayy
         `NNeeww DDiissppllaayy' button.

       nneeww__wwaattcchh
         `NNeeww WWaattcchhppooiinntt' button.

       ppllaaiinn__aarrrrooww
         The execution pointer.

       ppllaaiinn__ccoonndd
         A conditional breakpoint (enabled).

       ppllaaiinn__ssttoopp
         A breakpoint (enabled).

       ppllaaiinn__tteemmpp
         A temporary breakpoint (enabled).

       pprriinntt
         `PPrriinntt (())' button.

       pprrooppeerrttiieess
         `PPrrooppeerrttiieess' button.

       rroottaattee
         `RRoottaattee (())' button.

       sseett
         `SSeett (())' button.

       sshhooww
         `SShhooww (())' button.

       ssiiggnnaall__aarrrrooww
         The execution pointer (stopped by signal).

       uunnddiissppllaayy
         `UUnnddiissppllaayy (())' button.

       uunnwwaattcchh
         `UUnnwwaattcchh (())' button.

       wwaattcchh
         `WWaattcchh (())' button.


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 3.0                     1998-06-17                         87





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//'.
       EEDDIITTOORR              The text editor to invoke for  editing
                           source  code.   See  the `eeddiittCCoommmmaanndd'
                           resource, above.
       VVSSLL__IINNCCLLUUDDEE         Where to search for VSL include files.
                           Default is the current directory.
       WWWWWWBBRROOWWSSEERR          The  WWW browser to invoke for viewing
                           the DDD WWW page.   See  the  `wwwwwwCCoomm--
                           mmaanndd' resource, above.
       XXEEDDIITTOORR             The  X  editor  to  invoke for editing
                           source code.   See  the  `eeddiittCCoommmmaanndd'
                           resource,  above.  The following envi-
                           ronment 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'  resource (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.




DDD 3.0                     1998-06-17                         88





ddd(1)                                                     ddd(1)


       $$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//..dddddd//ttiippss     DDD  tips resource file.  Contains the
                           number of the next tip of the day.
       $$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;
                           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.

       _j_d_b_-_-_T_h_e  _J_a_v_a  _D_e_b_u_g_g_e_r,  at hhttttpp::////jjaavvaa..ssuunn..ccoomm// and its
       mirrors in pprroodduuccttss//jjddkk//11..11//ddooccss//ttoooollddooccss//ssoollaarriiss//jjddbb..hhttmmll

       _J_a_v_a  _L_a_n_g_u_a_g_e  _D_e_b_u_g_g_i_n_g, at hhttttpp::////jjaavvaa..ssuunn..ccoomm// and its
       mirrors in pprroodduuccttss//jjddkk//11..11//ddeebbuuggggiinngg//

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




DDD 3.0                     1998-06-17                         89





ddd(1)                                                     ddd(1)


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


   LLiimmiittaattiioonnss uussiinngg DDBBXX
       When used for debugging Pascal-like programs, DDD does not
       infer  correct array subscripts and always starts to count
       with 1.

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

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



DDD 3.0                     1998-06-17                         90





ddd(1)                                                     ddd(1)


       The JDB `dduummpp' and `pprriinntt' commands do not support expres-
       sion  evaluation.   Hence,  you  cannot  display arbitrary
       expressions.

       Parsing of JDB output is quite CPU-intensive, due  to  the
       recognition of asynchronous prompts (any thread may output
       anything at any time, including prompts).  Hence,  a  pro-
       gram  producing much console output is likely to slow down
       DDD considerably.  In such a case, have  the  program  run
       with  --ddeebbuugg  in  a  separate  window and attach JDB to it
       using the --ppaasssswwdd option.

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

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 3.0                     1998-06-17                         91





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.  (If
       `----ttrraaccee' is not given,  this  interaction  is  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 3.0                     1998-06-17                         92





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177' 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..66').

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

       +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.   By  default,  this  interaction  is
         logged  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;
         insert own comments where necessary.

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



DDD 3.0                     1998-06-17                         93





ddd(1)                                                     ddd(1)


       Thesis, a graphical syntax editor based on the Programming
       System Generator PSG.

       In  1992,  the VSL and BOX libraries were recycled for the
       NORA project.  For NORA, an  experimental  inference-based
       software  development tool set, Andreas wrote a graph edi-
       tor (based on VSL and the BOX  libraries)  and  facilities
       for  inter-process  knowledge  exchange.   Based  on these
       tools, _D_o_r_o_t_h_e_a _L___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, Andreas has further main-
       tained and extended DDD, based on the comments and sugges-
       tions of several DDD users around the world.  See the com-
       ments 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.
       June, 1998          DDD  3.0: Icon tool bar, Java support,
                           JDB support.

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




DDD 3.0                     1998-06-17                         94





ddd(1)                                                     ddd(1)


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

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



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

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

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

       This directory also contains other  documentation  related
       to DDD.

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


CCOOPPYYRRIIGGHHTT
       DDD is Copyright (C) 1995,  1996,  1997,  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



DDD 3.0                     1998-06-17                         95





ddd(1)                                                     ddd(1)


       and this permission notice are preserved on all copies.

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

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











































DDD 3.0                     1998-06-17                         96


