include/core/instance.hpp

   1 #ifndef _instance__hpp__included__
   2 #define _instance__hpp__included__
   3
   4 #include "library/threads.hpp"
   5
   6 class movie_logic;
   7 class memory_space;
   8 class memwatch_set;
   9 class voice_commentary;
  10 class subtitle_commentary;
  11 class movie_branches;
  12 class multitrack_edit;
  13 class _lsnes_status;
  14 class alias_binds_manager;
  15 class rrdata;
  16 class cart_mappings_refresher;
  17 class controller_state;
  18 class project_state;
  19 class debug_context;
  20 class framerate_regulator;
  21 class emu_framebuffer;
  22 class input_queue;
  23 class master_dumper;
  24 class button_mapping;
  25 class emulator_dispatch;
  26 class slotinfo_cache;
  27 class lua_state;
  28 class audioapi_instance;
  29 class loaded_rom;
  30 class save_jukebox;
  31 class emulator_runmode;
  32 class status_updater;
  33 namespace command { class group; }
  34 namespace lua { class state; }
  35 namespace settingvar { class group; }
  36 namespace settingvar { class cache; }
  37 namespace keyboard { class keyboard; }
  38 namespace keyboard { class mapper; }
  39 namespace triplebuffer { template<typename T> class triplebuffer; }
  40
  41 class dtor_list
  42 {
  43         struct entry
  44         {
  45                 void* ptr;
  46                 void (*free1)(void* ptr);
  47                 void (*free2)(void* ptr);
  48                 entry* prev;
  49         };
  50 public:
  51         dtor_list();
  52         ~dtor_list();
  53         void destroy();
  54         template<typename T> void prealloc(T*& ptr)
  55         {
  56                 entry e;
  57                 e.ptr = ptr = reinterpret_cast<T*>(new char[sizeof(T) + 32]);
  58                 memset(ptr, 0, sizeof(T) + 32);
  59                 e.free1 = null;
  60                 e.free2 = free2;
  61                 e.prev = list;
  62                 list = new entry(e);
  63         }
  64         template<typename T, typename... U> void init(T*& ptr, U&... args)
  65         {
  66                 if(ptr) {
  67                         //Find the entry.
  68                         entry* e = list;
  69                         while(e->ptr != ptr)
  70                                 e = e->prev;
  71                         new(ptr) T(args...);
  72                         e->free1 = free1_p<T>;
  73                 } else {
  74                         entry e;
  75                         e.ptr = ptr = new T(args...);
  76                         e.free1 = free1<T>;
  77                         e.free2 = null;
  78                         e.prev = list;
  79                         list = new entry(e);
  80                 }
  81         }
  82 private:
  83         entry* list;
  84         static void null(void* ptr) {}
  85         static void free2(void* ptr) { delete[] reinterpret_cast<char*>(ptr); }
  86         template<typename T> static void free1(void* ptr) { delete reinterpret_cast<T*>(ptr); }
  87         template<typename T> static void free1_p(void* ptr) { reinterpret_cast<T*>(ptr)->~T(); }
  88 };
  89
  90 struct emulator_instance
  91 {
  92         emulator_instance();
  93         ~emulator_instance();
  94         emulator_dispatch* dispatch;
  95         movie_logic* mlogic;
  96         memory_space* memory;
  97         lua::state* lua;
  98         lua_state* lua2;
  99         memwatch_set* mwatch;
 100         settingvar::group* settings;
 101         settingvar::cache* setcache;
 102         voice_commentary* commentary;
 103         subtitle_commentary* subtitles;
 104         movie_branches* mbranch;
 105         controller_state* controls;
 106         button_mapping* buttons;
 107         multitrack_edit* mteditor;
 108         _lsnes_status* status_A;
 109         _lsnes_status* status_B;
 110         _lsnes_status* status_C;
 111         triplebuffer::triplebuffer<_lsnes_status>* status;
 112         keyboard::keyboard* keyboard;
 113         command::group* command;
 114         keyboard::mapper* mapper;
 115         alias_binds_manager* abindmanager;
 116         rrdata* nrrdata;
 117         cart_mappings_refresher* cmapper;
 118         project_state* project;
 119         debug_context* dbg;
 120         framerate_regulator* framerate;
 121         emu_framebuffer* fbuf;
 122         input_queue* iqueue;
 123         master_dumper* mdumper;
 124         slotinfo_cache* slotcache;
 125         audioapi_instance* audio;
 126         loaded_rom* rom;
 127         save_jukebox* jukebox;
 128         emulator_runmode* runmode;
 129         status_updater* supdater;
 130         threads::id emu_thread;
 131         time_t random_seed_value;
 132         dtor_list D;
 133 private:
 134         emulator_instance(const emulator_instance&);
 135         emulator_instance& operator=(const emulator_instance&);
 136 };
 137
 138 extern emulator_instance lsnes_instance;
 139
 140 emulator_instance& CORE();
 141
 142 #endif