v1.6.1: CPU refactor, dark mode, memory API change

0) Bumped version to 1.6.1
1) EvmuMemory
    - internal BUS => data BUS
    - external BUS => program BUS
    - shitloads of files changed due to this API change
    - began work on vtable structure
    - SHITLOADS of planned signals
2) evmu_address_space.h
    - documented USER-side input variables to subroutines
3) EvmuCpu
    - full refactor
    ! still needs signals
    - Pipeline stages are now virtual functions
    - signal fires for "pcChange" every instruction execution
4) EvmuLcd
    - public toggle members became combined bitfields
    - added field and property for "invertColors" aka Dark Mode
5) EvmuRom
    - unloadBios() to go from external Sega BIOS to internal emulated
      BIOS
6) evmu_test_main.c
    - returning C standard EXIT_SUCCESS/EXIT_FAILURE
7) Syncing libGimbal

CMakeLists.txt

@@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.10)
 
 set(EVMU_VERSION_MAJOR 1)
 set(EVMU_VERSION_MINOR 6)
-set(EVMU_VERSION_PATCH 0)
+set(EVMU_VERSION_PATCH 1)
 set(EVMU_VERSION
     ${EVMU_VERSION_MAJOR}.${EVMU_VERSION_MINOR}.${EVMU_VERSION_PATCH})
 

legacy/source/gyro_vmu_device.c

