include/core/memorywatch.hpp

   1 #ifndef _memorywatch__hpp__included__
   2 #define _memorywatch__hpp__included__
   3
   4 #include <string>
   5 #include <stdexcept>
   6 #include <set>
   7 #include "library/memorywatch.hpp"
   8 #include "library/json.hpp"
   9
  10 class memory_space;
  11 class project_state;
  12 class emu_framebuffer;
  13
  14 /**
  15  * lsnes memory watch printer variables.
  16  */
  17 struct memwatch_printer
  18 {
  19 /**
  20  * Ctor.
  21  */
  22         memwatch_printer();
  23 /**
  24  * Serialize the printer to JSON value.
  25  */
  26         JSON::node serialize();
  27 /**
  28  * Unserialize the printer from JSON value.
  29  */
  30         void unserialize(const JSON::node& node);
  31 /**
  32  * Get a printer object corresponding to this object.
  33  */
  34         gcroot_pointer<memorywatch::item_printer> get_printer_obj(
  35                 std::function<gcroot_pointer<mathexpr::mathexpr>(const std::string& n)> vars);
  36         //Fields.
  37         enum position_category {
  38                 PC_DISABLED,
  39                 PC_MEMORYWATCH,
  40                 PC_ONSCREEN
  41         } position;
  42         bool cond_enable;                       //Ignored for disabled.
  43         std::string enabled;                    //Ignored for disabled.
  44         std::string onscreen_xpos;
  45         std::string onscreen_ypos;
  46         bool onscreen_alt_origin_x;
  47         bool onscreen_alt_origin_y;
  48         bool onscreen_cliprange_x;
  49         bool onscreen_cliprange_y;
  50         std::string onscreen_font;              //"" is system default.
  51         int64_t onscreen_fg_color;
  52         int64_t onscreen_bg_color;
  53         int64_t onscreen_halo_color;
  54 };
  55
  56 /**
  57  * lsnes memory watch item.
  58  */
  59 struct memwatch_item
  60 {
  61 /**
  62  * Ctor.
  63  */
  64         memwatch_item(memory_space& memory);
  65 /**
  66  * Serialize the item to JSON value.
  67  */
  68         JSON::node serialize();
  69 /**
  70  * Unserialize the item from JSON value.
  71  */
  72         void unserialize(const JSON::node& node);
  73 /**
  74  * Get memory read operator.
  75  *
  76  * If bytes == 0, returns NULL.
  77  */
  78         memorywatch::memread_oper* get_memread_oper();
  79 /**
  80  * Translate compatiblity item.
  81  */
  82         void compatiblity_unserialize(memory_space& memory, const std::string& item);
  83         //Fields
  84         memwatch_printer printer;       //The printer.
  85         std::string expr;                       //The main expression.
  86         std::string format;                     //Format.
  87         unsigned bytes;                         //Number of bytes to read (0 => Not memory read operator).
  88         bool signed_flag;                       //Is signed?
  89         bool float_flag;                        //Is float?
  90         int endianess;                          //Endianess (-1 => little, 0 => host, 1 => Big).
  91         uint64_t scale_div;                     //Scale divisor.
  92         uint64_t addr_base;                     //Address base.
  93         uint64_t addr_size;                     //Address size (0 => All).
  94         memory_space* mspace;                   //Memory space to read.
  95 };
  96
  97 struct memwatch_set
  98 {
  99         memwatch_set(memory_space& _memory, project_state& _project, emu_framebuffer& _fbuf);
 100 /**
 101  * Get the specified memory watch item.
 102  */
 103         memwatch_item& get(const std::string& name);
 104 /**
 105  * Get the specified memory watch item as JSON serialization.
 106  *
 107  * Parameter name: The item name.
 108  * Parameter printer: JSON pretty-printer to use.
 109  */
 110         std::string get_string(const std::string& name, JSON::printer* printer = NULL);
 111 /**
 112  * Set the specified memory watch item. Fills the runtime variables.
 113  *
 114  * Parameter name: The name of the new item.
 115  * Parameter item: The item to insert. Fields are shallow-copied.
 116  */
 117         void set(const std::string& name, memwatch_item& item);
 118 /**
 119  * Set the specified memory watch item from JSON serialization. Fills the runtime variables.
 120  *
 121  * Parameter name: The name of the new item.
 122  * Parameter item: The serialization of item to insert.
 123  */
 124         void set(const std::string& name, const std::string& item);
 125 /**
 126  * Set multiple items at once.
 127  *
 128  * Parameter list: The list of items.
 129  */
 130         void set_multi(std::list<std::pair<std::string, memwatch_item>>& list);
 131 /**
 132  * Set multiple items at once from JSON descriptions.
 133  *
 134  * Parameter list: The list of items.
 135  */
 136         void set_multi(std::list<std::pair<std::string, std::string>>& list);
 137 /**
 138  * Rename a memory watch item.
 139  *
 140  * Parameter oname: The old name.
 141  * Parameter newname: The new name.
 142  * Returns: True on success, false if failed (new item already exists).
 143  */
 144         bool rename(const std::string& oname, const std::string& newname);
 145 /**
 146  * Delete an item.
 147  *
 148  * Parameter name: The name of the item to delete.
 149  */
 150         void clear(const std::string& name);
 151 /**
 152  * Delete multiple items.
 153  *
 154  * Parameter names: The names of the items to delete.
 155  */
 156         void clear_multi(const std::set<std::string>& name);
 157 /**
 158  * Enumerate item names.
 159  */
 160         std::set<std::string> enumerate();
 161 /**
 162  * Get value of specified memory watch as a string.
 163  */
 164         std::string get_value(const std::string& name);
 165 /**
 166  * Watch all the items.
 167  *
 168  * Parameter rq: The render queue to use.
 169  */
 170         void watch(struct framebuffer::queue& rq);
 171 /**
 172  * Get memory watch vars that go to window.
 173  */
 174         const std::map<std::string, std::u32string>& get_window_vars() { return window_vars; }
 175 private:
 176         void rebuild(std::map<std::string, memwatch_item>& nitems);
 177         std::map<std::string, memwatch_item> items;
 178         std::map<std::string, std::u32string> window_vars;
 179         std::map<std::string, bool> used_memorywatches;
 180         void erase_unused_watches();
 181         void watch_output(const std::string& name, const std::string& value);
 182         memorywatch::set watch_set;
 183         memory_space& memory;
 184         project_state& project;
 185         emu_framebuffer& fbuf;
 186 };
 187
 188 #endif