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