


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.6                   1999-05-15                          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.6                   1999-05-15                          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r--
       eenncceess-->>SSoouurrccee-->>TTooooll BBuuttttoonnss LLooccaattiioonn' for details.


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

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

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

       +o You can _s_e_l_e_c_t _a_n _i_t_e_m from the source and data windows.



DDD 3.1.6                   1999-05-15                          3





ddd(1)                                                     ddd(1)


         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'
       item in the `HHeellpp' menu) or press CCttrrll++FF11.   Depending  on



DDD 3.1.6                   1999-05-15                          4





ddd(1)                                                     ddd(1)


       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.6                   1999-05-15                          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.6                   1999-05-15                          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.6                   1999-05-15                          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.6                   1999-05-15                          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-tempo-
         rary again.

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




DDD 3.1.6                   1999-05-15                          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.6                   1999-05-15                         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.6                   1999-05-15                         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.6                   1999-05-15                         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.6                   1999-05-15                         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f--
       e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.6                   1999-05-15                         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.6                   1999-05-15                         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.6                   1999-05-15                         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.6                   1999-05-15                         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.6                   1999-05-15                         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.6                   1999-05-15                         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.6                   1999-05-15                         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.6                   1999-05-15                         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.6                   1999-05-15                         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.6                   1999-05-15                         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.6                   1999-05-15                         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.6                   1999-05-15                         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.6                   1999-05-15                         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.6                   1999-05-15                         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r--
       e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s--
       p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.6                   1999-05-15                         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.6                   1999-05-15                         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.6                   1999-05-15                         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r--
       e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r--
       e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 automatic  layout  is
       enabled, the graph is layouted after each change.


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

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




DDD 3.1.6                   1999-05-15                         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.6                   1999-05-15                         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.6                   1999-05-15                         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.6                   1999-05-15                         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.6                   1999-05-15                         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 stopped 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.6                   1999-05-15                         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.6                   1999-05-15                         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.6                   1999-05-15                         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.6                   1999-05-15                         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.6                   1999-05-15                         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-win-
       dow 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.6                   1999-05-15                         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.6                   1999-05-15                         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-dimen-
       sional  arrays,  you  can  disable the `DDiissppllaayy ttwwoo--ddiimmeenn--
       s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.6                   1999-05-15                         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.6                   1999-05-15                         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.6                   1999-05-15                         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.6                   1999-05-15                         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.6                   1999-05-15                         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s--
       ssiioonnss//_s_e_s_s_i_o_n//iinniitt' instead.

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

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

DDEEBBUUGGGGEERR SSEETTTTIINNGGSS
       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
       exactly   one   button.   Clicking  on  `OOKK'  creates  the



DDD 3.1.6                   1999-05-15                         48





ddd(1)                                                     ddd(1)


       appropriate buttons from the text.  If the text  is  empty
       (the default), no button is created.

       As a simple example, assume you want to create a `pprriinntt ii'
       button.  Invoke `CCoommmmaannddss-->>EEddiitt BBuuttttoonnss' and enter a  line
       saying  `pprriinntt  ii'  in  the  button editor.  Then click on
       `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.

       +o Click on `EEddiitt >>>>' to edit the recorded commands.   When



DDD 3.1.6                   1999-05-15                         49





ddd(1)                                                     ddd(1)


         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.6                   1999-05-15                         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.6                   1999-05-15                         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.6                   1999-05-15                         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
       saving  a  session.  Depending on your architecture, other



DDD 3.1.6                   1999-05-15                         53





ddd(1)                                                     ddd(1)


       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

       There is no need to give further command-line options when



DDD 3.1.6                   1999-05-15                         54





ddd(1)                                                     ddd(1)


       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.   Likewise,  DDD  supports  the GDB `--aannnnoottaattee'
       option for even more detailed interaction.

       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'  or  with  the
         `--aannnnoottaattee'  option, the debugger console and the source
         window are initially disabled, as their  facilities  are
         supposed to be provided 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.6                   1999-05-15                         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
       In  XEmacs  21 and later, select `TToooollss-->>DDeebbuugg ((GGDDBB))'.  At
       the prompt, enter `dddddd' and the name of the program to  be
       debugged.  Proceed as usual.

       To   debug  with  DBX  in  XEmacs  21  and  later,  select
       `TToooollss-->>DDeebbuugg ((DDBBXX))'.  At the  prompt,  enter  `dddddd  ----ddbbxx
       ----ttttyy'  and  the name of the program to be debugged.  Pro-
       ceed as usual.

       In XEmacs 20 and earlier, 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 earlier):

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

       Use  `MM--xx  ggddbb'  or  `MM--xx  ggddbbssrrcc' or `MM--xx ddbbxx' to start a
       debugging session.  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



