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