


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.2                   1998-12-18                          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.2                   1998-12-18                          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.2                   1998-12-18                          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.2                   1998-12-18                          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.2                   1998-12-18                          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.2                   1998-12-18                          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.2                   1998-12-18                          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.2                   1998-12-18                          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.2                   1998-12-18                          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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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'.

       The  execution  window  is opened automatically as soon as
       you start the debugged program.  While the execution  win-
       dow  is  active, DDD redirects the standard input, output,
       and error streams of your program to the execution window.
       Note that the device `//ddeevv//ttttyy' still refers to the debug-
       ger console, _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.

   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



DDD 3.1.2                   1998-12-18                         13





ddd(1)                                                     ddd(1)


       PPrrooggrraamm' to specify the program running in the process and
       load its symbol table.

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


       You  can customize the list of processes shown by defining
       an   alternate   command   to   list    processes.     See
       `EEddiitt-->>PPrreeffeerreenncceess-->>HHeellppeerrss-->>LLiisstt PPrroocceesssseess'.

       Note:  JDB,  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



DDD 3.1.2                   1998-12-18                         14





ddd(1)                                                     ddd(1)


       _b_u_t_t_o_n _1 on the arrow and drag it to a different location.
       The  most  common  occasion to use this feature is to back
       up--perhaps with more breakpoints set-over a portion of  a
       program that has already executed, in order to examine its
       execution in more detail.

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

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

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


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

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

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

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


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

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

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

       `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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.2                   1998-12-18                         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.

       ddiissppllaayyTTiimmeeoouutt ((class DDiissppllaayyTTiimmeeoouutt))
              The  time (in ms) to wait for the inferior debugger
              to finish a partial display  information.   Default
              is 22000000.

       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.





DDD 3.1.2                   1998-12-18                         70





ddd(1)                                                     ddd(1)


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

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

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

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

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

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

       jjddbbIInniittCCoommmmaannddss ((class IInniittCCoommmmaannddss))
              This string contains a  list  of  newline-separated
              commands  that  are  initially  sent  to JDB.  This
              resource may be used to customize JDB.  By default,
              it is empty.

       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



DDD 3.1.2                   1998-12-18                         71





ddd(1)                                                     ddd(1)


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

       ppoossiittiioonnTTiimmeeoouutt ((class PPoossiittiioonnTTiimmeeoouutt))
              The  time (in ms) to wait for the inferior debugger
              to finish a partial position information.   Default
              is 550000.

       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.



DDD 3.1.2                   1998-12-18                         72





ddd(1)                                                     ddd(1)


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

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

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

       ttttyyMMooddee ((class TTTTYYMMooddee))
              If  `oonn',  enable  TTY interface, taking additional
              debugger commands from standard input and  forward-
              ing  debugger output on standard output.  As a side
              effect,  the  debugger  console  is   disabled   by
              default.   See  also  the  `----ttttyy' and `----ffuullllnnaammee'
              options, below.

       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.





DDD 3.1.2                   1998-12-18                         73





ddd(1)                                                     ddd(1)


   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.

       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



DDD 3.1.2                   1998-12-18                         74





ddd(1)                                                     ddd(1)


              command given by its name.

              The following characters have special meanings:

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

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

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

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

              The following button names are reserved:

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

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

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

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

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

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

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

              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



DDD 3.1.2                   1998-12-18                         75





ddd(1)                                                     ddd(1)


              buttons are created.

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

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

              This setting creates some more buttons:

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

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


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

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

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

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



DDD 3.1.2                   1998-12-18                         76