@@ -93,7 +93,7 @@ int gyVmuDeviceLoadState(VMUDevice* dev, const char *path) {
             dev->pFlashUserData = pFlashUserData;
             dev->pFnFlashChange = pFnFlashChange;
 
-            switch(EvmuMemory_viewInt(pDevice->pMemory, EVMU_ADDRESS_SFR_EXT)) {
+            switch(EvmuMemory_viewData(pDevice->pMemory, EVMU_ADDRESS_SFR_EXT)) {
             case EVMU_SFR_EXT_ROM:
                 pMemory_->pExt = pMemory_->rom;
                 break;

legacy/wrappers/cpp/include/evmu-core-cpp/evmu_device.hpp

@@ -245,19 +245,19 @@ inline VmuDevice::operator VMUDevice*(void) const {
 
 inline uint8_t VmuDevice::viewMemoryByte(EvmuAddress address) const {
     return address < VMU_MEM_ADDR_SPACE_RANGE?
-                EvmuMemory_viewInt(EVMU_DEVICE_PRISTINE_PUBLIC(_dev)->pMemory, address):
+                EvmuMemory_viewData(EVMU_DEVICE_PRISTINE_PUBLIC(_dev)->pMemory, address):
                 ELYSIAN_VMU_READ_INVALID_VALUE;
 }
 
 inline uint8_t VmuDevice::readMemoryByte(uint16_t address) const {
     return address < VMU_MEM_ADDR_SPACE_RANGE?
-                EvmuMemory_readInt(EVMU_DEVICE_PRISTINE_PUBLIC(_dev)->pMemory, address):
+                EvmuMemory_readData(EVMU_DEVICE_PRISTINE_PUBLIC(_dev)->pMemory, address):
                 ELYSIAN_VMU_READ_INVALID_VALUE;
 }
 
 inline bool VmuDevice::writeMemoryByte(uint16_t address, uint8_t value) const {
     if(address < VMU_MEM_ADDR_SPACE_RANGE) {
-        EvmuMemory_writeInt(EVMU_DEVICE_PRISTINE_PUBLIC(_dev)->pMemory, address, value);
+        EvmuMemory_writeData(EVMU_DEVICE_PRISTINE_PUBLIC(_dev)->pMemory, address, value);
         return true;
     } else return false;
 }

lib/api/evmu/hw/evmu_address_space.h

@@ -65,12 +65,20 @@ extern "C" {
 #define EVMU_ADDRESS_SYSTEM_CURSOR_POS_ROW  0x61    // cursor position, row (0-3)
 #define EVMU_ADDRESS_SYSTEM_GAME_LAST_BLK   0x6d    // Last block used by mini-game
 #define EVMU_ADDRESS_SYSTEM_BATTERY_CHECK   0x6e    // Battery check flag (0xff - disable auto battery check, 0x00 - enable auto battery check)
-//      UNKNOWN [17 bytes]             0x6f-0x7f    // Other BIOS magical shit?
+//      UNKNOWN [17 bytes]             0x6f-0x7f    // Other BIOS magical shit?    
 //-------------------- Stack Storage --------------------
 #define EVMU_ADDRESS_SYSTEM_STACK_BASE      0x80     // First entry for stack storage
 //      STACK STORAGE [126 BYTES]      0x81-0xfe     // Generic storage on the stack
 #define EVMU_ADDRESS_SYSTEM_STACK_END       0xff     // Last entry for stack storage
 
+//==================== BIOS INPUT VARIABLES (RAM BANK 1) =====================
+#define EVMU_ADDRESS_USER_FMBANK            0x7d    // Flash memory read bank address
+#define EVMU_ADDRESS_USER_FMADD_H           0x7e    // Flash memory read start upper address
+#define EVMU_ADDRESS_USER_FMADD_L           0x7f    // Flash memory read start lower address
+#define EVMU_ADDRESS_USER_FM_RET_BASE       0x80    // Flash read/write start address
+#define EVMU_ADDRESS_USER_FM_RET_SIZE       128     // Flash read/write count (128 bytes)
+#define EVMU_ADDRESS_USER_FM_RET_END        0xff    // Flash read/write end address
+
 //==================== SPECIAL FUNCTION REGISTERS ====================
 //-------------------- CPU, Interrupts, Clocks Registers --------------------
 #define EVMU_ADDRESS_SFR_ACC                0x100   // Accumulator

lib/api/evmu/hw/evmu_cpu.h

@@ -1,8 +1,18 @@
+/*! \file
+ *  \brief Sanyo LC86k CPU Core
+ *  \ingroup Peripherals
+ *
+ *  \todo
+ *      - Properties
+ *      - secs per instruction in msec/nsec, not float
+ *      - pull Rom/BIOS update out of CPU update path
+ */
 #ifndef EVMU_CPU_H
 #define EVMU_CPU_H
 
 #include "../types/evmu_peripheral.h"
 #include "evmu_isa.h"
+#include <gimbal/meta/signals/gimbal_signal.h>
 
 #define EVMU_CPU_TYPE                   (GBL_TYPEOF(EvmuCpu))
 #define EVMU_CPU(instance)              (GBL_INSTANCE_CAST(instance, EvmuCpu))
@@ -13,8 +23,27 @@
 
 GBL_DECLS_BEGIN
 
-GBL_CLASS_DERIVE_EMPTY   (EvmuCpu, EvmuPeripheral)
-GBL_INSTANCE_DERIVE_EMPTY(EvmuCpu, EvmuPeripheral)
+GBL_FORWARD_DECLARE_STRUCT(EvmuCpu);
+
+typedef uint16_t EvmuPc;
+
+GBL_CLASS_DERIVE(EvmuCpu, EvmuPeripheral)
+    EVMU_RESULT (*pFnFetch)  (GBL_SELF,
+                              EvmuPc           pc,
+                              EvmuInstruction* pEncoded);
+    EVMU_RESULT (*pFnDecode) (GBL_SELF,
+                              const EvmuInstruction*  pEncoded,
+                              EvmuDecodedInstruction* pDecoded);
+    EVMU_RESULT (*pFnExecute)(GBL_SELF,
+                              const EvmuDecodedInstruction* pInstr);
+    EVMU_RESULT (*pFnRunNext)(GBL_SELF);
+GBL_CLASS_END
+
+GBL_INSTANCE_DERIVE(EvmuCpu, EvmuPeripheral)
+    GblBool halted;
+    GblBool haltAfterNext;
+    GblBool pcChanged;
+GBL_INSTANCE_END
 
 GBL_PROPERTIES(EvmuCpu,
     (pc,                  GBL_GENERIC, (READ, WRITE, LOAD, SAVE), GBL_UINT32_TYPE),
@@ -24,17 +53,23 @@ GBL_PROPERTIES(EvmuCpu,
     (instructionOperand3, GBL_GENERIC, (READ),                    GBL_UINT8_TYPE)
 )
 
+GBL_SIGNALS(EvmuCpu,
+    (pcChange, (GBL_INSTANCE_TYPE, pReceiver), (GBL_UINT16_TYPE, pc))
+)
+
 EVMU_EXPORT GblType     EvmuCpu_type                 (void)                                 GBL_NOEXCEPT;
 
-EVMU_EXPORT EvmuAddress EvmuCpu_pc                   (GBL_CSELF)                            GBL_NOEXCEPT;
-EVMU_EXPORT void        EvmuCpu_setPc                (GBL_SELF, EvmuAddress address)        GBL_NOEXCEPT;
+EVMU_EXPORT EvmuPc      EvmuCpu_pc                   (GBL_CSELF)                            GBL_NOEXCEPT;
+EVMU_EXPORT void        EvmuCpu_setPc                (GBL_SELF, EvmuPc address)             GBL_NOEXCEPT;
 
 EVMU_EXPORT const EvmuDecodedInstruction*
                         EvmuCpu_currentInstruction   (GBL_CSELF)                            GBL_NOEXCEPT;
-EVMU_EXPORT EVMU_RESULT EvmuCpu_execute              (GBL_CSELF,
+
+EVMU_EXPORT EVMU_RESULT EvmuCpu_execute              (GBL_SELF,
                                                       const EvmuDecodedInstruction* pInstr) GBL_NOEXCEPT;
 
-EVMU_EXPORT EvmuAddress EvmuCpu_indirectAddress      (GBL_CSELF, uint8_t indirectMode)      GBL_NOEXCEPT;
+EVMU_EXPORT EVMU_RESULT EvmuCpu_runNext              (GBL_SELF)                             GBL_NOEXCEPT;
+
 EVMU_EXPORT double      EvmuCpu_secsPerInstruction   (GBL_CSELF)                            GBL_NOEXCEPT;
 EVMU_EXPORT GblSize     EvmuCpu_cyclesPerInstruction (GBL_CSELF)                            GBL_NOEXCEPT;
 
@@ -43,21 +78,3 @@ GBL_DECLS_END
 #undef GBL_SELF_TYPE
 
 #endif // EVMU_CPU_H
-
-
-#if 0
-EVMU_EXPORT EVMU_RESULT EvmuCpu_instructionInfo (GBL_CSELF,
-                                                 EvmuDecodedInstruction* pInstruction,
-                                                 EvmuWord*               pIndirectAddress,
-                                                 uint8_t*                pEllapsedCycles)  GBL_NOEXCEPT;
-
-//EVMU_EXPORT EVMU_RESULT EvmuCpu_executeInstruction      (GBL_CSELF,
-//                                                         const EvmuInstruction* pInstruction)   GBL_NOEXCEPT;
-
-EVMU_EXPORT EVMU_RESULT EvmuCpu_executeEncoded  (GBL_CSELF,
-                                                 const EvmuInstruction* pInstr)            GBL_NOEXCEPT;
-
-EVMU_EXPORT EVMU_RESULT EvmuCpu_executeDecoded  (GBL_CSELF,
-                                                 const EvmuDecodedInstruction* pInstr)     GBL_NOEXCEPT;
-#endif
-

lib/api/evmu/hw/evmu_lcd.h

@@ -3,6 +3,8 @@
  *  \ingroup Peripherals
  *  \todo
  *      - Pixel ghosting still needs some work
+ *      - update screen when in sleep mode
+ *      - access/control XRAM bank
  */
 
 #ifndef EVMU_LCD_H
@@ -57,11 +59,11 @@ GBL_CLASS_DERIVE(EvmuLcd, EvmuPeripheral)
 GBL_CLASS_END
 
 GBL_INSTANCE_DERIVE(EvmuLcd, EvmuPeripheral)
-    GblBool screenChanged;
-    GblBool ghostingEnabled;
-    GblBool filterEnabled;
-    GblBool screenSaverEnabled;   ///< Continue updating when display is disabled
     GblSize screenRefreshDivisor; ///< How many hardware refreshes before software refresh
+    uint32_t screenChanged   : 1; ///< User-driven toggle for knowing when to redraw
+    uint32_t ghostingEnabled : 1; ///< Emulate pixel ghosting/fade effect
+    uint32_t filterEnabled   : 1; ///< Enable linear filtering
+    uint32_t invertColors    : 1; ///< Swap black and white pixel values
 GBL_INSTANCE_END
 
 GBL_PROPERTIES(EvmuLcd,
@@ -70,15 +72,14 @@ GBL_PROPERTIES(EvmuLcd,
     (refreshRate,     GBL_GENERIC, (READ, WRITE), GBL_ENUM_TYPE),
     (ghostingEnabled, GBL_GENERIC, (READ, WRITE), GBL_BOOL_TYPE),
     (filterEnabled,   GBL_GENERIC, (READ, WRITE), GBL_BOOL_TYPE),
+    (invertColors,    GBL_GENERIC, (READ, WRITE), GBL_BOOL_TYPE),
     (icons,           GBL_GENERIC, (READ, WRITE), GBL_FLAGS_TYPE)
 )
 
 GBL_SIGNALS(EvmuLcd,
     (screenRefresh, (GBL_INSTANCE_TYPE, pReceiver)),
-    (screenToggle,  (GBL_INSTANCE_TYPE, pReceiver),
-                    (GBL_BOOL_TYPE,     enabled)),
-    (iconsChange,   (GBL_INSTANCE_TYPE, pReceiver),
-                    (GBL_FLAGS_TYPE,    flags))
+    (screenToggle,  (GBL_INSTANCE_TYPE, pReceiver), (GBL_BOOL_TYPE,  enabled)),
+    (iconsChange,   (GBL_INSTANCE_TYPE, pReceiver), (GBL_FLAGS_TYPE, flags))
 )
 
 EVMU_EXPORT GblType   EvmuLcd_type              (void)                                 GBL_NOEXCEPT;

lib/api/evmu/hw/evmu_memory.h

@@ -3,6 +3,7 @@
 
 #include "../types/evmu_peripheral.h"
 #include "../hw/evmu_sfr.h"
+#include <gimbal/meta/signals/gimbal_signal.h>
 
 #define EVMU_MEMORY_TYPE                (GBL_TYPEOF(EvmuMemory))
 #define EVMU_MEMORY_NAME                "FIXME"
@@ -15,15 +16,7 @@
 
 GBL_DECLS_BEGIN
 
-GBL_DECLARE_ENUM(EVMU_MEMORY_SEGMENT) {
-    EVMU_MEMORY_SEGMENT_RAM,
-    EVMU_MEMORY_SEGMENT_SFR,
-    EVMU_MEMORY_SEGMENT_XRAM,
-    EVMU_MEMORY_SEGMENT_WRAM,
-    EVMU_MEMORY_SEGMENT_ROM,
-    EVMU_MEMORY_SEGMENT_FLASH,
-    EVMU_MEMORY_SEGMENT_COUNT
-};
+GBL_FORWARD_DECLARE_STRUCT(EvmuMemory);
 
 GBL_DECLARE_ENUM(EVMU_MEMORY_BANK) {
     EVMU_MEMORY_BANK_INVALID,
@@ -45,13 +38,48 @@ GBL_DECLARE_ENUM(EVMU_MEMORY_EXT_SRC) {
     EVMU_MEMORY_EXT_SRC_FLASH_BANK_1 = EVMU_SFR_EXT_FLASH_BANK_1
 };
 
-GBL_CLASS_DERIVE_EMPTY   (EvmuMemory, EvmuPeripheral)
-GBL_INSTANCE_DERIVE_EMPTY(EvmuMemory, EvmuPeripheral)
+GBL_CLASS_DERIVE(EvmuMemory, EvmuPeripheral)
+    EVMU_RESULT (*pFnReadData)      (GBL_CSELF, EvmuAddress addr, EvmuWord* pValue);
+    EVMU_RESULT (*pFnReadDataLatch) (GBL_CSELF, EvmuAddress addr, EvmuWord* pValue);
+    EVMU_RESULT (*pFnWriteData)     (GBL_SELF, EvmuAddress addr, EvmuWord value);
+    EVMU_RESULT (*pFnWriteDataLatch)(GBL_SELF, EvmuAddress addr, EvmuWord value);
+    EVMU_RESULT (*pFnReadProgram)   (GBL_CSELF, EvmuAddress addr, EvmuWord* pValue);
+    EVMU_RESULT (*pFnWriteProgram)  (GBL_SELF, EvmuAddress addr, EvmuWord value);
+    EVMU_RESULT (*pFnReadFlash)     (GBL_CSELF, EvmuAddress addr, EvmuWord* pValue);
+    EVMU_RESULT (*pFnWriteFlash)    (GBL_SELF, EvmuAddress addr, EvmuWord value);
+GBL_CLASS_END
+
+GBL_INSTANCE_DERIVE(EvmuMemory, EvmuPeripheral)
+    uint32_t ramChanged   : 1;
+    uint32_t sfrChanged   : 1;
+    uint32_t xramChanged  : 1;
+    uint32_t flashChanged : 1;
+    uint32_t romChanged   : 1;
+    uint32_t wramChanged  : 1;
+GBL_INSTANCE_END
 
 GBL_PROPERTIES(EvmuMemory,
-    (stackPointer, GBL_GENERIC, (READ), GBL_UINT8_TYPE),
-    (extBusSource, GBL_GENERIC, (READ), GBL_ENUM_TYPE),
-    (intBusSource, GBL_GENERIC, (READ), GBL_ENUM_TYPE)
+    (ramBank,        GBL_GENERIC, (READ, WRITE), GBL_ENUM_TYPE),
+    (xramBank,       GBL_GENERIC, (READ, WRITE), GBL_ENUM_TYPE),
+    (programSource,  GBL_GENERIC, (READ, WRITE), GBL_ENUM_TYPE),
+    (stackPointer,   GBL_GENERIC, (READ),        GBL_UINT8_TYPE),
+    (vselIncrement,  GBL_GENERIC, (READ, WRITE), GBL_BOOL_TYPE),
+    (vrmad,          GBL_GENERIC, (READ, WRITE), GBL_UINT16_TYPE),
+    (vtrbf,          GBL_GENERIC, (READ, WRITE), GBL_UINT8_TYPE)
+)
+
+GBL_SIGNALS(EvmuMemory,
+    (ramValueChange,      (GBL_INSTANCE_TYPE, pReceiver), (GBL_UINT32_TYPE, address), (GBL_ENUM_TYPE, bank)),
+    (ramBankChange,       (GBL_INSTANCE_TYPE, pReceiver), (GBL_ENUM_TYPE, bank)),
+    (sfrValueChange,      (GBL_INSTANCE_TYPE, pReceiver), (GBL_UINT32_TYPE, address)),
+    (xramValueChange,     (GBL_INSTANCE_TYPE, pReceiver), (GBL_UINT32_TYPE, address), (GBL_ENUM_TYPE, bank)),
+    (xramBankChange,      (GBL_INSTANCE_TYPE, pReceiver), (GBL_ENUM_TYPE, bank)),
+    (flashValueChange,    (GBL_INSTANCE_TYPE, pReceiver), (GBL_UINT32_TYPE, address)),
+    (romValueChange,      (GBL_INSTANCE_TYPE, pReceiver), (GBL_UINT32_TYPE, address)),
+    (programSourceChange, (GBL_INSTANCE_TYPE, pReceiver), (GBL_BOOL_TYPE, flash)),
+    (wramValueChange,     (GBL_INSTANCE_TYPE, pReceiver), (GBL_UINT32_TYPE, address)),
+    (stackPush,           (GBL_INSTANCE_TYPE, pReceiver), (GBL_UINT8_TYPE, value)),
+    (stackPop,            (GBL_INSTANCE_TYPE, pReceiver))
 )
 
 EVMU_EXPORT GblType     EvmuMemory_type         (void)                        GBL_NOEXCEPT;
@@ -60,31 +88,36 @@ EVMU_EXPORT EvmuAddress EvmuMemory_indirectAddress
                                                 (GBL_CSELF, uint8_t mode)     GBL_NOEXCEPT;
 
 // Read/write into internal RAM address space (RAM, SFRs, XRAM)
-EVMU_EXPORT EvmuWord    EvmuMemory_readInt      (GBL_CSELF, EvmuAddress addr) GBL_NOEXCEPT;
-EVMU_EXPORT EvmuWord    EvmuMemory_readIntLatch (GBL_CSELF, EvmuAddress addr) GBL_NOEXCEPT;
-EVMU_EXPORT EvmuWord    EvmuMemory_viewInt      (GBL_CSELF, EvmuAddress addr) GBL_NOEXCEPT;
+EVMU_EXPORT EvmuWord    EvmuMemory_readData      (GBL_CSELF, EvmuAddress addr) GBL_NOEXCEPT;
+EVMU_EXPORT EvmuWord    EvmuMemory_readDataLatch (GBL_CSELF, EvmuAddress addr) GBL_NOEXCEPT;
+EVMU_EXPORT EvmuWord    EvmuMemory_viewData      (GBL_CSELF, EvmuAddress addr) GBL_NOEXCEPT;
 
-EVMU_EXPORT EVMU_RESULT EvmuMemory_writeInt     (GBL_SELF,
-                                                 EvmuAddress address,
-                                                 EvmuWord    value)           GBL_NOEXCEPT;
+EVMU_EXPORT EVMU_RESULT EvmuMemory_writeData     (GBL_SELF,
+                                                  EvmuAddress address,
+                                                  EvmuWord    value)           GBL_NOEXCEPT;
+
+EVMU_EXPORT EVMU_RESULT EvmuMemory_writeDataLatch    (GBL_SELF,
+                                                  EvmuAddress address,
+                                                  EvmuWord    value)           GBL_NOEXCEPT;
 
 // External addres space (ROM/Flash)
-EVMU_EXPORT EvmuWord    EvmuMemory_readExt      (GBL_CSELF, EvmuAddress addr) GBL_NOEXCEPT;
+EVMU_EXPORT EvmuWord    EvmuMemory_readProgram      (GBL_CSELF, EvmuAddress addr) GBL_NOEXCEPT;
 
-EVMU_EXPORT EVMU_RESULT EvmuMemory_writeExt     (GBL_SELF,
+EVMU_EXPORT EVMU_RESULT EvmuMemory_writeProgram     (GBL_SELF,
                                                  EvmuAddress addr,
                                                  EvmuWord    value)           GBL_NOEXCEPT;
 
 EVMU_EXPORT EVMU_MEMORY_EXT_SRC
-                        EvmuMemory_extSource    (GBL_CSELF)                   GBL_NOEXCEPT;
-EVMU_EXPORT EVMU_RESULT EvmuMemory_setExtSource (GBL_SELF,
+                        EvmuMemory_programSource    (GBL_CSELF)                   GBL_NOEXCEPT;
+EVMU_EXPORT EVMU_RESULT EvmuMemory_setProgramSource (GBL_SELF,
                                                  EVMU_MEMORY_EXT_SRC src)     GBL_NOEXCEPT;
 
 EVMU_EXPORT EvmuWord    EvmuMemory_readFlash    (GBL_CSELF, EvmuAddress addr) GBL_NOEXCEPT;
 
 EVMU_EXPORT EVMU_RESULT EvmuMemory_writeFlash   (GBL_SELF,
                                                  EvmuAddress addr,
                                                  EvmuWord    value)           GBL_NOEXCEPT;
+//READ/WRITE ROM
 
 EVMU_EXPORT int         EvmuMemory_stackDepth   (GBL_CSELF)                   GBL_NOEXCEPT;
 EVMU_EXPORT EvmuWord    EvmuMemory_viewStack    (GBL_CSELF, GblSize depth)    GBL_NOEXCEPT;

lib/api/evmu/hw/evmu_rom.h

@@ -5,7 +5,7 @@
  *  \todo
  *      - CLEAN UP IMPLEMENTATION IN GENERAL
  *      - remove "reestDevice" references (pending Flash updates get moved)
- *      - EvmuRom_setBiosMode()
+ *      - EvmuRom_setBiosMode() (set mode button then jump to Colton's address?)
  *      - EvmuRom["biosMode"]: R/W
  *      - EvmuRom["dateTime"]: R/W (pending on ISO8601 in Gimbal)
  *      - Maybe signal when entering/exiting BIOS
@@ -65,7 +65,7 @@ GBL_DECLARE_ENUM(EVMU_BIOS_MODE) {
     EVMU_BIOS_MODE_GAME,    ///< Game/Application mode
     EVMU_BIOS_MODE_TIME,    ///< Clock/time mode
     EVMU_BIOS_MODE_MAPLE,   ///< Connected to DC, Maple slave mode
-    EVMU_BIOS_MODE_UNKNOWN, ///< Unnknown mode (unknown BIOS)
+    EVMU_BIOS_MODE_UNKNOWN, ///< Unknown mode (unknown BIOS)
     EVMU_BIOS_MODE_COUNT    ///< Number of BIOS modes
 };
 
@@ -90,6 +90,7 @@ EVMU_EXPORT EVMU_BIOS_TYPE EvmuRom_biosType      (GBL_CSELF)
 EVMU_EXPORT EVMU_BIOS_MODE EvmuRom_biosMode      (GBL_CSELF)                    GBL_NOEXCEPT;
 
 EVMU_EXPORT EVMU_RESULT    EvmuRom_loadBios      (GBL_SELF, const char* pPath)  GBL_NOEXCEPT;
+EVMU_EXPORT EVMU_RESULT    EvmuRom_unloadBios    (GBL_SELF)                     GBL_NOEXCEPT;
 EVMU_EXPORT EvmuAddress    EvmuRom_callBios      (GBL_SELF, EvmuAddress entry)  GBL_NOEXCEPT;
 
 EVMU_EXPORT EVMU_RESULT    EvmuRom_skipBiosSetup (GBL_SELF, GblBool enableSkip) GBL_NOEXCEPT;

lib/api/evmu/types/evmu_ibehavior.h

@@ -16,8 +16,6 @@ GBL_DECLS_BEGIN
 GBL_FORWARD_DECLARE_STRUCT(EvmuEmulator);
 
 GBL_INTERFACE_DERIVE(EvmuIBehavior)
-    EVMU_RESULT (*pFnInitialize)(GBL_SELF);
-    EVMU_RESULT (*pFnFinalize)  (GBL_SELF);
     EVMU_RESULT (*pFnReset)     (GBL_SELF);
     EVMU_RESULT (*pFnUpdate)    (GBL_SELF, EvmuTicks ticks);
     EVMU_RESULT (*pFnSaveState) (GBL_CSELF, GblStringBuffer* pString);
@@ -27,8 +25,6 @@ GBL_INTERFACE_END
 EVMU_EXPORT GblType       EvmuIBehavior_type       (void)                                     GBL_NOEXCEPT;
 EVMU_EXPORT EvmuEmulator* EvmuIBehavior_emulator   (GBL_CSELF)                                GBL_NOEXCEPT;
 
-EVMU_EXPORT EVMU_RESULT   EvmuIBehavior_initialize (GBL_SELF)                                 GBL_NOEXCEPT;
-EVMU_EXPORT EVMU_RESULT   EvmuIBehavior_finalize   (GBL_SELF)                                 GBL_NOEXCEPT;
 EVMU_EXPORT EVMU_RESULT   EvmuIBehavior_reset      (GBL_SELF)                                 GBL_NOEXCEPT;
 EVMU_EXPORT EVMU_RESULT   EvmuIBehavior_update     (GBL_SELF, EvmuTicks ticks)                GBL_NOEXCEPT;
 EVMU_EXPORT EVMU_RESULT   EvmuIBehavior_saveState  (GBL_SELF, GblStringBuffer* pString)       GBL_NOEXCEPT;