home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1999 mARCH / PCWK3A99.iso / Linux / DDD331 / DDD-3_1_.000 / DDD-3_1_ / ddd-3.1.1 / ddd / BreakPoint.h < prev    next >
C/C++ Source or Header  |  1998-12-04  |  8KB  |  221 lines

  1. // $Id: BreakPoint.h,v 1.33.4.1 1998/12/04 10:39:03 zeller Exp $
  2. // Breakpoint handler
  3.  
  4. // Copyright (C) 1995 Technische Universitaet Braunschweig, Germany.
  5. // Written by Dorothea Luetkehaus <luetke@ips.cs.tu-bs.de>.
  6. // 
  7. // This file is part of DDD.
  8. // 
  9. // DDD is free software; you can redistribute it and/or
  10. // modify it under the terms of the GNU General Public
  11. // License as published by the Free Software Foundation; either
  12. // version 2 of the License, or (at your option) any later version.
  13. // 
  14. // DDD is distributed in the hope that it will be useful,
  15. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  17. // See the GNU General Public License for more details.
  18. // 
  19. // You should have received a copy of the GNU General Public
  20. // License along with DDD -- see the file COPYING.
  21. // If not, write to the Free Software Foundation, Inc.,
  22. // 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23. // 
  24. // DDD is the data display debugger.
  25. // For details, see the DDD World-Wide-Web page, 
  26. // `http://www.cs.tu-bs.de/softech/ddd/',
  27. // or send a mail to the DDD developers <ddd@ips.cs.tu-bs.de>.
  28.  
  29. #ifndef _DDD_BreakPoint_h
  30. #define _DDD_BreakPoint_h
  31.  
  32. #ifdef __GNUG__
  33. #pragma interface
  34. #endif
  35.  
  36. //-----------------------------------------------------------------------------
  37. // A `BreakPoint' stores information about an existing debugger breakpoint.
  38. //-----------------------------------------------------------------------------
  39.  
  40. #include <X11/Intrinsic.h>
  41.  
  42. // Misc includes
  43. #include "strclass.h"
  44. #include "bool.h"
  45. #include "GDBAgent.h"
  46. #include "StringA.h"
  47.  
  48. // Breakpoint type
  49. enum BPType {
  50.     BREAKPOINT,            // Breakpoint
  51.     WATCHPOINT            // Watchpoint
  52. };
  53.  
  54. // What to do when breakpoint is reached
  55. enum BPDispo {
  56.     BPKEEP,            // Keep (default)
  57.     BPDEL,            // Delete (temporary breakpoint)
  58.     BPDIS            // Disable (`enable once' in GDB)
  59. };
  60.  
  61. class BreakPoint {
  62.     int     mynumber;        // Breakpoint number
  63.     BPType  mytype;        // Type, as above
  64.     BPDispo mydispo;        // Disposition, as above
  65.     bool    myenabled;        // Is breakpoint enabled?
  66.     string  myfile_name;    // File name
  67.     int     myline_nr;        // Line number
  68.     string  myaddress;        // Address in memory
  69.     string  myfunc;        // Function name
  70.     string  myexpr;        // Expression to watch (for watchpoints)
  71.     string  myinfos;        // Additional information (human-readable)
  72.     int     myignore_count;    // Ignore count
  73.     string  mycondition;    // Breakpoint condition
  74.     StringArray mycommands;    // Commands to be issued when reached
  75.     string  myarg;        // Argument as given to breakpoint command
  76.     WatchMode mywatch_mode;    // Watchpoint detail
  77.  
  78.     bool    myenabled_changed;    // True if `enabled' state changed
  79.     bool    myfile_changed;    // True if source file changed
  80.     bool    myposition_changed;    // True if position changed
  81.     bool    myaddress_changed;    // True if address changed
  82.     bool    myselected;        // True if selected
  83.  
  84.     Widget  mysource_glyph;    // Associated glyph in source
  85.     Widget  mycode_glyph;    // Associated glyph in code
  86.  
  87. private:
  88.     BreakPoint(const BreakPoint& b)
  89.     : mynumber(b.mynumber),
  90.       mytype(b.mytype),
  91.       mydispo(b.mydispo),
  92.       myenabled(b.myenabled),
  93.       myfile_name(b.myfile_name),
  94.       myline_nr(b.myline_nr),
  95.       myaddress(b.myaddress),
  96.       myfunc(b.myfunc),
  97.       myexpr(b.myexpr),
  98.       myinfos(b.myinfos),
  99.       myignore_count(b.myignore_count),
  100.       mycondition(b.mycondition),
  101.       mycommands(b.mycommands),
  102.       myarg(b.myarg),
  103.       mywatch_mode(b.mywatch_mode),
  104.       myenabled_changed(b.myenabled_changed),
  105.       myfile_changed(b.myfile_changed),
  106.       myposition_changed(b.myposition_changed),
  107.       myaddress_changed(b.myaddress_changed),
  108.       myselected(b.myselected),
  109.       mysource_glyph(b.mysource_glyph),
  110.       mycode_glyph(b.mycode_glyph)
  111.     {
  112.     assert(0);
  113.     }
  114.     BreakPoint& operator = (const BreakPoint&)
  115.     {
  116.     assert(0); return *this;
  117.     }
  118.  
  119. protected:
  120.     // Helpers
  121.     static string false_value();
  122.     static string and_op();
  123.     static bool is_false(const string& cond);
  124.  
  125.     void process_gdb(string& info_output);
  126.     void process_dbx(string& info_output);
  127.     void process_xdb(string& info_output);
  128.     void process_jdb(string& info_output);
  129.     void process_pydb(string& info_output);
  130.     void process_perl(string& info_output);
  131.  
  132. public:
  133.     // Create new breakpoint from INFO_OUTPUT.  ARG denotes the
  134.     // argument of a breakpoint setting command.  If NUMBER is != 0,
  135.     // assign this number.  If FILE is != "", assume this file.
  136.     // Delete own info from INFO_OUTPUT.
  137.     BreakPoint(string& info_output, 
  138.            const string& arg, int number, string& file);
  139.  
  140.     // This should avoid link warnings on SGI
  141.     // as reported by Mike Tosti <tosti@cinesite.com>
  142.     ~BreakPoint() {}
  143.  
  144.     // Breakpoint number.
  145.     int number() const               { return mynumber; }
  146.  
  147.     // Breakpoint symbol (`#N#', `?N?', or `_N_')
  148.     string symbol() const;
  149.  
  150.     // Breakpoint type.
  151.     BPType type() const { return mytype; }
  152.  
  153.     // What to do when breakpoint is reached.
  154.     BPDispo dispo() const { return mydispo; }
  155.  
  156.     // Whether breakpoint is enabled
  157.     bool enabled() const;
  158.  
  159.     // Breakpoint position
  160.     const string& file_name() const { return myfile_name; }
  161.     int line_nr() const             { return myline_nr; }
  162.     const string& address() const   { return myaddress; }
  163.     string pos() const;
  164.     const string& func() const      { return myfunc; }
  165.  
  166.     // Watchpoint info
  167.     const string& expr() const   { return myexpr; }
  168.     WatchMode watch_mode() const { return mywatch_mode; }
  169.  
  170.     // Additional infos
  171.     const string& infos() const          { return myinfos; }
  172.     int ignore_count() const             { return myignore_count; }
  173.     const string& real_condition() const { return mycondition; }
  174.     const StringArray& commands() const  { return mycommands; }
  175.     string condition() const;
  176.  
  177.     // Argument of breakpoint-setting command, as passed to constructor
  178.     const string& arg() const { return myarg; }
  179.  
  180.     // Selection state
  181.     bool& selected() { return myselected; }
  182.  
  183.     // Associated glyphs in source and machine code
  184.     Widget& source_glyph() { return mysource_glyph; }
  185.     Widget& code_glyph()   { return mycode_glyph; }
  186.  
  187.     // True iff `enabled' status changed
  188.     bool enabled_changed () const { return myenabled_changed; }
  189.  
  190.     // True iff file name changed
  191.     bool file_changed () const { return myfile_changed; }
  192.  
  193.     // True iff position changed
  194.     bool position_changed () const { return myposition_changed; }
  195.  
  196.     // True iff address changed
  197.     bool address_changed () const { return myaddress_changed; }
  198.  
  199.     // Update breakpoint from breakpoint info INFO_OUTPUT.  Return
  200.     // true iff changes occurred.  Delete own info from INFO_OUTPUT.
  201.     // UNDO_COMMANDS contains commands to undo the change.
  202.     // NEED_TOTAL_UNDO is set iff the change requires deleting and
  203.     // setting a new breakpoint.
  204.     bool update(string& info_output, ostream& undo_commands, 
  205.         bool& need_total_undo);
  206.  
  207.     // Return commands to restore this breakpoint, using the dummy
  208.     // number NR.  If AS_DUMMY is set, delete the breakpoint
  209.     // immediately in order to increase the breakpoint number.  If
  210.     // ADDR is set, use ADDR as (fake) address.  If COND is set, use
  211.     // COND as (fake) condition.  Return true iff successful.
  212.     bool get_state(ostream& os, int nr, bool as_dummy = false, 
  213.            string addr = "", string cond = char(-1));
  214.  
  215.     // Stuff for constructing `false' breakpoint conditions
  216.     static string make_false(const string& cond);
  217. };
  218.  
  219. #endif // _DDD_BreakPoint_h
  220. // DON'T ADD ANYTHING BEHIND THIS #endif
  221.