include/library/memorywatch.hpp

   1 #ifndef _library__memorywatch__hpp__included__
   2 #define _library__memorywatch__hpp__included__
   3
   4 #include "mathexpr.hpp"
   5 #include <functional>
   6 #include <list>
   7 #include <set>
   8 #include <map>
   9
  10 class memory_space;
  11
  12 namespace memorywatch
  13 {
  14 /**
  15  * Read memory operator.
  16  */
  17 struct memread_oper : public mathexpr::operinfo
  18 {
  19 /**
  20  * Ctor
  21  */
  22         memread_oper();
  23 /**
  24  * Dtor
  25  */
  26         ~memread_oper();
  27 /**
  28  * Evaluate the operator.
  29  *
  30  * Note: The first promise is for the address.
  31  */
  32         void evaluate(mathexpr::value target, std::vector<std::function<mathexpr::value()>> promises);
  33         //Fields.
  34         unsigned bytes;         //Number of bytes to read.
  35         bool signed_flag;       //Is signed?
  36         bool float_flag;        //Is float?
  37         int endianess;          //Endianess (-1 => little, 0 => host, 1 => Big).
  38         uint64_t scale_div;     //Scale divisor.
  39         uint64_t addr_base;     //Address base.
  40         uint64_t addr_size;     //Address size (0 => All).
  41         memory_space* mspace;   //Memory space to read.
  42 };
  43
  44 /**
  45  * Memory watch item printer.
  46  */
  47 struct item_printer : public GC::item
  48 {
  49 /**
  50  * Dtor.
  51  */
  52         virtual ~item_printer();
  53 /**
  54  * Show the watched value.
  55  */
  56         virtual void show(const std::string& iname, const std::string& val) = 0;
  57 /**
  58  * Reset the printer.
  59  */
  60         virtual void reset() = 0;
  61 protected:
  62         void trace();
  63 };
  64
  65 /**
  66  * Memory watch item.
  67  */
  68 struct item
  69 {
  70 /**
  71  * Ctor.
  72  *
  73  * Parameter t: The type of the result.
  74  */
  75         item(mathexpr::typeinfo& t)
  76                 : expr(GC::obj_tag(), &t)
  77         {
  78         }
  79 /**
  80  * Get the value as string.
  81  */
  82         std::string get_value();
  83 /**
  84  * Print the value to specified printer.
  85  *
  86  * Parameter iname: The name of the watch.
  87  */
  88         void show(const std::string& iname);
  89         //Fields.
  90         GC::pointer<item_printer> printer;              //Printer to use.
  91         GC::pointer<mathexpr::mathexpr> expr;   //Expression to watch.
  92         std::string format;                             //Formatting to use.
  93 };
  94
  95 /**
  96  * A set of memory watches.
  97  */
  98 struct set
  99 {
 100 /**
 101  * Dtor.
 102  */
 103         ~set();
 104 /**
 105  * Call reset on all items and their printers in the set.
 106  */
 107         void reset();
 108 /**
 109  * Call reset and then show on all items in the set.
 110  */
 111         void refresh();
 112 /**
 113  * Get the longest name (by UTF-8 length) in the set.
 114  *
 115  * Returns: The longest nontrivial name, or "" if none.
 116  */
 117         const std::string& get_longest_name()
 118         {
 119                 return get_longest_name(set::utflength_rate);
 120         }
 121 /**
 122  * Get the longest name (by arbitrary function) in the set.
 123  *
 124  * Parameter rate: Get length for name function.
 125  * Returns: The longest nontrivial name, or "" if none.
 126  */
 127         const std::string& get_longest_name(std::function<size_t(const std::string& n)> rate);
 128 /**
 129  * Get the set of memory watch names.
 130  */
 131         std::set<std::string> names_set();
 132 /**
 133  * Get specified memory watch item.
 134  *
 135  * Parameter name: The name of the item.
 136  * Returns: The item.
 137  * Throws std::runtime_error: No such item in set.
 138  */
 139         item& get(const std::string& name);
 140 /**
 141  * Get specified memory watch item (without throwing).
 142  *
 143  * Parameter name: The name of the item.
 144  * Returns: The item, or NULL if no such item exists.
 145  */
 146         item* get_soft(const std::string& name);
 147 /**
 148  * Create a new memory watch item.
 149  *
 150  * Parameter name: The name of the new item.
 151  * Parameter item: The new item. All fields are shallow-copied.
 152  */
 153         item* create(const std::string& name, item& item);
 154 /**
 155  * Destroy a memory watch item.
 156  *
 157  * Parameter name: The name of the item to destroy.
 158  */
 159         void destroy(const std::string& name);
 160 /**
 161  * Call routine for all roots.
 162  */
 163         void foreach(std::function<void(item& item)> cb);
 164 /**
 165  * Swap set with another.
 166  */
 167         void swap(set& s) throw();
 168 private:
 169         static size_t utflength_rate(const std::string& s);
 170         std::map<std::string, item> roots;
 171 };
 172 }
 173
 174 #endif