DDD 3.1.6                   1999-05-15                         56





ddd(1)                                                     ddd(1)


       library using this resource.  (Unfortunately,  DDD  cannot
       detect this at run-time.)

       Here are a few scenarios to illustrate this scheme:

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

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

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

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

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

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

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

   UUssiinngg DDDDDD wwiitthh aa RReemmoottee DDeebbuuggggeerr
       In order to run the inferior debugger on  a  remote  host,
       you  need  `rreemmsshh' (called `rrsshh' on BSD systems) access on
       the remote host.

       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




DDD 3.1.6                   1999-05-15                         57





ddd(1)                                                     ddd(1)


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

       instead.

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

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

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

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

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

       +o To  help  you find problems due to remote execution, run
         DDD with the `----ttrraaccee' option.  This  prints  the  shell
         commands issued by DDD on standard error.

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



DDD 3.1.6                   1999-05-15                         58





ddd(1)                                                     ddd(1)


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

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

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

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

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

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

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

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

       to debug programs with root privileges.

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

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

   SSeettttiinngg DDDDDD FFoonnttss
       DDD uses the following resources to set up its fonts:

       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




DDD 3.1.6                   1999-05-15                         59





ddd(1)                                                     ddd(1)


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

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

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

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

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

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

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

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

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

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

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

       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




DDD 3.1.6                   1999-05-15                         60





ddd(1)                                                     ddd(1)


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

       You can copy and modify the appropriate resources to  your
       `$$HHOOMMEE//..dddddd//iinniitt'  file.   For colors within the data dis-
       play,  things  are  slightly  more  complicated--see   the
       `vvssllDDeeffss' resource, below.

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




DDD 3.1.6                   1999-05-15                         61





ddd(1)                                                     ddd(1)


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

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

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





DDD 3.1.6                   1999-05-15                         62





ddd(1)                                                     ddd(1)


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




DDD 3.1.6                   1999-05-15                         63





ddd(1)                                                     ddd(1)


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

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

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

              Note:  if  DDD  runs on a monochrome display, or if
              DDD was compiled without the XPM library, only  the
              monochrome version (`mm') can be shown.

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

       ssttaarrttuuppTTiippCCoouunntt ((class SSttaarrttuuppTTiippCCoouunntt))
              The number _n of the tip of the day to be  shown  at
              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.



DDD 3.1.6                   1999-05-15                         64





ddd(1)                                                     ddd(1)


       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.

       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



DDD 3.1.6                   1999-05-15                         65





ddd(1)                                                     ddd(1)


              occurrences are found.

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

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

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

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



DDD 3.1.6                   1999-05-15                         66





ddd(1)                                                     ddd(1)


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

       uusseeSSoouurrcceePPaatthh ((class UUsseeSSoouurrcceePPaatthh))
              If this is `ooffff' (default), the  inferior  debugger
              refers  to source code locations only by their base
              names.  If this is `oonn'  (default),  DDD  uses  the
              full source code paths.

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

       aauuttooRRaaiisseeTTooooll ((class AAuuttooRRaaiisseeTTooooll))
              If `oonn' (default), DDD will always keep the command
              tool on top of other DDD windows.  If this  setting
              interferes  with  your  window  manager, or if your
              window manager keeps the command tool on  top  any-
              way, set this resource to `ooffff'.

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

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


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

       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



DDD 3.1.6                   1999-05-15                         67





