


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] [----ppyyddbb] [----ppeerrll]
              [----ddeebbuuggggeerr _n_a_m_e] [----[rr]hhoosstt [_u_s_e_r_n_a_m_e@@]_h_o_s_t_n_a_m_e]]
              [----hheellpp] [----ttrraaccee] [----vveerrssiioonn] [----ccoonnffiigguurraattiioonn]
              [_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, JDB, Python debugger, or Perl 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:

         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



DDD 3.1                     1998-12-01                          1





ddd(1)                                                     ddd(1)


       argument, 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 determines the inferior debugger automati-
       cally.  Use

         dddddd ----ggddbb _p_r_o_g_r_a_m

       or

         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

       or

         dddddd ----ppyyddbb _m_o_d_u_l_e

       or

         dddddd ----ppeerrll _p_r_o_g_r_a_m_f_i_l_e

       to run GDB, DBX, XDB, JDB, PYDB or Perl as inferior debug-
       ger.

       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.



DDD 3.1                     1998-12-01                          2





ddd(1)                                                     ddd(1)


       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.

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




DDD 3.1                     1998-12-01                          3





ddd(1)                                                     ddd(1)


       +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 and Perl, the argument field provides a comple-
       tion mechanism.  You can enter the first few characters of
       an item an press the TTAABB key to complete it.  Pressing TTAABB
       again shows alternative completions.

       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??
       If you are 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'



DDD 3.1                     1998-12-01                          4





ddd(1)                                                     ddd(1)


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

   UUnnddooiinngg CCoommmmaannddss
       And  if,  after  all,  you  made  a  mistake, don't worry.
       Almost every DDD command can be undone, using `EEddiitt-->>UUnnddoo'
       or  the  `UUnnddoo'  button  on  the  command tool.  Likewise,
       `EEddiitt-->>RReeddoo' repeats the command most recently undone.

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

       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.



DDD 3.1                     1998-12-01                          5





ddd(1)                                                     ddd(1)


   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.

       As  an  even faster alternative, you can also double-click
       on a function call (an identifier followed by a `(('  char-
       acter) to lookup the function definition.

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

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

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

   LLooookkiinngg uupp PPrreevviioouuss LLooccaattiioonnss
       After looking up a  location,  use  `EEddiitt-->>UUnnddoo'  (or  the
       `UUnnddoo' button on the command tool) to go back to the orig-
       inal locations.  `EEddiitt-->>RReeddoo' brings you back again to the
       location you looked for.


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 simply double-click
       on the left of the source line to set a breakpoint.



DDD 3.1                     1998-12-01                          6





ddd(1)                                                     ddd(1)


       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.

       If  you  set  a breakpoint by mistake, use `EEddiitt-->>UUnnddoo' to
       delete it again.

       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:

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




DDD 3.1                     1998-12-01                          7





ddd(1)                                                     ddd(1)


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

       As a faster alternative, you can  simply  double-click  on
       the left of the source line while holding CCttrrll.

       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.




DDD 3.1                     1998-12-01                          8





ddd(1)                                                     ddd(1)


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

       As an even faster alternative, you can simply double-click
       on the breakpoint while holding CCttrrll.

   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
       _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 simply 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  has  no  way  to  make  a temporary breakpoint non-
         temporary again.

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




DDD 3.1                     1998-12-01                          9





ddd(1)                                                     ddd(1)


   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,  Perl  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:

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



DDD 3.1                     1998-12-01                         10





ddd(1)                                                     ddd(1)


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



DDD 3.1                     1998-12-01                         11





ddd(1)                                                     ddd(1)


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



DDD 3.1                     1998-12-01                         12





ddd(1)                                                     ddd(1)


       `PPrrooggrraamm-->>RRuunn'.  You will then be prompted for  the  argu-
       ments 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 `RRuunn' 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.


   UUssiinngg tthhee EExxeeccuuttiioonn WWiinnddooww
       By  default,  input  and  output of your 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.  To activate the execution window, select
       `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'.

       While  the  execution  window  is active, DDD invokes your
       program such that its standard input,  output,  and  error
       streams are redirected to the execution window.  Note that
       the device `//ddeevv//ttttyy' still refers to  the  debugger  con-
       sole, _n_o_t the execution window.

       You  can  override  the  DDD  stream redirection by giving
       alternate  redirection  operations  as   arguments.    For
       instance,  to  have  your program read from a file, but to
       write to the execution window, invoke your program with `<<
       _f_i_l_e'  as  argument.   Likewise,  to redirect the standard
       error output to the debugger console,  use  `22>>  //ddeevv//ttttyy'
       (assuming  the  inferior  debugger  and/or your UNIX shell
       support standard error redirection).

       The execution window is not available in JDB and Perl.

   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 mod-
       ify an attached process with all the DDD commands that are
       ordinarily  available when you start processes with `RRuunn'.
       You can insert breakpoints; you can step and continue; you
       can  modify  storage. If you would rather the process con-
       tinue running, you may use `CCoonnttiinnuuee' after attaching  DDD
       to the process.

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



DDD 3.1                     1998-12-01                         13





ddd(1)                                                     ddd(1)


       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, PYDB, and Perl do  not  support  attaching  the
       debugger to running 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  until a greater line in the current function
       is reached, click on the `UUnnttiill' button.  This  is  useful
       to avoid single stepping through a loop more than once.

       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.

   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.



DDD 3.1                     1998-12-01                         14





ddd(1)                                                     ddd(1)


       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.

       `UUpp' and `DDoowwnn' actions can be undone via `EEddiitt-->>UUnnddoo'.





DDD 3.1                     1998-12-01                         15





ddd(1)                                                     ddd(1)


   ""UUnnddooiinngg"" PPrrooggrraamm EExxeeccuuttiioonn
       If you take a look at the `EEddiitt-->>UUnnddoo' menu item after  an
       execution command, you'll find that DDD offers you to undo
       execution commands just as other commands.  Does this mean
       that  DDD allows you to go backwards in time, undoing pro-
       gram execution as well as undoing any side-effects of your
       program?

       Sorry--we  must disappoint you.  DDD cannot undo what your
       program did.  (After a little bit of thought, you'll  find
       that  this  would  be impossible in general.) However, DDD
       can  do  something  different:  it  can  show   _p_r_e_v_i_o_u_s_l_y
       _r_e_c_o_r_d_e_d _s_t_a_t_e_s of your program.

       After "undoing" an execution command (via `EEddiitt-->>UUnnddoo', or
       the `UUnnddoo' button), the execution position moves  back  to
       the  earlier  position  and displayed variables take their
       earlier values.  Your program state is in fact  unchanged,
       but  DDD gives you a _v_i_e_w on the earlier state as recorded
       by DDD.

       In this so-called _h_i_s_t_o_r_i_c _m_o_d_e, most normal DDD  commands
       that  would query further information from the program are
       disabled, since the debugger cannot  be  queried  for  the
       earlier  state.  However, you can examine the current exe-
       cution position, or the displayed variables.  Using `UUnnddoo'
       and `RReeddoo', you can move back and forward in time to exam-
       ine how your program got into the present state.

       To let you know that you are operating in  historic  mode,
       the  execution  arrow gets a dashed-line appearance (indi-
       cating a past position); variable displays also come  with
       dashed  lines.   Furthermore,  the status line informs you
       that you are seeing an earlier program state.

       Here's how historic mode works:  each  time  your  program
       stops, DDD collects the current execution position and the
       values of displayed  variables.   Backtrace,  thread,  and
       register  information is also collected if the correspond-
       ing dialogs are open.  When "undoing"  an  execution  com-
       mand,  DDD  updates  its  view  from  this collected state
       instead of querying the program.

       If you want to collect this information without interrupt-
       ing  your  program--within  a  loop, for instance--you can
       place a breakpoint with an associated `ccoonntt' command;  see
       `BBrreeaakkppooiinntt  CCoommmmaannddss',  above,  for  details.   When  the
       breakpoint is hit, DDD will stop, collect  the  data,  and
       execute  the  `ccoonntt' command, resuming execution.  Using a
       later `UUnnddoo', you can step back and look at  every  single
       loop iteration.

       To  leave  historic mode, you can use `RReeddoo' until you are
       back in the  current  program  state.   However,  any  DDD



DDD 3.1                     1998-12-01                         16





ddd(1)                                                     ddd(1)


       command  that refers to program state will also leave his-
       toric mode immediately by applying to the current  program
       state  instead.   For  instance, `UUpp' leaves historic mode
       immediately and selects an alternate frame in the restored
       current program state.

       If  you want to see the history of a specific variable, as
       recorded during program stops, you can enter the DDD  com-
       mand

         ggrraapphh hhiissttoorryy _n_a_m_e

       This  returns  a list of all previously recorded values of
       the variable _n_a_m_e, using array  syntax.   Note  that  _n_a_m_e
       must have been displayed at earlier program stops in order
       to record values.

   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 thread group;

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




DDD 3.1                     1998-12-01                         17





ddd(1)                                                     ddd(1)


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



DDD 3.1                     1998-12-01                         18





ddd(1)                                                     ddd(1)


                 see this signal.


       The  entry  `AAllll  SSiiggnnaallss' is special.  Changing a setting
       here affects _a_l_l _s_i_g_n_a_l_s _a_t _o_n_c_e--except those used by the
       debugger, typically SIGTRAP and SIGINT.

       To undo any changes, use `EEddiitt-->>UUnnddoo'.  The `RReesseett' button
       restores the saved settings.

       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 `PPaassss' setting in `SSttaattuuss-->>SSiiggnnaallss'  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
       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Eddiitt-->>SSaavvee OOppttiioonnss' does not  save  changed  signal  set-
       tings,  since  changed signal settings are normally useful
       within specific projects only.  Instead,  signal  settings
       are saved with the current session, using `FFiillee-->>SSaavvee SSeess--
       ssiioonn AAss'.

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



DDD 3.1                     1998-12-01                         19





ddd(1)                                                     ddd(1)


       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.

       PPlloottttiinngg VVaalluueess
                 If you want to examine arrays of numeric values,
                 you can plot them graphically in a separate plot
                 window.   The plot is updated each time the pro-
                 gram stops.  This is useful  for  large  numeric
                 arrays.

       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.


   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



DDD 3.1                     1998-12-01                         20





ddd(1)                                                     ddd(1)


       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 [cclluusstteerreedd] [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  `cclluusstteerreedd'  is specified, the new data
         display is created in a cluster.  See  `CClluusstteerriinngg  DDiiss--
         ppllaayyss', below, for a discussion.

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

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

       If you created a display by mistake, use  `EEddiitt-->>UUnnddoo'  to
       undisplay it.





DDD 3.1                     1998-12-01                         21





ddd(1)                                                     ddd(1)


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

       You can select individual displays  by  clicking  on  them
       with _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.

       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



DDD 3.1                     1998-12-01                         22





ddd(1)                                                     ddd(1)


              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 either

       +o a  space-separated list of display numbers to disable or
         enable, or

       +o a single display name.  If  you  specify  a  display  by
         name, all displays with this name will be affected.

       Use `EEddiitt-->>UUnnddoo' to undo disabling or enabling displays.

   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.




DDD 3.1                     1998-12-01                         23





ddd(1)                                                     ddd(1)


   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
       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 3.1                     1998-12-01                         24





ddd(1)                                                     ddd(1)


       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 GDB `NNeeww DDiissppllaayy' menu, where
       each of the base conversions has a label:

           //tt (()) //// CCoonnvveerrtt ttoo BBiinn
           //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.
       If  you press CCttrrll while double-clicking, the display will
       be dereferenced _i_n _p_l_a_c_e--that is, it will be replaced  by
       the dereferenced display.

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

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



   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
       You  can  create a display from the output of an arbitrary



DDD 3.1                     1998-12-01                         25





ddd(1)                                                     ddd(1)


       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,

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

       creates a status display named `WWhheerree' that shows the cur-
       rent backtrace.

       If you are using GDB, DDD provides a panel from which  you
       can  choose  useful  status  displays.  Select `DDaattaa-->>MMoorree
       SSttaattuuss DDiissppllaayyss' and pick your choice from the list.


       Status displays consume time; 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,
       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



DDD 3.1                     1998-12-01                         26





ddd(1)                                                     ddd(1)


       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.


       If you made a mistake, you can use `EEddiitt-->>UUnnddoo' to  re-set
       the variable to its previous value.

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



DDD 3.1                     1998-12-01                         27





ddd(1)                                                     ddd(1)


   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.  _d_i_s_p_l_a_y_s_._._. is either

       +o a space-separated list of display numbers to delete, or

       +o a single display name.  If  you  specify  a  display  by
         name, all displays with this name will be deleted.

       If  you  are using stacked windows, deleting the last dis-
       play from the data window also  automatically  closes  the
       data     window.      (You    can    change    this    via
       `EEddiitt-->>PPrreeffeerreenncceess-->>DDaattaa-->>CClloossee ddaattaa wwiinnddooww wwhheenn  ddeelleettiinngg
       llaasstt ddiissppllaayy'.)

       If  you  deleted a display by mistake, use `EEddiitt-->>UUnnddoo' to
       re-create it.

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

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

       When alias detection is enabled, DDD inquires  the  memory
       location  (the  _a_d_d_r_e_s_s)  of  each data display after each
       program step.  If two displays have the same address, they
       are  merged  into  one.   More  specifically, only the one



DDD 3.1                     1998-12-01                         28





ddd(1)                                                     ddd(1)


       which has least recently  changed  remains  (the  _o_r_i_g_i_n_a_l
       _d_a_t_a _d_i_s_p_l_a_y); all other aliases are _s_u_p_p_r_e_s_s_e_d, i.e. com-
       pletely hidden.  The edges  leading  to  the  aliases  are
       replaced by edges leading to the original data display.

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

       Each edge hint is a placeholder for  a  suppressed  alias;
       selecting  an  edge  hint  is  equivalent to selecting the
       alias.  This way, you can easily delete display aliases by
       simply  selecting the edge hint and clicking on `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.

       +o Alias detection slows down DDD slightly, 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 examining control
         flow (i.e., stepping through your  program).   DDD  will



DDD 3.1                     1998-12-01                         29





ddd(1)                                                     ddd(1)


         automatically  restore  edges  and  data  displays  when
         switching modes.


   CClluusstteerriinngg DDiissppllaayyss
       If you examine several variables at once, having  a  sepa-
       rate  display for each of them uses a lot of screen space.
       This is why DDD supports _c_l_u_s_t_e_r_s.  A cluster merges  sev-
       eral logical data displays into one physical display, sav-
       ing screen space.

       There are two ways to create clusters:

       +o You can create  clusters  _m_a_n_u_a_l_l_y.   This  is  done  by
         selecting  the  displays  to  be  clustered and choosing
         `UUnnddiisspp-->>CClluusstteerr (())'.  This creates a new  cluster  from
         all  selected  displays.  If an already existing cluster
         is selected, too, the selected displays  will  be  clus-
         tered into the selected cluster.

       +o You  can create a cluster _a_u_t_o_m_a_t_i_c_a_l_l_y for all indepen-
         dent data displays, such that all new data displays will
         automatically  be  clustered,  too.  This is achieved by
         enabling  `EEddiitt-->>PPrreeffeerreenncceess-->>DDaattaa-->>CClluusstteerr  DDaattaa   DDiiss--
         ppllaayyss'.


       Displays in a cluster can be selected and manipulated like
       parts of an ordinary display; in particular, you can  show
       and hide details, or dereference pointers.  However, edges
       leading to clustered displays can not be  shown,  and  you
       must either select one or all clustered displays.

       Disabling  a  cluster  is  called _u_n_c_l_u_s_t_e_r_i_n_g, and again,
       there are two ways of doing it:

       +o You can uncluster displays _m_a_n_u_a_l_l_y,  by  selecting  the
         cluster and choosing `UUnnddiisspp-->>UUnncclluusstteerr (())'.

       +o You  can  uncluster  all  current and future displays by
         disabling  `EEddiitt-->>PPrreeffeerreenncceess-->>DDaattaa-->>CClluusstteerr  DDaattaa  DDiiss--
         ppllaayyss'.


   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



DDD 3.1                     1998-12-01                         30





ddd(1)                                                     ddd(1)


       _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
       `EEddiitt-->>PPrreeffeerreenncceess-->>DDaattaa-->>CCoommppaacctt  llaayyoouutt'  option.   This
       realizes  an  alternate layout algorithm, where successors
       are placed next to their parents.  This algorithm is suit-
       able for homogeneous data structures only.

       You      can      enforce      layout      by      setting
       `EEddiitt-->>PPrreeffeerreenncceess-->>DDaattaa-->> AAuuttoommaattiicc  LLaayyoouutt'.   If  auto-
       matic  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.



DDD 3.1                     1998-12-01                         31





ddd(1)                                                     ddd(1)


   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.

       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 the graph in  another
         document;

       +o FFIIGG--suitable   for   post-processing,  using  the  XFIG
         graphic editor, or for  conversion  into  other  formats
         (among  others IBMGL, LATEX, PIC), using the TRANSFIG or
         FIG2DEV package.


       Please note the  following  _c_a_v_e_a_t_s  related  to  printing
       graphs:

       +o If  any displays were selected when invoking the `PPrriinntt'
         dialog, the option `SSeelleecctteedd OOnnllyy' is set.   This  makes
         DDD print only the selected displays.

       +o The `CCoolloorr', `OOrriieennttaattiioonn', and `PPaappeerr SSiizzee' options are
         meaningful for PostScript only.


PPLLOOTTTTIINNGG DDAATTAA
       If you have huge amounts of numerical data to  examine,  a
       picture  often  says more than a thousand numbers.  There-
       fore, DDD allows you to draw numerical values in nice  2-D
       and 3-D plots.

   PPlloottttiinngg AArrrraayyss
       Basically, DDD can plot two types of numerical values:

       +o One-dimensional  arrays.   These  are drawn in a 2-D _X/_Y
         space, where _X denotes the array index, and _Y  the  ele-
         ment value.

       +o Two-dimensional  arrays.  These are drawn in a 3-D _X/_Y/_Z
         space, where _X and _Y denote the array indexes, and _Z the



DDD 3.1                     1998-12-01                         32





ddd(1)                                                     ddd(1)


         element value.

       To  plot an array, select it by clicking _m_o_u_s_e _b_u_t_t_o_n _1 on
       an occurrence.  The array name is copied to  the  argument
       field.   By  clicking  the `PPlloott' button, a new display is
       created in the data window, followed by  a  new  top-level
       window containing the value plot.

       Each  time the value changes during program execution, the
       plot is updated to reflect the current values.   The  plot
       window   remains   active   until   you   close   it  (via
       `FFiillee-->>CClloossee') or until the associated display is deleted.

   CChhaannggiinngg tthhee PPlloott AAppppeeaarraannccee
       The  actual  drawing  is not done by DDD itself.  Instead,
       DDD relies on an external Gnuplot program  to  create  the
       drawing.   DDD  adds a menu bar to the Gnuplot plot window
       that lets you influence the appearance of the plot:

       +o The `VViieeww' menu toggles optional parts of the plot, such
         as border lines or a background grid.

       +o The  `PPlloott'  menu  changes the plotting style.  The `33--DD
         LLiinneess' option is  useful  for  plotting  two-dimensional
         arrays.

       +o The  `SSccaallee' menu allows you to enable logarithmic scal-
         ing and to enable or disable the scale tics.

       +o The `CCoonnttoouurr' menu adds contour lines to 3-D plots.

       You can also resize the plot window as desired.

       In a 3-D plot, you can use the scroll bars to change  your
       view position.  The horizontal scroll bar rotates the plot
       around the _Z axis, that is, to the left  and  right.   The
       vertical  scroll  bar  rotates the plot around the _Y axis,
       that is, up and down.


   PPlloottttiinngg SSccaallaarrss aanndd CCoommppoossiitteess
       Besides plotting arrays,  DDD  also  allows  you  to  plot
       scalars  (simple  numerical values).  This works just like
       plotting arrays--you select the numerical variable,  click
       on  `PPlloott',  and here comes the plot.  However, plotting a
       scalar is not very exciting.  A plot that contains nothing
       but  a  scalar simply draws the scalar's value as a _Y con-
       stant--that is, a horizontal line.

       So why care about scalars at all?  DDD allows you to  com-
       bine multiple values into one plot.  The basic idea is: if
       you want to plot something that is neither an array nor  a
       scalar, DDD takes all numerical sub-values it can find and
       plots them all together in one window.  For instance,  you



DDD 3.1                     1998-12-01                         33





ddd(1)                                                     ddd(1)


       can  plot  all local variables by selecting `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', followed by `PPlloott'.  This will create  a
       plot  containing all numerical values as found in the cur-
       rent local variables.  Likewise, you can plot all  numeric
       members contained in a structure by selecting it, followed
       by `PPlloott'.

       If you want more control about what to include in  a  plot
       and  what  not, you can use display clusters.  (See `CClluuss--
       tteerriinngg DDiissppllaayyss', above, for details on clusters.)  A com-
       mon  scenario  is to plot a one-dimensional array together
       with the current index position.  This is  done  in  three
       steps:

       +o Display the array and the index, using `DDiissppllaayy (())'.

       +o Cluster   both   displays:   select   them   and  choose
         `UUnnddiisspp-->>CClluusstteerr (())'.

       +o Plot the cluster by pressing `PPlloott'.

       Scalars that are displayed together  with  arrays  can  be
       displayed  either  as  vertical lines or horizontal lines.
       By default, scalars are plotted as horizontal lines.  How-
       ever,  if  a scalar is a valid index for an array that was
       previously plotted, it is shown as a vertical  line.   You
       can  change this initial alignment by selecting the scalar
       display, followed by `RRoottaattee (())'.

   PPlloottttiinngg DDiissppllaayy HHiissttoorriieess
       At each program stop, DDD records the values of  all  dis-
       played variables.  These _d_i_s_p_l_a_y _h_i_s_t_o_r_i_e_s can be plotted,
       too.  The menu item `PPlloott-->>PPlloott hhiissttoorryy ooff (())'  creates  a
       plot  that  shows  all  previously  recorded values of the
       selected display.

   PPrriinnttiinngg PPlloottss
       If you want to print the plot, select `FFiillee-->>PPrriinntt  PPlloott'.
       This  pops up the DDD printing dialog, set up for printing
       plots.  Just as when printing graphs, you have the  choice
       between  printing  to  a  printer or a file and setting up
       appropriate options.

       The actual printing is also performed  by  Gnuplot,  using
       the appropriate driver.  Please note the following caveats
       related to printing:

       +o Creating FFIIGG files requires an appropriate driver  built
         into Gnuplot.  Your Gnuplot program may not contain such
         a driver.  In this case, you will have to recompile Gnu-
         plot,  including  the  line `##ddeeffiinnee FFIIGG' in the Gnuplot
         `tteerrmm..hh' file.

       +o The `PPoorrttrraaiitt' option generates an EEPPSS file  useful  for



DDD 3.1                     1998-12-01                         34





ddd(1)                                                     ddd(1)


         inclusion  in  other  documents.  The `LLaannddssccaappee' option
         makes DDD print the plot in the size  specified  in  the
         `PPaappeerr  SSiizzee'  option;  this is useful for printing on a
         printer.  In `PPoorrttrraaiitt' mode, the `PPaappeerr SSiizzee' option is
         ignored.

       +o The  PostScript  and X11 drivers each have their own set
         of colors, such that the printed colors may differ  from
         the displayed colors.

       +o The  `SSeelleecctteedd OOnnllyy' option is set by default, such that
         only the currently selected plot is  printed.   (If  you
         select multiple plots to be printed, the respective out-
         puts will all be concatenated, which may not be what you
         desire.)


   EEnntteerriinngg PPlloottttiinngg CCoommmmaannddss
       Via   `FFiillee-->>CCoommmmaanndd',  you  can  enter  Gnuplot  commands
       directly.  Each command entered at the  `ggnnuupplloott>>'  prompt
       is  passed to Gnuplot, followed by a Gnuplot `rreepplloott' com-
       mand to update the view.  This is useful for advanced Gnu-
       plot tasks.

       Here's  a simple example.  The Gnuplot command `sseett xxrraannggee
       [[_x_m_i_n::_x_m_a_x]]' sets the horizontal range that will  be  dis-
       played  to  _x_m_i_n..._x_m_a_x.   To plot only the elements 10 to
       20, enter:

         gnuplot>sseett xxrraannggee [[1100::2200]]

       After each command entered, DDD adds a  `rreepplloott'  command,
       such that the plot is updated automatically.

       Here's  a more complex example.  The following sequence of
       Gnuplot commands saves the plot in LATEX format:

         gnuplot>sseett oouuttppuutt ""pplloott..tteexx"" # Set the output filename
         gnuplot>sseett tteerrmm llaatteexx        # Set the output format
         gnuplot>sseett tteerrmm xx1111          #  Show  original  picture
       again

       Due  to the implicit `rreepplloott' command, the output is auto-
       matically written to `pplloott..tteexx' after the `sseett tteerrmm llaatteexx'
       command.

       The  dialog  keeps  track of the commands entered; use the
       arrow keys to restore previous  commands.   Gnuplot  error
       messages (if any) are also shown in the history area.

       The  interaction  between DDD and Gnuplot is logged in the
       file `$$HHOOMMEE//..dddddd//lloogg'.  The DDD `----ttrraaccee' option logs this
       interaction on standard output.




DDD 3.1                     1998-12-01                         35





ddd(1)                                                     ddd(1)


   EExxppoorrttiinngg PPlloott DDaattaa
       If you want some external program to process the plot data
       (a stand-alone Gnuplot program or the  xxmmggrr  program,  for
       instance),  you  can  save  the plot data in a file, using
       `FFiillee-->>SSaavvee DDaattaa AAss'.  This pops up a dialog that lets you
       choose a data file to save the plotted data in.

       The  generated  file starts with a few comment lines.  The
       actual data follows in X/Y or X/Y/Z  format.   It  is  the
       same file as processed by Gnuplot.

   AAnniimmaattiinngg PPlloottss
       If  you want to see how your data evolves in time, you can
       set a breakpoint whose command sequence ends in  a  `ccoonntt'
       command.  Each time this "continue" breakpoint is reached,
       the program stops and DDD updates  the  displayed  values,
       including  the  plots.   Then, DDD executes the breakpoint
       command sequence, resuming execution.

       This way, you can set  a  "continue"  breakpoint  at  some
       decisive  point  within  an array-processing algorithm and
       have DDD display the progress graphically.  When your pro-
       gram has topped for good, you can use `UUnnddoo' and `Redo' to
       redisplay and examine previous program states.

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



DDD 3.1                     1998-12-01                         36





ddd(1)                                                     ddd(1)


       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.

   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 GDB or DBX, you can examine memory in any of several
       formats, 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,



DDD 3.1                     1998-12-01                         37





ddd(1)                                                     ddd(1)


                   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.

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






DDD 3.1                     1998-12-01                         38





ddd(1)                                                     ddd(1)


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

       By default, DDD tries a number of common editors.  You can
       customize  DDD  to   use   your   favourite   editor   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 updated.

       If you have DDD and an editor running in parallel, you can
       also  update  the source code manually via `SSoouurrccee-->>RReellooaadd
       SSoouurrccee'.  This reloads the  source  code  shown  from  the
       source  file.   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  `_t_h_r_e_a_d[[_d_e_p_t_h]]'  for  JDB,  or
       `((PPyyddbb))'  for PYDB, or `DDBB<<>>' for Perl.  You can use arbi-
       trary 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  and  Perl,  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.



DDD 3.1                     1998-12-01                         39





ddd(1)                                                     ddd(1)


   FFrreeqquueennttllyy UUsseedd PPrreeffeerreenncceess
       If  you  want  to  run your debugged process in a separate
       terminal emulator window, set `PPrrooggrraamm-->>RRuunn  iinn  EExxeeccuuttiioonn
       WWiinnddooww'.   This  is  useful for programs that have special
       terminal requirements not provided by the debugger window,
       as  raw keyboard processing or terminal control sequences.

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

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

       If you wish to display machine code of selected 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,



DDD 3.1                     1998-12-01                         40





ddd(1)                                                     ddd(1)


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

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

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

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

       If  you  want  to be warned about multiple DDD invocations
       sharing the same preferences  and  history  files,  enable
       `WWaarrnn iiff MMuullttiippllee DDDDDD IInnssttaanncceess aarree RRuunnnniinngg'.

       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  _U_n_d_o  _B_u_f_f_e_r is the area where DDD stores old program
       states and commands in order to undo operations.  When you
       are  displaying  lots of data, the undo buffer can quickly
       grow.  In `UUnnddoo BBuuffffeerr SSiizzee', you can limit  the  size  of
       the  undo  buffer.   Setting this limit to 00 disables undo
       altogether.  A negative value means to place no limit.

       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,  set  the
       `AAss  TTeexxtt  CChhaarraacctteerrs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.



DDD 3.1                     1998-12-01                         41





ddd(1)                                                     ddd(1)


       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.

       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
       You  can  control  whether edge hints and edge annotations
       are displayed.  Set or unset the  `SShhooww  EEddggee  HHiinnttss'  and
       `SShhooww EEddggee AAnnnnoottaattiioonnss' option, respectively.

       By  default, DDD disables the title of a dependent display
       if the name can be deduced from edge annotations.  If  you



DDD 3.1                     1998-12-01                         42





ddd(1)                                                     ddd(1)


       want  all  dependent  displays  to have a title, set `SShhooww
       TTiittlleess ooff DDeeppeennddeenntt DDiissppllaayyss'.


       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.

       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.

       By  default,  the  stacked  data  window  is automatically
       closed when you delete the last  data  display.   You  can
       keep  the data window open by unsetting `CClloossee ddaattaa wwiinnddooww
       wwhheenn ddeelleettiinngg llaasstt ddiissppllaayy'.

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

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

   SSttaarrttuupp PPrreeffeerreenncceess
       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



DDD 3.1                     1998-12-01                         43





ddd(1)                                                     ddd(1)


       restarting, you  still  must  save  options  to  make  the
       changes permanent.


       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.

       The CCttrrll++CC key can be bound to different actions, each  in
       accordance with a specific style guide.

       CCooppyy   This setting binds CCttrrll++CC to the Copy operation, as
              specified by the KDE style guide.  In this setting,
              use EESSCC to interrupt the debuggee.

       IInntteerrrruupptt
              This  (default)  setting binds CCttrrll++CC to the Inter-
              rupt operation, as used in  several  UNIX  command-
              line  programs.   In  this setting, use CCttrrll++IInnss to
              copy text to the clipboard.

       The CCttrrll++AA key can be bound to different actions, too.

       SSeelleecctt AAllll
              This (default) setting binds CCttrrll++AA to  the  Select
              All operation, as specified by the KDE style guide.
              In this setting, use HHOOMMEE tp move the cursor to the
              beginning of a line.

       BBeeggiinnnniinngg ooff LLiinnee
              This  setting binds CCttrrll++AA to the Beginning of Line
              operation, as used  in  several  UNIX  text-editing
              programs.   In  this  setting,  use CCttrrll++SShhiifftt++AA to
              select all text.

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

       IImmaaggeess This lets each tool bar 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 you choose to have neither images  nor  captions,  tool
       bar buttons are labeled like other buttons, as in DDD 2.x.



DDD 3.1                     1998-12-01                         44





ddd(1)                                                     ddd(1)


       Note that this implies that in the stacked window configu-
       ration,  the  common  tool  bar cannot be displayed; it is
       replaced by two separate tool bars, as in DDD 2.x.

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

       If  you  enable  `CCoolloorr'  buttons, tool bar images will be
       colored when entered.  If DDD was built  using  Motif  2.0
       and later, you can also choose a third setting, where but-
       tons appear in color all the time.

       By default, the DDD tool bars are located on  top  of  the
       window.   If  you prefer the tool bar being located at the
       bottom, as in DDD 2.x and  earlier,  enable  the  `BBoottttoomm'
       toggle.  The bottom setting is only supported for separate
       tool bars--that is, you must either choose  separate  win-
       dows  or configure the tool bar to have neither images nor
       captions.

       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 determines the inferior debugger automati-
       cally.  To change this default, unset `DDeetteerrmmiinnee AAuuttoommaattii--
       ccaallllyy'  and  set  the `DDeebbuuggggeerr TTyyppee' option to a specific
       debugger.   See  also  the  `----ggddbb',   `----ddbbxx',   `----xxddbb',
       `----jjddbb', `----ppyyddbb', and `----ppeerrll' 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.




DDD 3.1                     1998-12-01                         45





ddd(1)                                                     ddd(1)


   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
       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 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 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 is `lluucciiddaattyyppee--
              wwrriitteerr--mmeeddiiuumm'.

       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.





DDD 3.1                     1998-12-01                         46





ddd(1)                                                     ddd(1)


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

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

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

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

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

       `PPlloott'  is  the  name of a Gnuplot program to invoke.  DDD
       can run Gnuplot in two ways:

       +o DDD can use an EExxtteerrnnaall PPlloott WWiinnddooww, i.e. the plot  win-
         dow  as supplied by Gnuplot.  DDD "swallows" the Gnuplot
         output window into its  own  user  interface.   Unfortu-
         nately,  some window managers, notably MWM, have trouble
         with swallowing techniques.

       +o DDD can supply a  BBuuiillttiinn  PPlloott  WWiinnddooww  instead.   This



DDD 3.1                     1998-12-01                         47





ddd(1)                                                     ddd(1)


         works  with all window managers, but plots are less cus-
         tomizable (Gnuplot resources are not understood).

       Pick your choice from the menu.  See  also  the  `pplloottCCoomm--
       mmaanndd' and `pplloottTTeerrmmTTyyppee' resources, 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
       For most inferior debuggers, you can change  its  settings
       using  `EEddiitt-->>SSeettttiinnggss'.   Using  the settings editor, you
       can determine whether C++ names are to be  demangled,  how
       many array elements are to print, and so on.


       The  capabilities  of  the  settings  editor depend on the
       capabilities of your inferior debugger.  Clicking  on  `??'
       gives an an explanation on the specific item; the GDB doc-
       umentation gives more details.

       Use `EEddiitt-->>UUnnddoo' to undo  changes.   Clicking  on  `RReesseett'
       restores the most recently saved settings.

       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



DDD 3.1                     1998-12-01                         48





ddd(1)                                                     ddd(1)


       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.

   DDeeffiinniinngg SSiimmppllee CCoommmmaannddss uussiinngg 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 five 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.




DDD 3.1                     1998-12-01                         49





ddd(1)                                                     ddd(1)


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

   DDeeffiinniinngg AArrgguummeenntt CCoommmmaannddss uussiinngg GGDDBB
       If  you  want  to pass arguments to user-defined commands,
       you can enable the `(())' toggle button in the Command  Edi-
       tor.  Enabling `(())' has two effects:

       +o While recording commands, all references to the argument
         field are taken _s_y_m_b_o_l_i_c_a_l_l_y instead of literally.   The
         argument  field value is frozen to `$$aarrgg00', which is how
         GDB denotes the  argument  of  a  user-defined  command.
         When  GDB  executes the command, it will replace `$$aarrgg00'
         by the current command argument.

       +o When assigning a button to the command, the command will
         be  suffixed  by  the  current  contents of the argument
         field.

       While defining a command, you can toggle the  `(())'  button
       as  you  wish  to  switch between using the argument field
       symbolically and literally.

       As an example, let us define a  command  `ccoonnttuunnttiill'  that
       will  set  a breakpoint in the given argument and continue
       execution.

       +o Enter `ccoonnttuunnttiill' in the `DDeeffiinniittiioonn' field.

       +o Enable the `(())' toggle button.



DDD 3.1                     1998-12-01                         50





ddd(1)                                                     ddd(1)


       +o Now click on `RReeccoorrdd' to start recording.  Note that the
         contents of the argument field change to `$$aarrgg00'.

       +o Click  on  `BBrreeaakk  aatt  (())' to create a breakpoint.  Note
         that the recorded breakpoint command refers to  `$$aarrgg00'.

       +o Click on `CCoonntt' to continue execution.

       +o Click on `EEnndd' to end recording.  Note that the argument
         field is restored to its original value.

       +o Finally, click on one of the `BBuuttttoonn'  locations.   This
         creates  a  `CCoonnttuunnttiill  (())'  button  where  `(())' will be
         replaced by the current contents of the argument field--
         and thus passed to the `ccoonnttuunnttiill' command.

       +o You  can  now  either  use  the `CCoonnttuunnttiill (())' button or
         enter a `ccoonnttuunnttiill' command at the GDB prompt.  (If  you
         plan  to  use  the  command  frequently, you may wish to
         define a `ccuu' command,  which  again  calls  `ccoonnttuunnttiill'
         with its argument.  This is a nice exercise.)

       There is a little drawback with argument commands: a user-
       defined command in GDB has no means to access the argument
       list  as  a  whole; only the first argument (up to whites-
       pace)  is  processed.   This  may  change  in  future  GDB
       releases.

   DDeeffiinniinngg CCoommmmaannddss uussiinngg OOtthheerr DDeebbuuggggeerrss
       If your inferior 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::




DDD 3.1                     1998-12-01                         51





ddd(1)                                                     ddd(1)


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



DDD 3.1                     1998-12-01                         52





ddd(1)                                                     ddd(1)


       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.

       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



DDD 3.1                     1998-12-01                         53





ddd(1)                                                     ddd(1)


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

       Opening  sessions  also restores command definitions, but-
       tons, display shortcuts and the source  tab  width.   This
       way,  you  can maintain a different set of definitions for
       each session.

   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




DDD 3.1                     1998-12-01                         54





ddd(1)                                                     ddd(1)


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



DDD 3.1                     1998-12-01                         55





ddd(1)                                                     ddd(1)


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




DDD 3.1                     1998-12-01                         56





ddd(1)                                                     ddd(1)


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

       +o Your DDD binary was compiled against LessTif  0.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.

       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



DDD 3.1                     1998-12-01                         57





ddd(1)                                                     ddd(1)


         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.

       +o See also the `rrsshhCCoommmmaanndd' resource, below.

   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.




DDD 3.1                     1998-12-01                         58





ddd(1)                                                     ddd(1)


       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:

       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.




DDD 3.1                     1998-12-01                         59





ddd(1)                                                     ddd(1)


       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.

       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



DDD 3.1                     1998-12-01                         60





ddd(1)                                                     ddd(1)


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

   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.



DDD 3.1                     1998-12-01                         61





ddd(1)                                                     ddd(1)


       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chheecckkOOppttiioonnss ((class CChheecckkOOppttiioonnss))
              Every _N seconds, where  _N  is  the  value  of  this
              resource,  DDD  checks whether the options file has
              changed.  Default is 3300, which means that every  30
              seconds,  DDD checks for the options file.  Setting
              this resource to 00 disables  checking  for  changed
              option files.

       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.

       ffiilltteerrFFiilleess ((class FFiilltteerrFFiilleess))
              If this is `oonn' (default), DDD filters  files  when
              opening  execution  files,  core  dumps,  or source
              files, such that the selection shows only  suitable
              files.   This  requires  that  DDD opens each file,
              which may take time.  If this is `ooffff', DDD  always
              presents all available files.

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



DDD 3.1                     1998-12-01                         62





ddd(1)                                                     ddd(1)


              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seelleeccttAAllllB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 the select all opera-
              tion.

              +o If this is `MMoottiiff', Select All on SShhiifftt++CCttrrll++AA.

              +o If  this  is  `KKDDEE'  (default),  Select All is on
                CCttrrll++AA.  This is  conformant  to  the  KDE  style
                guide.   Note  that  this  means  that  CCttrrll++AA no
                longer moves the cursor to  the  beginning  of  a
                line; use the HHOOMMEE key instead.

       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.



DDD 3.1                     1998-12-01                         63





ddd(1)                                                     ddd(1)


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

       mmaaxxUUnnddooDDeepptthh ((class MMaaxxUUnnddooDDeepptthh))
              The  maximum  number of entries in the undo buffer.
              This limits the  number  of  actions  that  can  be
              undone,  and the number of states that can be shown
              in historic mode.  Useful for limiting  DDD  memory
              usage.   A  negative value (default) means to place
              no limit.

       mmaaxxUUnnddooSSiizzee ((class MMaaxxUUnnddooSSiizzee))
              The maximum memory usage (in  bytes)  of  the  undo
              buffer.   Useful  for limiting DDD memory usage.  A
              negative value means to place no limit.  Default is
              22000000000000.

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

       wwaarrnnIIffLLoocckkeedd ((class WWaarrnnIIffLLoocckkeedd))
              Whether to warn if multiple DDD instances are  run-
              ning (`oonn') or not (`ooffff', default).

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



DDD 3.1                     1998-12-01                         64





ddd(1)                                                     ddd(1)


       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.

       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.





DDD 3.1                     1998-12-01                         65





ddd(1)                                                     ddd(1)


       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.

       iinnddeennttSSccrriipptt ((class IInnddeenntt))
              The minimum indentation for script languages,  such
              as Perl and Python.  Default: 44.

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

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

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

       mmaaxxDDiissaasssseemmbbllee ((class MMaaxxDDiissaasssseemmbbllee))
              Maximum number of bytes  to  disassemble  (default:
              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.



DDD 3.1                     1998-12-01                         66





ddd(1)                                                     ddd(1)


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

       aauuttooRRaaiisseeTTooooll ((class AAuuttooRRaaiisseeTTooooll))
              If `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.

       ddeeccoorraatteeTTooooll ((class DDeeccoorraattee))
              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



DDD 3.1                     1998-12-01                         67





ddd(1)                                                     ddd(1)


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




DDD 3.1                     1998-12-01                         68





ddd(1)                                                     ddd(1)


       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.

       aauuttooDDeebbuuggggeerr ((class AAuuttooDDeebbuuggggeerr))
              If this is `oonn'  (default),  DDD  will  attempt  to
              determine  the  debugger  type  from its arguments,
              possibly overriding the  `ddeebbuuggggeerr'  resource  (see
              below).   If  this  is  `ooffff',  DDD will invoke the
              debugger  specified  by  the  `ddeebbuuggggeerr'   resource
              regardless of DDD arguments.

       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.



DDD 3.1                     1998-12-01                         69





ddd(1)                                                     ddd(1)


       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 to invoke (`ggddbb',
              `ddbbxx', `xxddbb',  `jjddbb',  `ppyyddbb',  or  `ppeerrll').   This
              resource   is  usually  set  through  the  `----ggddbb',
              `----ddbbxx', `----xxddbb', `----jjddbb', `----ppyyddbb', and  `----ppeerrll',
              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 `ddeebbuuggggeerr--
              HHoosstt', using this  resource  causes  DDD  to  login
              interactively  to  the  remote  host and invoke the
              inferior debugger from the remote shell.  See  also
              the  `----rrhhoosstt'  option,  below,  and `RREEMMOOTTEE DDEEBBUUGG--
              GGIINNGG', above.

       ffuullllNNaammeeMMooddee ((class TTTTYYMMooddee))
              If this is `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



DDD 3.1                     1998-12-01                         70





ddd(1)                                                     ddd(1)


              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.

       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.

       ooppeennSSeelleeccttiioonn ((class OOppeennSSeelleeccttiioonn))
              If  this  is  `oonn',  DDD  invoked  without argument
              checks whether the current selection  or  clipboard
              contains the file name or URL of an executable pro-
              gram.  If this is so, DDD will  automatically  open
              this  program  for  debugging.  If this resource is
              `ooffff' (default), DDD invoked without arguments will
              always start without a debugged program.

       ppeerrllI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



DDD 3.1                     1998-12-01                         71





ddd(1)                                                     ddd(1)


              commands that are initially sent to the Perl debug-
              ger.  By default, it is empty.

              This  resource  may  be  used to customize the Perl
              debugger.

       ppyyd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 the Perl
              debugger.  By default, it is empty.

              This resource is used by DDD to  save  and  restore
              Perl debugger settings.

       ppyyd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  PYDB.   By
              default, it is empty.
              This resource may be used to customize PYDB.

       ppyyd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 PYDB.   By
              default, it is empty.

              This  resource  is  used by DDD to save and restore
              PYDB 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.





DDD 3.1                     1998-12-01                         72





ddd(1)                                                     ddd(1)


       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.

       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.

       aaccttiivveeB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 the images  of  active
              buttons  (entered  or armed).  `cc' means color, `gg'
              (default) means grey, and `mm' means monochrome.




DDD 3.1                     1998-12-01                         73





ddd(1)                                                     ddd(1)


       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 the images of inactive
              buttons  (non-entered  or  insensitive).  `cc' means
              color, `gg' (default)  means  grey,  and  `mm'  means
              monochrome.

       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



DDD 3.1                     1998-12-01                         74





ddd(1)                                                     ddd(1)


                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.

              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:



DDD 3.1                     1998-12-01                         75





ddd(1)                                                     ddd(1)


                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
              icon.  If `ooffff', the 3-D border is  shown  all  the
              time.

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

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

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

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

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




DDD 3.1                     1998-12-01                         76





ddd(1)                                                     ddd(1)


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

                DDdddd**ssoouurrcceeBBuuttttoonnss:: \\
                pprriinntt **(())\\nnggrraapphh ddiissppllaayy **(())\\nnpprriinntt //xx (())\\nn\\
                wwhhaattiiss (())\\nnppttyyppee (())\\nnwwaattcchh (())\\nnuunnttiill\\nnsshheellll

              An even more professional setting  uses  customized
              button labels.

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

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

       ttoooollbbaar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').  See also
              the `----ttoooollbbaarrss--aatt--bboottttoomm' and  `----ttoooollbbaarrss--aatt--ttoopp'
              options, below.

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




DDD 3.1                     1998-12-01                         77





ddd(1)                                                     ddd(1)


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

   UUsseerr--DDeeffiinneedd NNeeww DDiissppllaayy MMeennuu
       The following resources control the user-defined `NNeeww DDiiss--
       ppllaayy' menu.

       ddbbxxD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 for DBX.   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.

       ggddbbD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 for GDB.  See
              the description of `ddbbxxDDiissppllaayySShhoorrttccuuttss', above.

       jjddbbD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 for JDB.  See
              the description of `ddbbxxDDiissppllaayySShhoorrttccuuttss', above.

       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peerrllD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  for  Perl.
              See   the   description  of  `ddbbxxDDiissppllaayySShhoorrttccuuttss',
              above.





DDD 3.1                     1998-12-01                         78





ddd(1)                                                     ddd(1)


       ppyyddbbD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 for PYDB.
              See  the  description   of   `ddbbxxDDiissppllaayySShhoorrttccuuttss',
              above.

       xxddbbD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 for XDB.  See
              the description of `ddbbxxDDiissppllaayySShhoorrttccuuttss', above.

   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.

       aauuttooCClloosseeDDaattaaWWiinnddooww ((class AAuuttooCClloossee))
              If  this  is  `oonn'  (default) and DDD is in stacked
              window mode, deleting the  last  display  automati-
              cally  closes  the  data window.  If this is `ooffff',
              the data window stays open even after deleting  the
              last display.

       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.

       cclluusstteerrDDiissppllaayyss ((class CClluusstteerrDDiissppllaayyss))
              If  `oonn',  new independent data displays will auto-
              matically be clustered.  Default is `ooffff',  meaning
              to leave new displays unclustered.

       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 (())' but-
              ton also deletes all aliases of the  selected  dis-
              plays.   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.




DDD 3.1                     1998-12-01                         79





ddd(1)                                                     ddd(1)


       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.

       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.

       ppaappeerrSSiizzee ((class PPaappeerrSSiizzee))
              The paper size used for printing, in format _w_i_d_t_h x
              _h_e_i_g_h_t.   The  default  is  A4  format, or `221100mmmm xx
              229977mmmm'.

       sshhoowwBBaasseeDDiissppllaayyTTiittlleess ((class SShhoowwDDiissppllaayyTTiittlleess))
              Whether to assign titles to base (independent) dis-
              plays or not.  Default is `oonn'.

       sshhoowwDDeeppeennddeennttDDiissppllaayyTTiittlleess ((class SShhoowwDDiissppllaayyTTiittlleess))
              Whether  to  assign titles to dependent displays or
              not.  Default is `ooffff'.

       ttyyppeeddAAlliiaasseess ((class TTyyppeeddAAlliiaasseess))
              If `oonn' (default), DDD requires structural  equiva-
              lence in order to recognize shared data structures.
              If this is `ooffff', two displays at the same  address
              are  considered aliases, regardless of their struc-
              ture.

       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



DDD 3.1                     1998-12-01                         80





ddd(1)                                                     ddd(1)


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

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





DDD 3.1                     1998-12-01                         81





ddd(1)                                                     ddd(1)


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





DDD 3.1                     1998-12-01                         82





ddd(1)                                                     ddd(1)


       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.

   PPlloott WWiinnddooww
       The following resources control the plot window.

       pplloottTTeerrmmTTyyppee ((class PPlloottTTeerrmmTTyyppee))
              The Gnuplot terminal type.  Can  have  one  of  two
              values:

       +o If this is `xx1111', DDD "swallows" the Gnuplot output win-
         dow into its own user interface.  Some window  managers,
         notably MWM, have trouble with swallowing techniques.

       +o Setting this resource to `xxlliibb' (default) makes DDD pro-
         vide a _b_u_i_l_t_i_n _p_l_o_t _w_i_n_d_o_w instead.  In this mode, plots
         work  well  with  any  window manager, but are less cus-
         tomizable (Gnuplot resources are not understood).

       pplloottCCoommmmaanndd ((class PPlloottCCoommmmaanndd))
         The name of a Gnuplot executable.  Default is `ggnnuupplloott',
         followed  by  some options to set up colors and the ini-
         tial geometry.

       pplloottWWiinnddoowwCCllaassss ((class PPlloottWWiinnddoowwCCllaassss))
         The class of the Gnuplot output window.   When  invoking
         Gnuplot,  DDD  waits  for  a  window with this class and
         incorporates it into  its  own  user  interface  (unless
         `pplloottTTeerrmmTTyyppee'  is `xxlliibb'; see above).  Default is `GGnnuu--
         pplloott'.

       pplloottWWiinnddoowwDDeellaayy ((class WWiinnddoowwDDeellaayy))
         The time (in ms) to wait for the creation of the Gnuplot
         window.   Before  this  delay,  DDD  looks at each newly



DDD 3.1                     1998-12-01                         83





ddd(1)                                                     ddd(1)


         created window to see whether this is the plot window to
         swallow.   This is cheap, but unfortunately, some window
         managers do not pass the creation event to DDD.  If this
         delay has passed, and DDD has not found the plot window,
         DDD searches  _a_l_l  existing  windows,  which  is  pretty
         expensive.  Default time is 22000000.

       pplloottIInniittCCoommmmaannddss ((class PPlloottIInniittCCoommmmaannddss))
         The initial Gnuplot commands issued by DDD.  Default is:

           sseett ppaarraammeettrriicc
           sseett uurraannggee [[00::11]]
           sseett vvrraannggee [[00::11]]
           sseett ttrraannggee [[00::11]]

         The `ppaarraammeettrriicc' setting is  required  to  make  Gnuplot
         understand  the  data files as generated DDD.  The range
         commands are used to plot scalars.

       pplloott22ddSSeettttiinnggss ((class PPlloottSSeettttiinnggss))
         Additional initial settings for 2-D plots.   Default  is
         `sseett  nnoobboorrddeerr'.   Feel free to customize these settings
         as desired.

       pplloott33ddSSeettttiinnggss ((class PPlloottSSeettttiinnggss))
         Additional initial settings for 3-D plots.   Default  is
         `sseett  bboorrddeerr'.  Feel free to customize these settings as
         desired.


   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.


   VVaalluuee HHiissttoorriieess
       The  following resources control the pop-down value histo-
       ries associated with various text fields.

       ppooppddoowwnnHHiissttoorryySSiizzee ((class HHiissttoorryySSiizzee))
              The maximum number of items to display in  pop-down
              value  histories.   A value of 00 (default) means an
              unlimited number of values.

       ssoorrttPPooppddoowwnnHHiissttoorryy ((class SSoorrttPPooppddoowwnnHHiissttoorryy))
              If `oonn' (default), items in the pop-down value his-
              tories  are  sorted alphabetically.  If `ooffff', most



DDD 3.1                     1998-12-01                         84





ddd(1)                                                     ddd(1)


              recently used values will appear at the top.


   CCuussttoommiizziinngg HHeellppeerrss
       The  following  resources  determine   external   programs
       invoked by DDD.

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

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

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

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

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

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


       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



DDD 3.1                     1998-12-01                         85





ddd(1)                                                     ddd(1)


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

       lliissttCCoorreeCCoommmmaanndd ((class lliissttCCoorreeCCoommmmaanndd))
              The  command  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  command  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  command  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  command 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






DDD 3.1                     1998-12-01                         86





ddd(1)                                                     ddd(1)


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

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

       rrsshhCCoommmmaanndd ((class RRsshhCCoommmmaanndd))
              The  remote  shell command to invoke TTY-based com-
              mands on remote hosts.   Usually,  `rreemmsshh',  `rrsshh',
              `sss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

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

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

       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:



DDD 3.1                     1998-12-01                         87





ddd(1)                                                     ddd(1)


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

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

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

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


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

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

       cchheecckkCCoonnffiigguurraattiioonn ((class CChheecckkCCoonnffiigguurraattiioonn))
              If  `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.

       ddeebbuuggCCoorreeDDuummppss ((class DDeebbuuggCCoorreeDDuummppss))
              If  `oonn',  DDD  invokes  a  debugger on itself when
              receiving a fatal signal.

       dduummppCCoorree ((class DDuummppCCoorree))
              If `oonn' (default), DDD dumps core when receiving  a
              fatal signal.

       mmaaiinntteennaannccee ((class MMaaiinntteennaannccee))
              If  `oonn',  enables  a  top-level `MMaaiinntteennaannccee' menu
              with additional options.  See also  the  `----mmaaiinnttee--
              nnaannccee' option, below.

       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.





DDD 3.1                     1998-12-01                         88





ddd(1)                                                     ddd(1)


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



DDD 3.1                     1998-12-01                         89





ddd(1)                                                     ddd(1)


              console, creating one single big DDD window.   This
              is the default setting.

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

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

       ----aauuttoommaattiicc--ddeebbuuggggeerr
              Determine the inferior debugger automatically.

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

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

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

       ----d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',  `jjddbb',  `ppyyddbb',  or  `ppeerrll'  respec-
              tively.
              This option can also be used to pass options to the
              inferior debugger  that  would  otherwise  conflict
              with DDD options.  For instance, to pass the option
              `--dd _d_i_r_e_c_t_o_r_y' 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',  `----jjddbb' `----ppyyddbb', or `----ppeerrll' (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--



DDD 3.1                     1998-12-01                         90





ddd(1)                                                     ddd(1)


              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
              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 999999'.  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.




DDD 3.1                     1998-12-01                         91





ddd(1)                                                     ddd(1)


       ----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aiinntteennaannccee
              Enable   the   top-level  `MMaaiinntteennaannccee'  menu  with
              options for debugging DDD.

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

       ----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peerrll Run Perl as inferior debugger.

       ----ppyyddbb Run PYDB as inferior debugger.

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



DDD 3.1                     1998-12-01                         92





ddd(1)                                                     ddd(1)


              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.

       ----ppllaayy _l_o_g_-_f_i_l_e
              Recapitulate  a  previous DDD session.  Invoke `ddd
              ----PPLLAAYY _l_o_g_-_f_i_l_e' as inferior  debugger,  simulating
              the   inferior  debugger  given  in  _l_o_g_-_f_i_l_e  (see
              below).  This is useful for debugging DDD.

       ----PPLLAAYY _l_o_g_-_f_i_l_e
              Simulate  an  inferior  debugger.   _l_o_g_-_f_i_l_e  is  a
              `$$HHOOMMEE//..dddddd//lloogg' file as generated by some previous
              DDD session.  When a command is entered,  scan  the
              _l_o_g_-_f_i_l_e  for  this command and re-issue the logged
              reply; if the command is  not  found,  do  nothing.
              This is used by the `----ppllaayy' option.

       ----rrhhoosstt [_u_s_e_r_n_a_m_e@@]_h_o_s_t_n_a_m_e
              Run  the  inferior  debugger  interactively  on the
              remote host _h_o_s_t_n_a_m_e.  If _u_s_e_r_n_a_m_e is given and the
              `----llooggiinn'  option  is  not  used,  use  _u_s_e_r_n_a_m_e as
              remote user name.  See `RREEMMOOTTEE DDEEBBUUGGGGIINNGG', above.

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

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

       ----s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toooollbbaarrss--aatt--bboottttoomm
              Place the toolbars the bottom of the window.




DDD 3.1                     1998-12-01                         93





ddd(1)                                                     ddd(1)


       ----ttoooollbbaarrss--aatt--ttoopp
              Place the toolbars at the top of the window.

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





DDD 3.1                     1998-12-01                         94





ddd(1)                                                     ddd(1)


       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.

       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



DDD 3.1                     1998-12-01                         95





ddd(1)                                                     ddd(1)


              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.

       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.





DDD 3.1                     1998-12-01                         96





ddd(1)                                                     ddd(1)


       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.

   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.




DDD 3.1                     1998-12-01                         97





ddd(1)                                                     ddd(1)


       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.

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



DDD 3.1                     1998-12-01                         98





ddd(1)                                                     ddd(1)


       ggddbb--iisseeaarrcchh--pprreevv (())
              Enter  reverse  incremental  search mode.  Bound to
              CCttrrll++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elleecctt--aallll (())
              If  the  `sseelleeccttAAllllBBiinnddiinnggss'  resource  is  set  to
              MMoottiiff, perform _b_e_g_i_n_n_i_n_g_-_o_f_-_l_i_n_e.  Otherwise,  per-
              form _s_e_l_e_c_t_-_a_l_l.  Bound to CCttrrll++AA.

       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
              [,_f_u_n_c_t_i_o_n_- _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.

              +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 If  this  action is taken in the source text, and



DDD 3.1                     1998-12-01                         99





ddd(1)                                                     ddd(1)


                the next character following the  current  selec-
                tion  is  a  `((',  invoke  `ggddbb--ccoommmmaanndd((_f_u_n_c_t_i_o_n_-
                _a_c_t_i_o_n))'.  If _f_u_n_c_t_i_o_n_-_a_c_t_i_o_n is  not  given,  it
                defaults to `lliisstt (())'.

              +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seett--aarrgg (())
              Set  the  argument  field to the current selection.
              Typically bound to some selection operation.

       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 images that may be used as pixmap
       resources, simply by giving a symbolic name.   For  button
       images, three variants are installed as well:

       +o The suffix `--hhii' indicates a highlighted variant (Button
         is entered).

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

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





DDD 3.1                     1998-12-01                        100





ddd(1)                                                     ddd(1)


       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.

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




DDD 3.1                     1998-12-01                        101





ddd(1)                                                     ddd(1)


       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.

       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.




DDD 3.1                     1998-12-01                        102





ddd(1)                                                     ddd(1)


       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
                           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 environment variables are set by DDD:


       DDDDDD                 Set  to  a  string  indicating the DDD
                           version.  By testing  whether  DDDDDD  is
                           set, a debuggee (or inferior debugger)
                           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).



DDD 3.1                     1998-12-01                        103





ddd(1)                                                     ddd(1)


       TTEERRMMCCAAPP             Set  to  `'  (none),  the DDD terminal
                           capabilities.

       PPAAGGEERR               Set to `ccaatt', the preferred DDD pager.

FFIILLEESS
       $$HHOOMMEE//..dddddd//         DDD state directory.
       $$HHOOMMEE//..dddddd//iinniitt     Individual  DDD  resource  file.   DDD
                           options are saved here.
       $$HHOOMMEE//..dddddd//hhiissttoorryy  Default DDD command history file.
       $$HHOOMMEE//..dddddd//lloocckk     DDD lock file; indicates that a DDD is
                           running.
       $$HHOOMMEE//..dddddd//lloogg      Trace   of   the  current  interaction
                           between DDD and the inferior debugger.
       $$HHOOMMEE//..dddddd//sseessssiioonnss//
                           DDD  session directory.  One subdirec-
                           tory per session.
       $$HHOOMMEE//..dddddd//sseessssiioonnss//_s_e_s_s_i_o_n//ddddddccoorree
                           DDD core file for _s_e_s_s_i_o_n.
       $$HHOOMMEE//..dddddd//sseessssiioonnss//_s_e_s_s_i_o_n//iinniitt
                           DDD resource file for _s_e_s_s_i_o_n.
       $$HHOOMMEE//..dddddd//sseessssiioonnss//_s_e_s_s_i_o_n//hhiissttoorryy
                           DDD command history for _s_e_s_s_i_o_n.
       $$HHOOMMEE//..dddddd//sseessssiioonnss//..dddddd//
                           The DDD `restart' session.
       $$HHOOMMEE//..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//..ggnnuupplloott      Gnuplot 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),  ppeerrllddeebbuugg(1),  rreemmsshh(1),
       rrsshh(1), ggnnuupplloott(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d--
       u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//

       _T_h_e _P_y_t_h_o_n _L_a_n_g_u_a_g_e,  at  hhttttpp::////wwwwww..ppyytthhoonn..oorrgg//  and  its
       mirrors.



DDD 3.1                     1998-12-01                        104





ddd(1)                                                     ddd(1)


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

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

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

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


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

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


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

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

       For more information on this list, send a mail to

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



LLIIMMIITTAATTIIOONNSS
   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



DDD 3.1                     1998-12-01                        105





ddd(1)                                                     ddd(1)


       initialization file, DDD will likely become confused.  The
       same applies to debugged programs which change the default
       TTY settings.

   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



DDD 3.1                     1998-12-01                        106





ddd(1)                                                     ddd(1)


       values.   This  means  that variable names are interpreted
       according to the current frame; variables outside the cur-
       rent frame cannot be displayed.

       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.

   LLiimmiittaattiioonnss uussiinngg PPeerrll
       There  is  no  automatic  data  display  in  Perl.   As  a
       workaround, DDD uses the `xx' 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.

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

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

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

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

         Technische Universitt Braunschweig
         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



DDD 3.1                     1998-12-01                        107





ddd(1)                                                     ddd(1)


       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 the
       file `$$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
         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



DDD 3.1                     1998-12-01                        108





ddd(1)                                                     ddd(1)


         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 the file `$$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
       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.



DDD 3.1                     1998-12-01                        109





ddd(1)                                                     ddd(1)


       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.
       December, 1998      DDD  3.1: Data plotting, Perl support,
                           Python support, Undo/Redo.

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
         Abteilung Softwaretechnologie
         Bltenweg 88
         D-38092 Braunschweig
         GERMANY

       You  may  also leave a message in the _D_D_D _G_u_e_s_t_b_o_o_k. It is
       accessible via the 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



DDD 3.1                     1998-12-01                        110





ddd(1)                                                     ddd(1)


       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
   DDDDDD
       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'.


   DDDDDD MMaannuuaall
       This  DDD  manual  is Copyright (C) 1995, 1996, 1997, 1998
       Technische Universitt Braunschweig, Germany.

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

       Permission is granted to copy and distribute modified ver-
       sions  of  this  manual  under the conditions for verbatim
       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 into another language, under the above con-
       ditions for modified versions, except that this permission
       notice  may  be  included  in translations approved by the
       Free  Software  Foundation  instead  of  in  the  original
       English.







DDD 3.1                     1998-12-01                        111