ddd(1)                                                     ddd(1)


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

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

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

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

              An  even  more professional setting uses customized
              button labels.

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

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

       ttoooollbbaarrssAAttBBoottttoomm ((class TToooollbbaarrssAAttBBoottttoomm))
              Whether source and data tool bars should be  placed
              above   source   and   data,  respectively  (`ooffff',
              default), or below, as in DDD 2.x (`oonn').  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



DDD 3.1.2                   1998-12-18                         77





ddd(1)                                                     ddd(1)


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

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

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

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

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

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



DDD 3.1.2                   1998-12-18                         78





ddd(1)                                                     ddd(1)


       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.

       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.





DDD 3.1.2                   1998-12-18                         79





ddd(1)                                                     ddd(1)


       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.

       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



DDD 3.1.2                   1998-12-18                         80





ddd(1)                                                     ddd(1)


              appended to the builtin VSL library.  This resource
              is  prepended  to  the `vvssllDDeeffss' resource below and
              set in the DDD  application  defaults  file;  don't
              change it.

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

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

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

              The following VSL functions are frequently used:

              ccoolloorr((_b_o_x,, _f_o_r_e_g_r_o_u_n_d [[,, _b_a_c_k_g_r_o_u_n_d]]))
                        Set the _f_o_r_e_g_r_o_u_n_d and _b_a_c_k_g_r_o_u_n_d  colors
                        of _b_o_x.

              ddiissppllaayy__ccoolloorr((_b_o_x))
                        The   color   used   in   data  displays.
                        Default: ccoolloorr((_b_o_x,, ""bbllaacckk"",, ""wwhhiittee""))

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

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

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

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

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

              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:



DDD 3.1.2                   1998-12-18                         81





ddd(1)                                                     ddd(1)


                        ccoolloorr((_b_o_x,, ""bblluuee44""))

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

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

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

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

              ssttddffoonnttwweeiigghhtt(())
                        The    font    weight    used.     Either
                        wweeiigghhtt__mmeeddiiuumm(())       (default)        or
                        wweeiigghhtt__bboolldd(()).

              To set the pointer color to "red4", use

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

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

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

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

                DDdddd**vvssllDDeeffss:: \\
                ##pprraaggmmaa rreeppllaaccee ssttddffoonnttssiizzee\\nn\\
                ##pprraaggmmaa rreeppllaaccee ssttddffoonnttffaammiillyy\\nn\\
                ssttddffoonnttssiizzee(()) == 1122;;\\nn\\
                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.





DDD 3.1.2                   1998-12-18                         82





ddd(1)                                                     ddd(1)


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

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

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

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

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

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

   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



DDD 3.1.2                   1998-12-18                         83





ddd(1)                                                     ddd(1)


         `GGnnuup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 cre-
         ated  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



DDD 3.1.2                   1998-12-18                         84





ddd(1)                                                     ddd(1)


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



DDD 3.1.2                   1998-12-18                         85





ddd(1)                                                     ddd(1)


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

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



DDD 3.1.2                   1998-12-18                         86





ddd(1)                                                     ddd(1)


                || ccuutt --dd:: --ff11


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

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

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



DDD 3.1.2                   1998-12-18                         87





ddd(1)                                                     ddd(1)


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

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

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

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

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


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

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

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



DDD 3.1.2                   1998-12-18                         88





ddd(1)                                                     ddd(1)


              option, below.

       sshhoowwFFoonnttss ((class SShhoowwFFoonnttss))
              If `oonn', show the DDD font definitions on  standard
              output  and  exit.   See also the `----ffoonnttss' option,
              below.

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

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

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





DDD 3.1.2                   1998-12-18                         89





ddd(1)                                                     ddd(1)


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

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

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

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




DDD 3.1.2                   1998-12-18                         90





ddd(1)                                                     ddd(1)


       ----ddiissaasssseemmbbllee
              Disassemble  the  source code.  See also the `----nnoo--
              ddiissaasssseemmbbllee' option, below.

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

       ----ffoonnttss
              Show the font definitions used by DDD  on  standard
              output.

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

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





DDD 3.1.2                   1998-12-18                         91





ddd(1)                                                     ddd(1)


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

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

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



DDD 3.1.2                   1998-12-18                         92





ddd(1)                                                     ddd(1)


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

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





DDD 3.1.2                   1998-12-18                         93





ddd(1)                                                     ddd(1)


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

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





DDD 3.1.2                   1998-12-18                         94





ddd(1)                                                     ddd(1)


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

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

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

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

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

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

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

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

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

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

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

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

       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



DDD 3.1.2                   1998-12-18                         95





ddd(1)                                                     ddd(1)


              graph operations, nnooddee pops up  a  menu  with  node
              operations,  and  sshhoorrttccuutt pops up a menu with dis-
              play shortcuts.  If no argument is given, pops up a
              menu  depending  on the context: when pointing on a
              node with  the  SShhiifftt  key  pressed,  behaves  like
              sshhoorrttccuutt;  when pointing on a without the SShhiifftt key
              pressed, behaves like nnooddee; otherwise,  behaves  as
              if ggrraapphh was given.

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

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

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

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

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

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

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

       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



DDD 3.1.2                   1998-12-18                         96





ddd(1)                                                     ddd(1)


              selections.  Bound to a button down event.

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

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

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

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

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

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

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

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

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

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

   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,



DDD 3.1.2                   1998-12-18                         97





ddd(1)                                                     ddd(1)


              after the prompt.  Bound to HHOOMMEE.

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

       ggddbb--ccoommmmaanndd ((_c_o_m_m_a_n_d))
              Execute  _c_o_m_m_a_n_d in the debugger console.  The fol-
              lowing replacements are performed on _c_o_m_m_a_n_d:

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

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

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

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

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

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

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

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

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

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





DDD 3.1.2                   1998-12-18                         98





ddd(1)                                                     ddd(1)


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

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

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

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

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

       ggddbb--pprreevv--hhiissttoorryy (())
              Recall previous command from history.  Bound to UUpp.

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

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

       ggddbb--sse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,



DDD 3.1.2                   1998-12-18                         99





ddd(1)                                                     ddd(1)


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




DDD 3.1.2                   1998-12-18                        100





ddd(1)                                                     ddd(1)


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

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




DDD 3.1.2                   1998-12-18                        101





ddd(1)                                                     ddd(1)


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

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

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

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

       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.




DDD 3.1.2                   1998-12-18                        102





ddd(1)                                                     ddd(1)


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

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


EENNVVIIRROONNMMEENNTT
       DDD is controlled by the following environment variables:


       CCLLAASSSSPPAATTHH           A  colon-separated list of directories
                           in which to search for Java classes.

       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.



DDD 3.1.2                   1998-12-18                        103





ddd(1)                                                     ddd(1)


                           This is set for the inferior  debugger
                           only.  If the debuggee runs in a sepa-
                           rate execution window, the  debuggee's
                           TTEERRMM  value  is  set  according to the
                           `tteerrmmTTyyppee' resource (see  `RREESSOOUURRCCEESS',
                           above).

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

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

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