ddd(1)                                                     ddd(1)


                windows  are  not  automatically  kept  on top of
                other windows, such that you may wish to set  the
                `aauuttooRRaaiisseeTTooooll' resource, too.

              +o If  this  is `aauuttoo' (default), DDD checks whether
                the window manager decorates transients.  If yes,
                the  command tool is realized as a transient win-
                dow (as in the `ooffff' setting); if no, the command
                tool is realized as a top-level window (as in the
                `oonn' setting).  Hence, the command tool is always
                decorated  using the "best" method, but the extra
                check takes some time.


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

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

       ooppeennSSoouurrcceeWWiinnddooww ((class WWiinnddooww))
              If `ooffff', the source window is closed  upon  start-
              up.

       sseeppaarraatteeDDaattaaWWiinnddooww ((class SSeeppaarraattee))
              If  `oonn',  the data window and the debugger console
              are realized in different  top-level  windows.   If
              `ooffff' (default), the data window is attached to the
              debugger console.  See also the  `----aattttaacchh--wwiinnddoowwss'
              and `----aattttaacchh--ddaattaa--wwiinnddooww' options, below.

       sseeppaarraatteeEExxeeccWWiinnddooww ((class SSeeppaarraattee))
              If `oonn', the debugged program is executed in a sep-
              arate execution window.  If  `ooffff'  (default),  the
              debugged program is executed in the console window.
              See also the `----eexxeecc--wwiinnddooww' and `----nnoo--eexxeecc--wwiinnddooww'
              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n--
              d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.




DDD 3.1.6                   1999-05-15                         68





ddd(1)                                                     ddd(1)


       ssttiicckkyyTTooooll ((class SSttiicckkyyTTooooll))
              If `oonn' (default), the command  tool  automatically
              follows every movement of the source window.  When-
              ever the source window is moved, the  command  tool
              is  moved by the same offset such that its position
              relative to the source  window  remains  unchanged.
              If  `ooffff',  the command tool does not follow source
              window movements.

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


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

       aannnnoottaattee ((class AAnnnnoottaattee))
              If this is 11  or  more,  DDD  reports  the  current
              source  position  on standard output in GDB `--ffuullll--
              nnaammee' format.  As a side effect, the source  window
              is  disabled  by default.  Default value is 00.  See
              also the `----ffuullllnnaammee' option, below.

       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



DDD 3.1.6                   1999-05-15                         69





ddd(1)                                                     ddd(1)


              inferior  debugger  via  the  pseudo-tty interface.
              Some systems _r_e_q_u_i_r_e this, such as Linux with  libc
              5.4.33  and  earlier;  set  it to `oonn'.  Some other
              systems _p_r_o_h_i_b_i_t this, such as Linux with GNU  libc
              6  and  later;  set  it to `ooffff'.  The value `aauuttoo'
              (default) will  always  select  the  "best"  choice
              (that is, the best choice known to the DDD develop-
              ers).

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

       ddbbxxSSeettttiinnggss ((class SSeettttiinnggss))
              This string contains a  list  of  newline-separated
              commands  that  are also initially sent to DBX.  By
              default, it is empty.

       ddeebbuuggggeerr ((class DDeebbuuggggeerr))
              The type of the inferior debugger 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



DDD 3.1.6                   1999-05-15                         70





ddd(1)                                                     ddd(1)


              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.

       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.



DDD 3.1.6                   1999-05-15                         71





ddd(1)                                                     ddd(1)


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

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

       ppeerrllIInniittCCoommmmaannddss ((class IInniittCCoommmmaannddss))
              This string contains a  list  of  newline-separated
              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.



DDD 3.1.6                   1999-05-15                         72





ddd(1)                                                     ddd(1)


              By default, it sets up  the  remote  terminal  such
              that it suits DDD:

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

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

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

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

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

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

       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,



DDD 3.1.6                   1999-05-15                         73





ddd(1)                                                     ddd(1)


              use  a  personal `$$HHOOMMEE//..xxddbbrrcc' file.  See your XDB
              documentation for details.

       xxddbbSSeettttiinnggss ((class SSeettttiinnggss))
              This string contains a  list  of  newline-separated
              commands  that  are also initially sent to XDB.  By
              default, it is empty.


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

       aaccttiivveeBBuuttttoonnCCoolloorrKKeeyy ((class CCoolloorrKKeeyy))
              The  XPM  color key to use for the images of active
              buttons (entered or armed).  `cc' means  color,  `gg'
              (default) means grey, and `mm' means monochrome.

       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.





DDD 3.1.6                   1999-05-15                         74





ddd(1)                                                     ddd(1)


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

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

              The following characters have special meanings:

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

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

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

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

              The following button names are reserved:

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

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

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

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

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

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

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

              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.




DDD 3.1.6                   1999-05-15                         75





ddd(1)                                                     ddd(1)


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

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

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


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

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

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

              This setting creates some more buttons:

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

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


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

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

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

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



DDD 3.1.6                   1999-05-15                         76





ddd(1)                                                     ddd(1)


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

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

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

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

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

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

              An  even  more professional setting uses customized
              button labels.

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

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

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



DDD 3.1.6                   1999-05-15                         77





ddd(1)                                                     ddd(1)


              issues  the  command  given  by  its name.  See the
              `ccoonnssoolleeBBuuttttoonnss' resource, above,  for  details  on
              button syntax.

              The default resource value is

                DDdddd**ttoooollBBuuttttoonnss:: \\
                rruunn\\nnbbrreeaakk^^CC\\nnsstteepp\\nnsstteeppii\\nnnneexxtt\\nnnneexxttii\\nn\\
                uunnttiill\\nnffiinniisshh\\nnccoonntt\\nn\\kkiillll\\nn\\
                uupp\\nnddoowwnn\\nnBBaacckk\\nnFFoorrwwaarrdd\\nnEEddiitt\\nnMMaakkee

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

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

       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



DDD 3.1.6                   1999-05-15                         78





ddd(1)                                                     ddd(1)


              be included in the `NNeeww DDiissppllaayy' menu for GDB.  See
              the description of `ddbbxxDDiissppllaayySShhoorrttccuuttss', above.

       jjddbbDDiissppllaayySShhoorrttccuuttss ((class DDiissppllaayySShhoorrttccuuttss))
              A  newline-separated list of display expressions to
              be included in the `NNeeww DDiissppllaayy' menu for JDB.  See
              the description of `ddbbxxDDiissppllaayySShhoorrttccuuttss', above.

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

       ppeerrllDDiissppllaayySShhoorrttccuuttss ((class DDiissppllaayySShhoorrttccuuttss))
              A newline-separated list of display expressions  to
              be  included  in  the  `NNeeww DDiissppllaayy' menu for Perl.
              See  the  description   of   `ddbbxxDDiissppllaayySShhoorrttccuuttss',
              above.

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





DDD 3.1.6                   1999-05-15                         79





ddd(1)                                                     ddd(1)


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

       ddeelleetteeAAlliiaassDDiissppllaayyss ((class DDeelleetteeAAlliiaassDDiissppllaayyss))
              If this is `oonn' (default), the `UUnnddiissppllaayy (())'  but-
              ton  also  deletes all aliases of the selected dis-
              plays.  If this is `ooffff', only  the  selected  dis-
              plays  are  deleted; the aliases remain, and one of
              the aliases will be unsuppressed.

       ddeetteeccttAAlliiaasseess ((class DDeetteeccttAAlliiaasseess))
              If `oonn', DDD  attempts  to  recognize  shared  data
              structures.   See  `EExxaammiinniinngg  sshhaarreedd  ddaattaa  ssttrruucc--
              ttuurreess', above, for a discussion.   The  default  is
              `ooffff',  meaning that shared data structures are not
              recognized.

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





DDD 3.1.6                   1999-05-15                         80





ddd(1)                                                     ddd(1)


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

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

       vvssllBBaasseeDDeeffss ((class VVSSLLDDeeffss))
              A  string  with additional VSL definitions that are
              appended to the builtin VSL library.  This resource
              is  prepended  to  the `vvssllDDeeffss' resource below and
              set in the DDD  application  defaults  file;  don't
              change it.

       vvssllDDeeffss ((class VVSSLLDDeeffss))
              A  string  with additional VSL definitions that are
              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""))





DDD 3.1.6                   1999-05-15                         81





ddd(1)                                                     ddd(1)


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

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

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

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

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

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

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



DDD 3.1.6                   1999-05-15                         82





ddd(1)                                                     ddd(1)


                ssttddffoonnttppooiinnttss(()) == 110000;;\\nn

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

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

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


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

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

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

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

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

              Instead of supplying another  VSL  library,  it  is
              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



DDD 3.1.6                   1999-05-15                         83





ddd(1)                                                     ddd(1)


         provide  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
         customizable (Gnuplot resources are not understood).

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

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

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



DDD 3.1.6                   1999-05-15                         84





ddd(1)                                                     ddd(1)


              inferior is output on each own, such that the final
              line  is  placed at the bottom of the debugger con-
              sole.  If this is `ooffff', all lines are output as  a
              whole.   This  is  faster,  but results in a random
              position of the last line.


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

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

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



DDD 3.1.6                   1999-05-15                         85





ddd(1)                                                     ddd(1)


              the PRIMARY selection or print the selected font on
              standard output.  A typical value is:

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


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

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

       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



DDD 3.1.6                   1999-05-15                         86





ddd(1)                                                     ddd(1)


              file filter.  The default setting is:

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


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

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


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




DDD 3.1.6                   1999-05-15                         87





ddd(1)                                                     ddd(1)


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

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

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

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




DDD 3.1.6                   1999-05-15                         88





ddd(1)                                                     ddd(1)


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

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

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

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

       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



DDD 3.1.6                   1999-05-15                         89





ddd(1)                                                     ddd(1)


       information about setting DDD resources.  The  `DDdddd'  file
       comes with the DDD distribution.

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

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


       ----aannnnoottaattee _l_e_v_e_l
              If _l_e_v_e_l is 1 or more, enable TTY interface, taking
              additional  debugger  commands  from standard input
              and forwarding debugger 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 win-
              dow are disabled.  If _l_e_v_e_l is 2 or more, DDD  also
              issues  annotations  about  its current state, like
              the GDB `--aannnnoottaattee==22'  format.   These  annotations
              should suffice for XEmacs integration.  If _l_e_v_e_l is
              0, no annotations are made.

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



DDD 3.1.6                   1999-05-15                         90





ddd(1)                                                     ddd(1)


              and exit.

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

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

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

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

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

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

       ----ddiissaasssseemmbbllee
              Disassemble  the  source code.  See also the `----nnoo--
              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
              Same as `----aannnnoottaattee 11', above.

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





DDD 3.1.6                   1999-05-15                         91





ddd(1)                                                     ddd(1)


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

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

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

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

       ----lleessssttiiff--hhaacckkss
              Equivalent to `----lleessssttiiff--vveerrssiioonn 999999'.  Deprecated.

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

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

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



DDD 3.1.6                   1999-05-15                         92





ddd(1)                                                     ddd(1)


              created  execution window; use the debugger console
              instead.  Useful for programs that have little ter-
              minal input/output, or for remote debugging.

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

       ----nnoo--lleessssttiiff--hhaacckkss
              Equivalent  to  `----lleessssttiiff--vveerrssiioonn  11000000'.   Depre-
              cated.

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

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

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

       ----ppeerrll Run Perl as inferior debugger.

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

       ----ppaannnneedd--ggrraapphh--eeddiittoorr
              Use an Athena panner to  scroll  the  data  window.
              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.





DDD 3.1.6                   1999-05-15                         93





ddd(1)                                                     ddd(1)


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

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

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

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

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

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

       ----ttoooollbbaarrss--aatt--bboottttoomm
              Place the toolbars the bottom of the window.

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



DDD 3.1.6                   1999-05-15                         94





ddd(1)                                                     ddd(1)


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

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

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

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

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

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

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

       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.



DDD 3.1.6                   1999-05-15                         95





ddd(1)                                                     ddd(1)


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

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

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

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

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

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

       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



DDD 3.1.6                   1999-05-15                         96





ddd(1)                                                     ddd(1)


              layout  algorithm; ccoommppaacctt uses an alternate layout
              algorithm, where  successors  are  placed  next  to
              their  parents.  Default is rreegguullaarr.  _d_e_g_r_e_e_s indi-
              cates in which direction the graph should  be  lay-
              outed.  Default is the current graph direction.

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

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

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

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

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

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

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

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

       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.





DDD 3.1.6                   1999-05-15                         97





ddd(1)                                                     ddd(1)


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

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

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

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

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

       ggddbb--bbeeggiinnnniinngg--ooff--lliinnee (())
              Move cursor to the beginning of the  current  line,
              after the prompt.  Bound to HHOOMMEE.

       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.



DDD 3.1.6                   1999-05-15                         98





ddd(1)                                                     ddd(1)


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

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

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

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

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

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

       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



DDD 3.1.6                   1999-05-15                         99





ddd(1)                                                     ddd(1)


              MMoottiiff, perform _b_e_g_i_n_n_i_n_g_-_o_f_-_l_i_n_e.  Otherwise,  per-
              form _s_e_l_e_c_t_-_a_l_l.  Bound to CCttrrll++AA.

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

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

       ssoouurrccee--ddeelleettee--ggllyypphh (())
              Delete  the breakpoint related to the glyph at cur-
              sor position.

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

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

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

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





DDD 3.1.6                   1999-05-15                        100





ddd(1)                                                     ddd(1)


       ssoouurrccee--sseett--aarrgg (())
              Set  the  argument  field to the current selection.
              Typically bound to some selection operation.

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

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

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

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

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

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

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



DDD 3.1.6                   1999-05-15                        101





ddd(1)                                                     ddd(1)


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

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

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

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

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

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

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

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

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

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

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

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




DDD 3.1.6                   1999-05-15                        102





ddd(1)                                                     ddd(1)


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

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

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

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

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

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

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

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

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


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


       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.




DDD 3.1.6                   1999-05-15                        103





ddd(1)                                                     ddd(1)


       VVSSLL__IINNCCLLUUDDEE         Where to search for VSL include files.
                           Default is the current directory.

       WWWWWWBBRROOWWSSEERR          The WWW browser to invoke for  viewing
                           the  DDD  WWW  page.  See the `wwwwwwCCoomm--
                           mmaanndd' resource, above.

       XXEEDDIITTOORR             The X editor  to  invoke  for  editing
                           source  code.   See  the `eeddiittCCoommmmaanndd'
                           resource, above.

       The following environment variables are set by DDD:


       DDDDDD                 Set to a  string  indicating  the  DDD
                           version.   By  testing  whether DDDDDD is
                           set, a debuggee (or inferior debugger)
                           can  determine  whether it was invoked
                           by DDD.

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

       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



DDD 3.1.6                   1999-05-15                        104





ddd(1)                                                     ddd(1)


                           number of the next tip of the day.
       $$HHOOMMEE//..ggddbbiinniitt      GDB initialization file.
       $$HHOOMMEE//..ddbbxxiinniitt      DBX initialization file.
       $$HHOOMMEE//..ddbbxxrrcc        Alternate DBX initialization file.
       $$HHOOMMEE//..xxddbbrrcc        XDB initialization file.
       $$HHOOMMEE//..ggnnuupplloott      Gnuplot initialization file.
       $$HHOOMMEE//..ddddddiinniitt      Old-style  DDD  initialization   file;
                           used  only if $$HHOOMMEE//..dddddd//iinniitt does not
                           exist.

SSEEEE AALLSSOO
       XX(1),  ggddbb(1),  ddbbxx(1),  xxddbb(1),  ppeerrllddeebbuugg(1),  rreemmsshh(1),
       rrsshh(1), ggnnuupplloott(1),

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

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

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

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

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

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

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

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

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


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

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


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

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

       For more information on this list, send a mail to

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



DDD 3.1.6                   1999-05-15                        105





ddd(1)                                                     ddd(1)


LLIIMMIITTAATTIIOONNSS
   GGeenneerraall LLiimmiittaattiioonnss
       If command output is sent to the debugger console,  it  is
       impossible  for  DDD  to distinguish between the output of
       the debugged program and the output of the inferior debug-
       ger.   This  problem can be avoided by running the program
       in the separate execution window.

       Output that confuses DDD includes:

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

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

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

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

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

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

       If the inferior debugger changes the default TTY settings,
       for  instance  through a `ssttttyy' command in its 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



DDD 3.1.6                   1999-05-15                        106





ddd(1)                                                     ddd(1)


       with 1.

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

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

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

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

       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



DDD 3.1.6                   1999-05-15                        107





ddd(1)                                                     ddd(1)


       may also send _f_i_x_e_s; DDD is an excellent tool  for  debug-
       ging itself :-)

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

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

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

         Technische Universitt Braunschweig
         Abteilung Softwaretechnologie
         DDD-Bugs
         Bltenweg 88
         D-38092 Braunschweig
         GERMANY

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

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

       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



DDD 3.1.6                   1999-05-15                        108





ddd(1)                                                     ddd(1)


         assumption that the bug is not known.

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

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

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


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

       +o Your DDD configuration.  Invoke DDD as

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

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

       +o The debugger  you  are  using  and  its  version  (e.g.,
         `ggddbb--44..1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.



DDD 3.1.6                   1999-05-15                        109





ddd(1)                                                     ddd(1)


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

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

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

       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:




DDD 3.1.6                   1999-05-15                        110





ddd(1)                                                     ddd(1)


         Technische Universitt Braunschweig
         Abteilung Softwaretechnologie
         Bltenweg 88
         D-38092 Braunschweig
         GERMANY

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

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



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

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

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

       This  directory  also contains other documentation related
       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, 1999 Technis-
       che 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



DDD 3.1.6                   1999-05-15                        111





ddd(1)                                                     ddd(1)


       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,
       1999 Technische Universitt Braunschweig, Germany.

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

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

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


































DDD 3.1.6                   1999-05-15                        112


