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 / UndoBuffer.h < prev    next >
C/C++ Source or Header  |  1998-11-17  |  7KB  |  271 lines
  1. // $Id: UndoBuffer.h,v 1.29 1998/11/17 10:05:36 zeller Exp $ -*- C++ -*-
  2. // Undo/Redo buffer
  3.  
  4. // Copyright (C) 1998 Technische Universitaet Braunschweig, Germany.
  5. // Written by Andreas Zeller <zeller@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_UndoBuffer_h
  30. #define _DDD_UndoBuffer_h
  31.  
  32. #ifdef __GNUG__
  33. #pragma interface
  34. #endif
  35.  
  36. #include "bool.h"
  37. #include "UndoBE.h"
  38. #include "string-fun.h"        // itostring()
  39. #include "IntArray.h"
  40.  
  41. class BreakPoint;
  42. class StatusMsg;
  43.  
  44. class UndoBuffer {
  45.  
  46. private:
  47.     // The history itself
  48.     static UndoBufferArray history;
  49.  
  50.     // Last position in history + 1
  51.     static int history_position;
  52.  
  53.     // Currently processed entry
  54.     static int current_entry;
  55.  
  56.     // If true, next `add' creates new entry
  57.     static bool force_new_entry;
  58.  
  59.     // A collector for state values
  60.     static UndoBufferEntry collector;
  61.  
  62.     // True if we have undone some exec position
  63.     static bool _showing_earlier_state;
  64.  
  65.     // Current command source
  66.     static string current_source;
  67.  
  68.     // True if position history is to stay unchanged
  69.     static bool locked;
  70.  
  71.     // Helpers
  72.     static bool process_command(UndoBufferEntry& entry);
  73.     static bool process_state(UndoBufferEntry& entry);
  74.     static bool process_frame(UndoBufferEntry& entry);
  75.     static bool process_pos(UndoBufferEntry& entry);
  76.  
  77.     // True if we're undoing
  78.     static bool undoing;
  79.  
  80.     // Rename all breakpoints from OLD_BP_NR to NEW_BP_NR
  81.     static void remap_breakpoint(int old_bp_nr, int new_bp_nr);
  82.     static void remap_breakpoint(string& cmd, int old_bp_nr, int new_bp_nr);
  83.  
  84.     // Enter or leave `past exec' mode
  85.     static void showing_earlier_state(bool set, StatusMsg *msg = 0);
  86.  
  87.     // Remove all later entries, except for exec positions
  88.     static void clear_after_position();
  89.  
  90.     // Remove all exec commands
  91.     static void clear_exec_commands();
  92.  
  93.     // Remove all entries with no effect
  94.     static void cleanup();
  95.  
  96.  
  97. protected:
  98.     // Add new entry
  99.     static void add_entry(const UndoBufferEntry& entry);
  100.  
  101.     // Process entry
  102.     static bool process_command(int entry);
  103.     static bool process_state(int entry);
  104.     static bool process_frame(int entry);
  105.     static bool process_pos(int entry);
  106.  
  107.     // Log current position
  108.     static void log();
  109.  
  110.     // Call when all is done.  If MSG is set, leave the outcome there.
  111.     static void done(StatusMsg *msg = 0);
  112.  
  113.     // Get a short action description from COMMAND
  114.     static string action(const string& command);
  115.  
  116.     // True if ENTRY has any effect
  117.     static bool has_effect(const UndoBufferEntry& entry);
  118.  
  119. public:
  120.     // Maximum depth (-1: unlimited)
  121.     static int max_history_depth;
  122.  
  123.     // Maximum memory size (-1: unlimited)
  124.     static int max_history_size;
  125.  
  126.     // Set source command.
  127.     static void set_source(const string& command);
  128.  
  129.     // Adding entries
  130.  
  131.     // If SET_SOURCE was called before any of these add_SOMETHING
  132.     // calls, the call creates a new entry in the history.  Otherwise,
  133.     // the values are added to the last entry, possibly overriding
  134.     // existing values.
  135.  
  136.     // Add status NAME/VALUE to history.
  137.     static void add_status(const string& name, const string& value);
  138.  
  139.     // Add command COMMAND to history.  If EXEC is set, COMMAND is
  140.     // treated as execution command, i.e. dependent on the current
  141.     // program state.
  142.     static void add_command(const string &command, bool exec = false);
  143.  
  144.     // Custom calls
  145.     static void add_state()
  146.     {
  147.     add_status(UB_STATE, "");
  148.     }
  149.  
  150.     static void add_position(const string& file_name, int line, bool exec)
  151.     {
  152.     add_status(exec ? UB_EXEC_POS : UB_POS,
  153.            file_name + ":" + itostring(line));
  154.     }
  155.  
  156.     static void add_address(const string& address, bool exec)
  157.     {
  158.     add_status(exec ? UB_EXEC_ADDRESS : UB_ADDRESS, address);
  159.     }
  160.  
  161.     static void add_where(const string& where)
  162.     {
  163.     add_status(UB_WHERE, where);
  164.     }
  165.  
  166.     static void add_frame(const string& frame)
  167.     {
  168.     add_status(UB_FRAME, frame);
  169.     }
  170.  
  171.     static void add_registers(const string& registers)
  172.     {
  173.     add_status(UB_REGISTERS, registers);
  174.     }
  175.  
  176.     static void add_threads(const string& threads)
  177.     {
  178.     add_status(UB_THREADS, threads);
  179.     }
  180.  
  181.     static void add_display(const string& name, const string& value)
  182.     {
  183.     add_status(UB_DISPLAY_PREFIX + name, value);
  184.     }
  185.  
  186.     static void add_display_address(const string& name, const string& addr)
  187.     {
  188.     add_status(UB_DISPLAY_ADDRESS_PREFIX + name, addr);
  189.     }
  190.  
  191.     // Removals
  192.  
  193.     // Remove status NAME from current history entry.
  194.     static void remove_status(const string& name);
  195.  
  196.     static void remove_position()
  197.     {
  198.     remove_status(UB_EXEC_POS);
  199.     remove_status(UB_POS);
  200.     }
  201.  
  202.     static void remove_address()
  203.     {
  204.     remove_status(UB_EXEC_ADDRESS);
  205.     remove_status(UB_ADDRESS);
  206.     }
  207.  
  208.     static void remove_where()
  209.     {
  210.     remove_status(UB_WHERE);
  211.     }
  212.  
  213.     static void remove_frame()
  214.     {
  215.     remove_status(UB_FRAME);
  216.     }
  217.  
  218.     static void remove_registers()
  219.     {
  220.     remove_status(UB_REGISTERS);
  221.     }
  222.  
  223.     static void remove_threads()
  224.     {
  225.     remove_status(UB_THREADS);
  226.     }
  227.  
  228.     static void remove_display(const string& name)
  229.     {
  230.     remove_status(UB_DISPLAY_PREFIX + name);
  231.     remove_status(UB_DISPLAY_ADDRESS_PREFIX + name);
  232.     }
  233.  
  234.     // Undo/Redo action
  235.     static void undo();
  236.     static void redo();
  237.  
  238.     // Undo/Redo action descriptions
  239.     static string undo_action();
  240.     static string redo_action();
  241.  
  242.     // True iff we're showing an earlier program state
  243.     static bool showing_earlier_state() { return _showing_earlier_state; }
  244.  
  245.     // Restore current program state
  246.     static void restore_current_state();
  247.  
  248.     // Clear history
  249.     static void clear();
  250.  
  251.     // Clear all execution positions
  252.     static void clear_exec_pos();
  253.  
  254.     // Add breakpoint state to OS
  255.     static void add_breakpoint_state(ostream& os, BreakPoint *bp);
  256.  
  257.     // Return history of display NAME
  258.     static string display_history(const string& name);
  259.  
  260.     // Return currently allocated bytes
  261.     static int allocation();
  262.  
  263.     // Invariant
  264.     static bool OK();
  265. };
  266.  
  267. extern UndoBuffer undo_buffer;
  268.  
  269. #endif // _DDD_UndoBuffer_h
  270. // DON'T ADD ANYTHING BEHIND THIS #endif
  271.