DDD 3.1.2                   1998-12-18                        104





ddd(1)                                                     ddd(1)


       //pprroodduuccttss//jjddkk//11..11//ddooccss//ttoooollddooccss//ssoollaarriiss//jjddbb..hhttmmll

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

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

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



DDD 3.1.2                   1998-12-18                        105





ddd(1)                                                     ddd(1)


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

       If your program outputs any of these strings,  you  should
       run it in the separate execution window.

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

   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



DDD 3.1.2                   1998-12-18                        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.

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

       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





DDD 3.1.2                   1998-12-18                        107





ddd(1)                                                     ddd(1)


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

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

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

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

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

       This  shows  the  interaction between DDD and the inferior
       debugger on standard error  while  DDD  is  running.   (If
       `----ttrraaccee'  is not given, this interaction is logged in 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.






DDD 3.1.2                   1998-12-18                        108





ddd(1)                                                     ddd(1)


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

       +o Your DDD configuration.  Invoke DDD as

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

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

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

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

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

       +o A _l_o_g _f_i_l_e showing the interaction between DDD  and  the
         inferior  debugger.   By  default,  this  interaction is
         logged in 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.



DDD 3.1.2                   1998-12-18                        109





ddd(1)                                                     ddd(1)


       The original DDD had no source window; this was  added  by
       Dorothea  during  the  winter  of 1994-1995.  In the first
       quarter of 1995, finally, Andreas completed DDD by  adding
       command  and  execution  windows,  extensions  for DBX and
       remote debugging as well as configuration support for sev-
       eral architectures.  Since then, Andreas has further main-
       tained and extended DDD, based on the comments and sugges-
       tions of several DDD users around the world.  See the com-
       ments in the DDD source for details.

       Major DDD events:
       April, 1995         DDD 0.9: First DDD beta release.
       May, 1995           DDD 1.0: First public DDD release.
       December, 1995      DDD  1.4:   Machine-level   debugging,
                           glyphs, EMACS integration.
       October, 1996       DDD  2.0: Color displays, XDB support,
                           generic DBX support, command tool.
       May, 1997           DDD 2.1: Alias detection, button tips,
                           status displays.
       November, 1997      DDD  2.2: Persistent sessions, display
                           shortcuts.
       June, 1998          DDD 3.0: Icon tool bar, Java  support,
                           JDB support.
       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



DDD 3.1.2                   1998-12-18                        110





ddd(1)                                                     ddd(1)


       `//uussrr//llooccaall//mmaann//ccaatt11//dddddd..11' or similar) on UNIX systems.

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

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

       This directory also contains other  documentation  related
       to DDD.

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


CCOOPPYYRRIIGGHHTT
   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.




DDD 3.1.2                   1998-12-18                        111





ddd(1)                                                     ddd(1)


       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.2                   1998-12-18                        112


