include/core/instance.hpp

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