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 / DispValue.h < prev    next >
C/C++ Source or Header  |  1998-11-24  |  11KB  |  398 lines
  1. // $Id: DispValue.h,v 1.51 1998/11/24 09:56:30 zeller Exp $
  2. // Read and store type and value of a displayed expression
  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_DispValue_h
  30. #define _DDD_DispValue_h
  31.  
  32. #ifdef __GNUG__
  33. #pragma interface
  34. #endif
  35.  
  36. //-----------------------------------------------------------------------------
  37. // A DispValue reads and stores type and value of a displayed expression
  38. //-----------------------------------------------------------------------------
  39.  
  40. #include "strclass.h"
  41. #include "bool.h"
  42. #include "DispValueA.h"
  43. #include "DispValueT.h"
  44. #include "StringSA.h"
  45. #include "Box.h"
  46.  
  47. class Agent;
  48. class PlotAgent;
  49.  
  50. enum DispValueAlignment {Vertical, Horizontal};
  51.  
  52. class DispValue {
  53.     // General members
  54.     DispValueType mytype;
  55.     bool myexpanded;
  56.     bool myenabled;
  57.     string myfull_name;        // Full name
  58.     string print_name;        // Name relative to parent
  59.     string myaddr;        // Address as found
  60.     bool changed;
  61.     int myrepeats;        // Number of repetitions
  62.  
  63.     // Type-dependent members
  64.     string _value;        // Value of basic types
  65.     bool _dereferenced;        // True iff pointer is dereferenced
  66.     DispValueArray _children;    // Array or Struct members 
  67.     int _index_base;        // First index
  68.     bool _have_index_base;    // True if INDEX_BASE is valid
  69.     DispValueAlignment _alignment; // Array alignment
  70.     bool _has_plot_alignment;   // True if plotter set the alignment
  71.  
  72.     // Plotting stuff
  73.     PlotAgent *_plotter;    // Plotting agent
  74.  
  75.     // Caching stuff
  76.     Box *_cached_box;        // Last box
  77.     int _cached_box_change;    // Last cached box change
  78.     static int cached_box_tics;    // Counter
  79.  
  80.     // Initialize from VALUE.  If TYPE is given, use TYPE as type
  81.     // instead of inferring it.
  82.     void init(DispValue *parent, int depth, 
  83.           string& value, DispValueType type = UnknownType);
  84.  
  85.     // Delete helper
  86.     void clear();
  87.  
  88.     // Assignment
  89.     void assign(DispValue& dv);
  90.  
  91.     DispValue& operator = (const DispValue&)
  92.     {
  93.     assert(0); return *this;
  94.     }
  95.  
  96.     // Helpers
  97.     static StringStringAssoc type_cache;
  98.     static int index_base(const string& expr, int dim);
  99.     static string add_member_name(const string& base, 
  100.                   const string& member_name);
  101.  
  102.     // Plotting stuff
  103.     void _plot(PlotAgent *plotter, int ndim) const;
  104.     void plot1d(PlotAgent *plotter, int ndim) const;
  105.     void plot2d(PlotAgent *plotter, int ndim) const;
  106.     void plot3d(PlotAgent *plotter, int ndim) const;
  107.     bool can_plot1d() const;
  108.     bool can_plot2d() const;
  109.     bool can_plot3d() const;
  110.     static bool starts_number(char c);
  111.  
  112.     static void PlotterDiedHP(Agent *, void *, void *);
  113.  
  114.     // Update helper
  115.     DispValue *_update(DispValue *source, 
  116.                bool& was_changed, bool& was_initialized);
  117.  
  118.     // Clear cached box
  119.     void clear_cached_box()
  120.     {
  121.     if (_cached_box != 0)
  122.     {
  123.         _cached_box->unlink();
  124.         _cached_box = 0;
  125.     }
  126.     _cached_box_change = 0;
  127.     }
  128.  
  129. protected:
  130.     int _links;            // #references (>= 1)
  131.  
  132.     // Array, Struct
  133.     // Expand/collapse single value
  134.     void _expand()
  135.     {
  136.     if (myexpanded)
  137.         return;
  138.  
  139.     myexpanded = true;
  140.     clear_cached_box();
  141.     }
  142.     void _collapse()
  143.     {
  144.     if (!myexpanded)
  145.         return;
  146.  
  147.     myexpanded = false;
  148.     clear_cached_box();
  149.     }
  150.  
  151.     // True if more sequence members are coming
  152.     static bool sequence_pending(const string& value, 
  153.                  const DispValue *parent);
  154.  
  155.     // Numeric value
  156.     string num_value() const;
  157.  
  158.     // The DispValue type and address are determined from VALUE
  159.     DispValue (DispValue *parent, 
  160.            int        depth,
  161.            string&    value,
  162.            const string& full_name, 
  163.            const string& print_name,
  164.            DispValueType type = UnknownType);
  165.  
  166.     // Parsing function
  167.     static DispValue *parse(DispValue *parent, 
  168.                 int depth,
  169.                 string& value,
  170.                 const string& full_name, 
  171.                 const string& print_name,
  172.                 DispValueType type = UnknownType);
  173.  
  174.     DispValue *parse_child(int depth,
  175.                string& value,
  176.                const string& full_name, 
  177.                const string& _print_name,
  178.                DispValueType type = UnknownType)
  179.     {
  180.     return parse(this, depth + 1, value, full_name, _print_name, type);
  181.     }
  182.  
  183.     DispValue *parse_child(int depth,
  184.                string& value,
  185.                const string& name, 
  186.                DispValueType type = UnknownType)
  187.     {
  188.     return parse_child(depth, value, name, name, type);
  189.     }
  190.  
  191.  
  192.     // Copy constructor
  193.     DispValue (const DispValue& dv);
  194.  
  195.     // Return a `normalized' prefix BASE for arrays and structs
  196.     string normalize_base(const string& base);
  197.  
  198. public:
  199.     // Global settings
  200.     static bool expand_repeated_values;
  201.  
  202.     // Parse VALUE into a DispValue tree
  203.     static DispValue *parse(string& value, const string& name)
  204.     {
  205.     return parse(0, 0, value, name, name);
  206.     }
  207.  
  208.     // Duplicator
  209.     DispValue *dup() const
  210.     {
  211.     return new DispValue(*this);
  212.     }
  213.  
  214.     // Destructor
  215.     virtual ~DispValue()
  216.     {
  217.     assert (_links == 0);
  218.     clear();
  219.     }
  220.  
  221.     // Create new reference
  222.     DispValue *link()
  223.     {
  224.     assert(_links > 0);
  225.     _links++;
  226.     return this;
  227.     }
  228.  
  229.     // Kill reference
  230.     void unlink()
  231.     {
  232.     assert(_links > 0);
  233.     if (--_links == 0)
  234.         delete this;
  235.     }
  236.  
  237.     // General resources
  238.     DispValueType type()       const { return mytype; }
  239.     bool enabled()             const { return myenabled; }
  240.     const string& full_name()  const { return myfull_name; }
  241.     const string& name()       const { return print_name; }
  242.     const string& addr()       const { return myaddr; }
  243.     int repeats()              const { return myrepeats; }
  244.     bool has_plot_alignment()  const { return _has_plot_alignment; }
  245.  
  246.     int& repeats()       { clear_cached_box(); return myrepeats; }
  247.     string& full_name()  { clear_cached_box(); return myfull_name; }
  248.     string& name()       { clear_cached_box(); return print_name; }
  249.     bool& enabled()      { clear_cached_box(); return myenabled; }
  250.     bool& has_plot_alignment() { return _has_plot_alignment; }
  251.  
  252.     bool is_changed() const { return changed; }
  253.     bool descendant_changed() const;
  254.     bool expanded()   const { return myexpanded; }
  255.     bool collapsed()  const { return !expanded(); }
  256.  
  257.     // Return height of entire tree
  258.     int height() const;
  259.  
  260.     // Return height of expanded tree
  261.     int heightExpanded() const;
  262.  
  263.  
  264.     // Type-specific resources
  265.  
  266.     // Simple or Pointer
  267.     const string& value() const { return _value; }
  268.     
  269.     // Pointer
  270.     bool dereferenced() const { return _dereferenced; }
  271.     string dereferenced_name() const;
  272.  
  273.     // Array, Struct, List, Sequence ...
  274.     int nchildren() const { return _children.size(); }
  275.     DispValue *child(int i) const { return _children[i]; }
  276.     int nchildren_with_repeats() const;
  277.  
  278.     // General modifiers
  279.  
  280.     // Expand/collapse entire tree.  If DEPTH is non-negative, expand
  281.     // DEPTH levels only.  If DEPTH is negative, expand all.
  282.     void collapseAll(int depth = -1);
  283.     void expandAll(int depth = -1);
  284.  
  285.     // Custom calls
  286.     void collapse() { collapseAll(1); }
  287.     void expand()   { expandAll(1); }
  288.  
  289.     // Count expanded or selected nodes in tree
  290.     int expandedAll()  const;
  291.     int collapsedAll() const;
  292.  
  293.     // Type-specific modifiers
  294.  
  295.     // Array
  296.     void set_alignment(DispValueAlignment alignment);
  297.  
  298.     bool vertical_aligned()   const { return _alignment == Vertical; }
  299.     bool horizontal_aligned() const { return _alignment == Horizontal; }
  300.     void align_vertical()     { set_alignment(Vertical); }
  301.     void align_horizontal()   { set_alignment(Horizontal); }
  302.  
  303.     // Pointer
  304.     void dereference(bool set = true)
  305.     {
  306.     if (_dereferenced == set)
  307.         return;
  308.  
  309.     _dereferenced = set;
  310.     clear_cached_box();
  311.     }
  312.  
  313.     // Updating
  314.  
  315.     // Update values from VALUE.  Set WAS_CHANGED iff value changed;
  316.     // Set WAS_INITIALIZED iff type changed.  If TYPE is given, use
  317.     // TYPE as type instead of inferring it.  Note: THIS can no more
  318.     // be referenced after calling this function; use the returned
  319.     // value instead.
  320.     DispValue *update(string& value, bool& was_changed, bool& was_initialized,
  321.               DispValueType type = UnknownType);
  322.  
  323.     // Update values from SOURCE.  Set WAS_CHANGED iff value changed;
  324.     // Set WAS_INITIALIZED iff type changed.  Note: Neither THIS nor
  325.     // SOURCE can be referenced after calling this function; use the
  326.     // returned value instead.
  327.     DispValue *update(DispValue *source, 
  328.               bool& was_changed, bool& was_initialized);
  329.  
  330.     // Return true iff SOURCE and this are structurally equal.
  331.     // If SOURCE_DESCENDANT (a descendant of SOURCE) is not 0,
  332.     // return its equivalent descendant of this in DESCENDANT.
  333.     bool structurally_equal(const DispValue *source,
  334.                 const DispValue *source_descendant,
  335.                 const DispValue *&descendant) const;
  336.  
  337.     // Short version
  338.     bool structurally_equal(const DispValue *source) const
  339.     {
  340.     const DispValue *dummy = 0;
  341.     return structurally_equal(source, 0, dummy);
  342.     }
  343.  
  344.     // Plotting
  345.  
  346.     // Return 0 if we cannot plot; return number of required
  347.     // dimensions, otherwise (1, 2, or 3)
  348.     int can_plot() const;
  349.  
  350.     // Plot value
  351.     void plot() const;
  352.  
  353.     // Replot value
  354.     void replot() const;
  355.  
  356.     // Current plot agent
  357.     PlotAgent *plotter() const { return _plotter; }
  358.  
  359.     // Show plot state
  360.     void set_plot_state(const string& state = "") const;
  361.  
  362.     // Background processing.  PROCESSED is the number of characters
  363.     // processed so far.  If this returns true, abort operation.
  364.     static bool (*background)(int processed);
  365.  
  366.     // Clear cache of all types read so far
  367.     static void clear_type_cache();
  368.  
  369.     // Hook for inserting previously computed DispValues
  370.     static DispValue *(*value_hook)(string& value);
  371.  
  372.     // Box cache
  373.     Box *cached_box() const
  374.     {
  375.     return _cached_box;
  376.     }
  377.  
  378.     // Verify if cached box is recent respective to children's caches
  379.     void validate_box_cache();
  380.  
  381.     void set_cached_box(Box *value)
  382.     {
  383.     clear_cached_box();
  384.     _cached_box = value->link();
  385.     _cached_box_change = cached_box_tics++;
  386.     }
  387.  
  388.     // Print plots to FILENAME
  389.     void print_plots(const string& filename, 
  390.              const PrintGC& gc = PostScriptPrintGC()) const;
  391.  
  392.     // Return a title for NAME
  393.     static string make_title(const string& name);
  394. };
  395.  
  396. #endif // _DDD_DispValue_h
  397. // DON'T ADD ANYTHING BEHIND THIS #endif
  398.