[VM][STATE] Apply new state framework to some VMs.
cpu = new MC6800(this, emu);
pia = new MC6820(this, emu);
- memory = new MEMORY(this, emu);
+ memory = new BMJR_MEMORY(this, emu);
// Set names
#if defined(_USE_QT)
class MC6800;
class MC6820;
-class MEMORY;
+class BMJR_MEMORY;
class VM : public VM_TEMPLATE
{
MC6800* cpu;
MC6820* pia;
- MEMORY* memory;
+ BMJR_MEMORY* memory;
public:
// ----------------------------------------
{0x00, 0x0d, 0x2e, 0xdc}, // RETURN DEL '\'
};
-void MEMORY::initialize()
+void BMJR_MEMORY::initialize()
{
// initialize memory
memset(ram, 0, sizeof(ram));
register_frame_event(this);
}
-void MEMORY::reset()
+void BMJR_MEMORY::reset()
{
touch_sound();
memory_bank = 0;
sound_clock = sound_mix_clock = get_current_clock();
}
-void MEMORY::write_data8(uint32_t addr, uint32_t data)
+void BMJR_MEMORY::write_data8(uint32_t addr, uint32_t data)
{
if((addr & 0xfe00) == 0xee00) {
// EE00h - EFFFh
wbank[(addr >> 11) & 0x1f][addr & 0x7ff] = data;
}
-uint32_t MEMORY::read_data8(uint32_t addr)
+uint32_t BMJR_MEMORY::read_data8(uint32_t addr)
{
if((addr & 0xfe00) == 0xee00) {
// EE00h - EFFFh
return rbank[(addr >> 11) & 0x1f][addr & 0x7ff];
}
-void MEMORY::write_signal(int id, uint32_t data, uint32_t mask)
+void BMJR_MEMORY::write_signal(int id, uint32_t data, uint32_t mask)
{
if(id == SIG_MEMORY_DATAREC_EAR) {
bool new_in = ((data & mask) != 0);
}
}
-void MEMORY::event_frame()
+void BMJR_MEMORY::event_frame()
{
key_data = 0xff;
if(key_column < 13) {
#endif
}
-void MEMORY::key_down(int code)
+void BMJR_MEMORY::key_down(int code)
{
// pause -> break
if(code == 0x13) {
}
}
-void MEMORY::update_bank()
+void BMJR_MEMORY::update_bank()
{
if(memory_bank & 1) {
SET_BANK(0xb000, 0xdfff, ram + 0xb000, ram + 0xb000);
}
}
-void MEMORY::mix(int32_t* buffer, int cnt)
+void BMJR_MEMORY::mix(int32_t* buffer, int cnt)
{
int32_t volume = 0;
if(get_passed_clock(sound_mix_clock) != 0) {
}
}
-void MEMORY::set_volume(int ch, int decibel_l, int decibel_r)
+void BMJR_MEMORY::set_volume(int ch, int decibel_l, int decibel_r)
{
volume_l = decibel_to_volume(decibel_l);
volume_r = decibel_to_volume(decibel_r);
}
-void MEMORY::draw_screen()
+void BMJR_MEMORY::draw_screen()
{
if(!(screen_mode & 0x80)) {
// text
#define STATE_VERSION 2
-bool MEMORY::process_state(FILEIO* state_fio, bool loading)
+bool BMJR_MEMORY::process_state(FILEIO* state_fio, bool loading)
{
if(!state_fio->StateCheckUint32(STATE_VERSION)) {
return false;
[ memory bus ]
*/
-#ifndef _MEMORY_H_
-#define _MEMORY_H_
+#ifndef _BMJR_MEMORY_H_
+#define _BMJR_MEMORY_H_
#include "../vm.h"
#include "../../emu.h"
#define SIG_MEMORY_DATAREC_EAR 0
-class MEMORY : public DEVICE
+class BMJR_MEMORY : public DEVICE
{
private:
// contexts
int volume_l, volume_r;
public:
- MEMORY(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
+ BMJR_MEMORY(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
{
volume_l = volume_r = 1024;
set_device_name(_T("Memory Bus"));
}
- ~MEMORY() {}
+ ~BMJR_MEMORY() {}
// common functions
void initialize();
#endif
#include "keyboard.h"
-#include "memory.h"
+#include "./memory.h"
// ----------------------------------------------------------------------------
// initialize
cpu = new Z80(this, emu);
key = new KEYBOARD(this, emu);
- memory = new MEMORY(this, emu);
+ memory = new COLECOVISION_MEMORY(this, emu);
// set contexts
event->set_context_cpu(cpu);
class Z80;
class KEYBOARD;
-class MEMORY;
+class COLECOVISION_MEMORY;
class VM : public VM_TEMPLATE
{
Z80* cpu;
KEYBOARD* key;
- MEMORY* memory;
+ COLECOVISION_MEMORY* memory;
public:
// ----------------------------------------
} \
}
-void MEMORY::initialize()
+void COLECOVISION_MEMORY::initialize()
{
memset(cart, 0xff, sizeof(cart));
memset(ipl, 0xff, sizeof(ipl));
inserted = false;
}
-void MEMORY::write_data8(uint32_t addr, uint32_t data)
+void COLECOVISION_MEMORY::write_data8(uint32_t addr, uint32_t data)
{
addr &= 0xffff;
wbank[addr >> 12][addr & 0xfff] = data;
}
-uint32_t MEMORY::read_data8(uint32_t addr)
+uint32_t COLECOVISION_MEMORY::read_data8(uint32_t addr)
{
addr &= 0xffff;
return rbank[addr >> 12][addr & 0xfff];
}
-void MEMORY::open_cart(const _TCHAR* file_path)
+void COLECOVISION_MEMORY::open_cart(const _TCHAR* file_path)
{
FILEIO* fio = new FILEIO();
delete fio;
}
-void MEMORY::close_cart()
+void COLECOVISION_MEMORY::close_cart()
{
memset(cart, 0xff, sizeof(cart));
inserted = false;
#define STATE_VERSION 1
-bool MEMORY::process_state(FILEIO* state_fio, bool loading)
+bool COLECOVISION_MEMORY::process_state(FILEIO* state_fio, bool loading)
{
if(!state_fio->StateCheckUint32(STATE_VERSION)) {
return false;
[ memory ]
*/
-#ifndef _MEMORY_H_
-#define _MEMORY_H_
+#ifndef _COLECOVISION_MEMORY_H_
+#define _COLECOVISION_MEMORY_H_
#include "../vm.h"
#include "../../emu.h"
#include "../device.h"
-class MEMORY : public DEVICE
+class COLECOVISION_MEMORY : public DEVICE
{
private:
// memory
bool inserted;
public:
- MEMORY(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
+ COLECOVISION_MEMORY(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
{
set_device_name(_T("Memory Bus"));
}
- ~MEMORY() {}
+ ~COLECOVISION_MEMORY() {}
// common functions
void initialize();
#include "cmt.h"
#include "display.h"
#include "keyboard.h"
-#include "memory.h"
+#include "./memory.h"
// ----------------------------------------------------------------------------
// initialize
cmt = new CMT(this, emu);
display = new DISPLAY(this, emu);
keyboard = new KEYBOARD(this, emu);
- memory = new MEMORY(this, emu);
+ memory = new EX80_MEMORY(this, emu);
// Set names
#if defined(_USE_QT)
dummy->set_device_name(_T("1st Dummy"));
class CMT;
class DISPLAY;
class KEYBOARD;
-class MEMORY;
+class EX80_MEMORY;
class VM : public VM_TEMPLATE
{
CMT* cmt;
DISPLAY* display;
KEYBOARD* keyboard;
- MEMORY* memory;
+ EX80_MEMORY* memory;
public:
// ----------------------------------------
[ memory ]
*/
-#include "memory.h"
+#include "./memory.h"
#include "../i8080.h"
#define SET_BANK(s, e, w, r) { \
} \
}
-void MEMORY::initialize()
+void EX80_MEMORY::initialize()
{
memset(mon, 0xff, sizeof(mon));
memset(prom1, 0xff, sizeof(prom1));
SET_BANK(0x8800, 0xffff, wdmy, rdmy);
}
-void MEMORY::write_data8(uint32_t addr, uint32_t data)
+void EX80_MEMORY::write_data8(uint32_t addr, uint32_t data)
{
addr &= 0xffff;
wbank[addr >> 10][addr & 0x3ff] = data;
}
-uint32_t MEMORY::read_data8(uint32_t addr)
+uint32_t EX80_MEMORY::read_data8(uint32_t addr)
{
addr &= 0xffff;
return rbank[addr >> 10][addr & 0x3ff];
}
-uint32_t MEMORY::fetch_op(uint32_t addr, int *wait)
+uint32_t EX80_MEMORY::fetch_op(uint32_t addr, int *wait)
{
if((config.dipswitch & 1) && d_cpu->read_signal(SIG_I8080_INTE)) {
d_cpu->write_signal(SIG_I8080_INTR, 1, 1);
return read_data8(addr);
}
-void MEMORY::load_binary(const _TCHAR* file_path)
+void EX80_MEMORY::load_binary(const _TCHAR* file_path)
{
FILEIO* fio = new FILEIO();
if(fio->Fopen(file_path, FILEIO_READ_BINARY)) {
delete fio;
}
-void MEMORY::save_binary(const _TCHAR* file_path)
+void EX80_MEMORY::save_binary(const _TCHAR* file_path)
{
FILEIO* fio = new FILEIO();
if(fio->Fopen(file_path, FILEIO_WRITE_BINARY)) {
#define STATE_VERSION 1
-bool MEMORY::process_state(FILEIO* state_fio, bool loading)
+bool EX80_MEMORY::process_state(FILEIO* state_fio, bool loading)
{
if(!state_fio->StateCheckUint32(STATE_VERSION)) {
return false;
[ memory ]
*/
-#ifndef _MEMORY_H_
-#define _MEMORY_H_
+#ifndef _EX80_MEMORY_H_
+#define _EX80_MEMORY_H_
#include "../vm.h"
#include "../../emu.h"
#include "../device.h"
-class MEMORY : public DEVICE
+class EX80_MEMORY : public DEVICE
{
private:
DEVICE *d_cpu;
uint8_t* rbank[64];
public:
- MEMORY(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
+ EX80_MEMORY(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
{
set_device_name(_T("Memory Bus"));
}
- ~MEMORY() {}
+ ~EX80_MEMORY() {}
// common functions
void initialize();
// cpu = new M6502(this, emu);
opll = new YM2413(this, emu);
- memory = new MEMORY(this, emu);
+ memory = new FAMILYBASIC_MEMORY(this, emu);
apu = new APU(this, emu);
ppu = new PPU(this, emu);
cpu = new N2A03(this, emu); // cpu shoud be reset after other device
class N2A03;
class YM2413;
-class MEMORY;
+class FAMILYBASIC_MEMORY;
class APU;
class PPU;
N2A03* cpu;
YM2413* opll;
- MEMORY* memory;
+ FAMILYBASIC_MEMORY* memory;
APU* apu;
PPU* ppu;
[ memory ]
*/
-#include "memory.h"
+#include "./memory.h"
#include "ppu.h"
#include "../datarec.h"
#include "../ym2413.h"
#define EVENT_DMA_DONE 0
-void MEMORY::initialize()
+void FAMILYBASIC_MEMORY::initialize()
{
key_stat = emu->get_key_buffer();
joy_stat = emu->get_joy_buffer();
register_vline_event(this);
}
-void MEMORY::load_rom_image(const _TCHAR *file_name)
+void FAMILYBASIC_MEMORY::load_rom_image(const _TCHAR *file_name)
{
FILEIO* fio = new FILEIO();
save_ram_crc32 = get_crc32(save_ram, sizeof(save_ram));
}
-void MEMORY::save_backup()
+void FAMILYBASIC_MEMORY::save_backup()
{
if(save_ram_crc32 != get_crc32(save_ram, sizeof(save_ram))) {
FILEIO* fio = new FILEIO();
}
}
-void MEMORY::release()
+void FAMILYBASIC_MEMORY::release()
{
if(rom != NULL) {
free(rom);
save_backup();
}
-void MEMORY::reset()
+void FAMILYBASIC_MEMORY::reset()
{
memset(ram, 0, sizeof(ram));
vrc7_reset();
}
-void MEMORY::write_data8(uint32_t addr, uint32_t data)
+void FAMILYBASIC_MEMORY::write_data8(uint32_t addr, uint32_t data)
{
addr &= 0xffff;
}
}
-uint32_t MEMORY::read_data8(uint32_t addr)
+uint32_t FAMILYBASIC_MEMORY::read_data8(uint32_t addr)
{
addr &= 0xffff;
}
}
-void MEMORY::event_vline(int v, int clock)
+void FAMILYBASIC_MEMORY::event_vline(int v, int clock)
{
// 525 -> 262.5
if(v & 1) {
}
}
-void MEMORY::event_callback(int event_id, int err)
+void FAMILYBASIC_MEMORY::event_callback(int event_id, int err)
{
// dma done
d_cpu->write_signal(SIG_CPU_BUSREQ, 0, 1);
}
-void MEMORY::set_rom_bank(uint8_t bank, uint32_t bank_num)
+void FAMILYBASIC_MEMORY::set_rom_bank(uint8_t bank, uint32_t bank_num)
{
bank_ptr[bank] = rom + 0x2000 * (bank_num & rom_mask);
banks[bank] = bank_num;
// mmc5
-void MEMORY::mmc5_reset()
+void FAMILYBASIC_MEMORY::mmc5_reset()
{
if(header.mapper() == 5) {
mmc5_set_wram_bank(3, 0);
}
}
-uint32_t MEMORY::mmc5_lo_read(uint32_t addr)
+uint32_t FAMILYBASIC_MEMORY::mmc5_lo_read(uint32_t addr)
{
uint8_t data = (uint8_t)(addr >> 8);
return data;
}
-void MEMORY::mmc5_lo_write(uint32_t addr, uint32_t data)
+void FAMILYBASIC_MEMORY::mmc5_lo_write(uint32_t addr, uint32_t data)
{
switch(addr) {
case 0x5100:
}
}
-//uint32_t MEMORY::mmc5_save_read(uint32_t addr)
+//uint32_t FAMILYBASIC_MEMORY::mmc5_save_read(uint32_t addr)
//{
// return bank_ptr[3][addr & 0x1fff];
//}
-void MEMORY::mmc5_save_write(uint32_t addr, uint32_t data)
+void FAMILYBASIC_MEMORY::mmc5_save_write(uint32_t addr, uint32_t data)
{
if(mmc5_wram_protect0 == 0x02 && mmc5_wram_protect1 == 0x01) {
if(mmc5_wram_bank[3] < 8) {
}
}
-void MEMORY::mmc5_hi_write(uint32_t addr, uint32_t data)
+void FAMILYBASIC_MEMORY::mmc5_hi_write(uint32_t addr, uint32_t data)
{
if(mmc5_wram_protect0 == 0x02 && mmc5_wram_protect1 == 0x01) {
if(addr < 0xa000) {
}
}
-void MEMORY::mmc5_hsync(int v)
+void FAMILYBASIC_MEMORY::mmc5_hsync(int v)
{
if(v <= 240) {
if(v == mmc5_irq_line) {
}
}
-void MEMORY::mmc5_set_cpu_bank(uint8_t bank, uint32_t bank_num)
+void FAMILYBASIC_MEMORY::mmc5_set_cpu_bank(uint8_t bank, uint32_t bank_num)
{
if(bank_num & 0x80) {
if(mmc5_prg_size == 0) {
}
}
-void MEMORY::mmc5_set_wram_bank(uint8_t bank, uint32_t bank_num)
+void FAMILYBASIC_MEMORY::mmc5_set_wram_bank(uint8_t bank, uint32_t bank_num)
{
if(bank_num < 8) {
bank_ptr[bank] = save_ram + 0x2000 * bank_num;
}
}
-void MEMORY::mmc5_set_ppu_bank(uint8_t mode)
+void FAMILYBASIC_MEMORY::mmc5_set_ppu_bank(uint8_t mode)
{
if(mmc5_chr_size == 0) {
d_ppu->set_ppu_bank(0, mmc5_chr_reg[7][mode] * 8 + 0);
}
}
-uint8_t MEMORY::mmc5_ppu_latch_render(uint8_t mode, uint32_t addr)
+uint8_t FAMILYBASIC_MEMORY::mmc5_ppu_latch_render(uint8_t mode, uint32_t addr)
{
uint8_t data = 0;
// vrc7
-void MEMORY::vrc7_reset()
+void FAMILYBASIC_MEMORY::vrc7_reset()
{
if(header.mapper() == 85) {
vrc7_irq_enabled = 0;
}
}
-//uint32_t MEMORY::vrc7_lo_read(uint32_t addr)
+//uint32_t FAMILYBASIC_MEMORY::vrc7_lo_read(uint32_t addr)
//{
// return 0xff;
//}
-//void MEMORY::vrc7_lo_write(uint32_t addr, uint32_t data)
+//void FAMILYBASIC_MEMORY::vrc7_lo_write(uint32_t addr, uint32_t data)
//{
//}
-//uint32_t MEMORY::vrc7_save_read(uint32_t addr)
+//uint32_t FAMILYBASIC_MEMORY::vrc7_save_read(uint32_t addr)
//{
// return bank_ptr[3][addr & 0x1fff];
//}
-//void MEMORY::vrc7_save_write(uint32_t addr, uint32_t data)
+//void FAMILYBASIC_MEMORY::vrc7_save_write(uint32_t addr, uint32_t data)
//{
// bank_ptr[3][addr & 0x1fff] = data;
//}
-void MEMORY::vrc7_hi_write(uint32_t addr, uint32_t data)
+void FAMILYBASIC_MEMORY::vrc7_hi_write(uint32_t addr, uint32_t data)
{
switch(addr & 0xf038) {
case 0x8000:
}
}
-void MEMORY::vrc7_hsync(int v)
+void FAMILYBASIC_MEMORY::vrc7_hsync(int v)
{
if(vrc7_irq_enabled & 0x02) {
if(vrc7_irq_counter == 0xff) {
#define STATE_VERSION 2
-bool MEMORY::process_state(FILEIO* state_fio, bool loading)
+bool FAMILYBASIC_MEMORY::process_state(FILEIO* state_fio, bool loading)
{
if(!state_fio->StateCheckUint32(STATE_VERSION)) {
return false;
[ memory ]
*/
-#ifndef _MEMORY_H_
-#define _MEMORY_H_
+#ifndef _FAMILYBASIC_MEMORY_H_
+#define _FAMILYBASIC_MEMORY_H_
#include "../vm.h"
#include "../../emu.h"
class PPU;
-class MEMORY : public DEVICE
+class FAMILYBASIC_MEMORY : public DEVICE
{
private:
DEVICE *d_cpu, *d_apu, *d_drec, *d_opll;
void vrc7_hsync(int v);
public:
- MEMORY(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
+ FAMILYBASIC_MEMORY(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
{
set_device_name(_T("Memory Bus"));
}
- ~MEMORY() {}
+ ~FAMILYBASIC_MEMORY() {}
// common functions
void initialize();
#define MIRROR_VERT 1
#define MIRROR_4SCREEN 2
-class MEMORY;
+class FAMILYBASIC_MEMORY;
class PPU : public DEVICE
{
private:
DEVICE *d_cpu;
- MEMORY *d_memory;
+ FAMILYBASIC_MEMORY *d_memory;
scrntype_t palette_pc[64];
uint8_t screen[240][256 + 16]; // 2*8 = side margin
{
d_cpu = device;
}
- void set_context_memory(MEMORY* device)
+ void set_context_memory(FAMILYBASIC_MEMORY* device)
{
d_memory = device;
}
#define STATE_VERSION 1
-#include "../../statesub.h"
-
-void CMOS::decl_state()
-{
- enter_decl_state(STATE_VERSION);
-
- DECL_STATE_ENTRY_1D_ARRAY(cmos, sizeof(cmos));
- DECL_STATE_ENTRY_BOOL(modified);
-
- leave_decl_state();
-}
-void CMOS::save_state(FILEIO* state_fio)
-{
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
- }
-
-// state_fio->FputUint32(STATE_VERSION);
-// state_fio->FputInt32(this_device_id);
-
-// state_fio->Fwrite(cmos, sizeof(cmos), 1);
-// state_fio->FputBool(modified);
-}
-
-bool CMOS::load_state(FILEIO* state_fio)
-{
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
- }
- if(!mb) {
- return false;
- }
-
-// if(state_fio->FgetUint32() != STATE_VERSION) {
-// return false;
-// }
-// if(state_fio->FgetInt32() != this_device_id) {
-// return false;
-// }
-// state_fio->Fread(cmos, sizeof(cmos), 1);
-// modified = state_fio->FgetBool();
- return true;
-}
-
bool CMOS::process_state(FILEIO* state_fio, bool loading)
{
if(!state_fio->StateCheckUint32(STATE_VERSION)) {
void release();
void write_io8(uint32_t addr, uint32_t data);
uint32_t read_io8(uint32_t addr);
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
+ bool process_state(FILEIO* state_fio, bool loading);
};
#endif
for(DEVICE* device = first_device; device; device = device->next_device) {
device->initialize();
}
- decl_state();
for(int i = 0; i < 4; i++) {
fdc_2hd->set_drive_type(i, DRIVE_TYPE_2HD);
#define STATE_VERSION 1
-#include "../../statesub.h"
-#include "../../qt/gui/csp_logger.h"
-extern CSP_Logger DLL_PREFIX_I *csp_logger;
-
-void VM::decl_state(void)
-{
- state_entry = new csp_state_utils(STATE_VERSION, 0, (_TCHAR *)(_T("CSP::FM16BETA_HEAD")), csp_logger);
- for(DEVICE* device = first_device; device; device = device->next_device) {
- device->decl_state();
- }
-}
-
-void VM::save_state(FILEIO* state_fio)
-{
- //state_fio->FputUint32(STATE_VERSION);
-
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
- }
- for(DEVICE* device = first_device; device; device = device->next_device) {
- device->save_state(state_fio);
- }
-}
-
-bool VM::load_state(FILEIO* state_fio)
-{
- //if(state_fio->FgetUint32() != STATE_VERSION) {
- // return false;
- //}
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
- }
- if(!mb) {
- emu->out_debug_log("INFO: HEADER DATA ERROR");
- return false;
- }
- for(DEVICE* device = first_device; device; device = device->next_device) {
- if(!device->load_state(state_fio)) {
- return false;
- }
- }
- return true;
-}
-
bool VM::process_state(FILEIO* state_fio, bool loading)
{
if(!state_fio->StateCheckUint32(STATE_VERSION)) {
- return false;
- }
- for(DEVICE* device = first_device; device; device = device->next_device) {
- const char *name = typeid(*device).name() + 6; // skip "class "
+ return false;
+ }
+ for(DEVICE* device = first_device; device; device = device->next_device) {
+ // Note: typeid(foo).name is fixed by recent ABI.Not dec 6.
+ // const char *name = typeid(*device).name();
+ // But, using get_device_name() instead of typeid(foo).name() 20181008 K.O
+ const char *name = device->get_device_name();
int len = strlen(name);
if(!state_fio->StateCheckInt32(len)) {
+ if(loading) {
+ printf("Class name len Error: DEVID=%d EXPECT=%s\n", device->this_device_id, name);
+ }
return false;
}
if(!state_fio->StateCheckBuffer(name, len, 1)) {
- return false;
- }
+ if(loading) {
+ printf("Class name Error: DEVID=%d EXPECT=%s\n", device->this_device_id, name);
+ }
+ return false;
+ }
if(!device->process_state(state_fio, loading)) {
- return false;
- }
- }
- return true;
+ if(loading) {
+ printf("Data loading Error: DEVID=%d\n", device->this_device_id);
+ }
+ return false;
+ }
+ }
+ // Machine specified.
+ return true;
}
bool is_frame_skippable();
void update_config();
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
+ bool process_state(FILEIO* state_fio, bool loading);
// ----------------------------------------
// for each device
#define STATE_VERSION 1
-#include "../../statesub.h"
-
-void KEYBOARD::decl_state()
-{
- enter_decl_state(STATE_VERSION);
-
- DECL_STATE_ENTRY_FIFO(key_buf);
- DECL_STATE_ENTRY_INT32(kbstat);
- DECL_STATE_ENTRY_INT32(kbdata);
- DECL_STATE_ENTRY_1D_ARRAY(table, sizeof(table));
-
- leave_decl_state();
-}
-void KEYBOARD::save_state(FILEIO* state_fio)
+bool KEYBOARD::process_state(FILEIO* state_fio, bool loading)
{
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
+ if(!state_fio->StateCheckUint32(STATE_VERSION)) {
+ return false;
}
-
-// state_fio->FputUint32(STATE_VERSION);
-// state_fio->FputInt32(this_device_id);
-
-// key_buf->save_state((void *)state_fio);
-// state_fio->FputInt32(kbstat);
-// state_fio->FputInt32(kbdata);
-// state_fio->Fwrite(table, sizeof(table), 1);
-}
-
-bool KEYBOARD::load_state(FILEIO* state_fio)
-{
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
+ if(!state_fio->StateCheckInt32(this_device_id)) {
+ return false;
}
- if(!mb) {
+ if(!key_buf->process_state((void *)state_fio, loading)) {
return false;
}
-
-// if(state_fio->FgetUint32() != STATE_VERSION) {
-// return false;
-// }
-// if(state_fio->FgetInt32() != this_device_id) {
-// return false;
-// }
-// if(!key_buf->load_state((void *)state_fio)) {
-// return false;
-// }
-// kbstat = state_fio->FgetInt32();
-// kbdata = state_fio->FgetInt32();
-// state_fio->Fread(table, sizeof(table), 1);
+ state_fio->StateInt32(kbstat);
+ state_fio->StateInt32(kbdata);
+ state_fio->StateBuffer(table, sizeof(table), 1);
return true;
}
-1, -1, 0x34, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
};
-bool KEYBOARD::process_state(FILEIO* state_fio, bool loading)
-{
- if(!state_fio->StateCheckUint32(STATE_VERSION)) {
- return false;
- }
- if(!state_fio->StateCheckInt32(this_device_id)) {
- return false;
- }
- if(!key_buf->process_state((void *)state_fio, loading)) {
- return false;
- }
- state_fio->StateInt32(kbstat);
- state_fio->StateInt32(kbdata);
- state_fio->StateBuffer(table, sizeof(table), 1);
- return true;
-}
+
void reset();
uint32_t read_io8(uint32_t addr);
void event_frame();
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
+ bool process_state(FILEIO* state_fio, bool loading);
// unique functions
void set_context_main(DEVICE* device)
-bool MAIN::process_state(FILEIO* state_fio, bool loading)
-{
- if(!state_fio->StateCheckUint32(STATE_VERSION)) {
- return false;
- }
- if(!state_fio->StateCheckInt32(this_device_id)) {
- return false;
- }
- return true;
-}
#define STATE_VERSION 1
-#include "../../statesub.h"
-
-void MAINBUS::decl_state()
-{
- enter_decl_state(STATE_VERSION);
-
- leave_decl_state();
-
-// MEMORY::decl_state();
-}
-
-void MAINBUS::save_state(FILEIO* state_fio)
-{
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
- }
-
-// state_fio->FputUint32(STATE_VERSION);
-// state_fio->FputInt32(this_device_id);
-
- MEMORY::save_state(state_fio);
-}
-
-bool MAINBUS::load_state(FILEIO* state_fio)
+bool MAINBUS::process_state(FILEIO* state_fio, bool loading)
{
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
+ if(!state_fio->StateCheckUint32(STATE_VERSION)) {
+ return false;
}
- if(!mb) {
+ if(!state_fio->StateCheckInt32(this_device_id)) {
return false;
}
-
-// if(state_fio->FgetUint32() != STATE_VERSION) {
-// return false;
-// }
-// if(state_fio->FgetInt32() != this_device_id) {
-// return false;
-// }
- if(MEMORY::load_state(state_fio) == false) return false;
- return true;
+ return MEMORY::process_state(state_fio, loading); // OK?
+// return true;
}
void write_io8(uint32_t addr, uint32_t data);
uint32_t read_io8(uint32_t addr);
void write_signal(int id, uint32_t data, uint32_t mask);
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
+ bool process_state(FILEIO* state_fio, bool loading);
// unique functions
#ifdef HAS_I286
#define STATE_VERSION 1
-#include "../../statesub.h"
-
-void SUB::decl_state()
-{
- enter_decl_state(STATE_VERSION);
-
- leave_decl_state();
-
-// MEMORY::decl_state(); //
-}
-
-void SUB::save_state(FILEIO* state_fio)
-{
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
- }
-
-// state_fio->FputUint32(STATE_VERSION);
-// state_fio->FputInt32(this_device_id);
-
- MEMORY::save_state(state_fio);
-}
-
-bool SUB::load_state(FILEIO* state_fio)
-{
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
- }
- if(!mb) {
- return false;
- }
-
-// if(state_fio->FgetUint32() != STATE_VERSION) {
-// return false;
-// }
-// if(state_fio->FgetInt32() != this_device_id) {
-// return false;
-// }
- if(!MEMORY::load_state(state_fio)) {
- return false;
- }
- return true;
-}
-
bool SUB::process_state(FILEIO* state_fio, bool loading)
{
if(!state_fio->StateCheckUint32(STATE_VERSION)) {
void write_io8(uint32_t addr, uint32_t data);
uint32_t read_io8(uint32_t addr);
void write_signal(int id, uint32_t data, uint32_t mask);
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
+ bool process_state(FILEIO* state_fio, bool loading);
// unique functions
void set_context_crtc(DEVICE* device)
for(DEVICE* device = first_device; device; device = device->next_device) {
device->initialize();
}
- decl_state();
//pcm->set_realtime_render(true);
}
#define STATE_VERSION 3
-#include "../../statesub.h"
-#include "../../qt/gui/csp_logger.h"
-extern CSP_Logger DLL_PREFIX_I *csp_logger;
-
-void VM::decl_state(void)
-{
- state_entry = new csp_state_utils(STATE_VERSION, 0, (_TCHAR *)(_T("CSP::FM16PI_HEAD")), csp_logger);
- DECL_STATE_ENTRY_MULTI(void, ram, sizeof(ram));
- for(DEVICE* device = first_device; device; device = device->next_device) {
- device->decl_state();
- }
-}
-
-void VM::save_state(FILEIO* state_fio)
-{
- //state_fio->FputUint32(STATE_VERSION);
-
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
- }
- for(DEVICE* device = first_device; device; device = device->next_device) {
- device->save_state(state_fio);
- }
- //state_fio->Fwrite(ram, sizeof(ram), 1);
-}
-
-bool VM::load_state(FILEIO* state_fio)
-{
- //if(state_fio->FgetUint32() != STATE_VERSION) {
- // return false;
- //}
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
- }
- if(!mb) {
- emu->out_debug_log("INFO: HEADER DATA ERROR");
- return false;
- }
- for(DEVICE* device = first_device; device; device = device->next_device) {
- if(!device->load_state(state_fio)) {
- return false;
- }
- }
- //state_fio->Fread(ram, sizeof(ram), 1);
- return true;
-}
-
bool VM::process_state(FILEIO* state_fio, bool loading)
{
if(!state_fio->StateCheckUint32(STATE_VERSION)) {
return false;
}
- for(DEVICE* device = first_device; device; device = device->next_device) {
- const char *name = typeid(*device).name() + 6; // skip "class "
+ for(DEVICE* device = first_device; device; device = device->next_device) {
+ // Note: typeid(foo).name is fixed by recent ABI.Not dec 6.
+ // const char *name = typeid(*device).name();
+ // But, using get_device_name() instead of typeid(foo).name() 20181008 K.O
+ const char *name = device->get_device_name();
int len = strlen(name);
if(!state_fio->StateCheckInt32(len)) {
+ if(loading) {
+ printf("Class name len Error: DEVID=%d EXPECT=%s\n", device->this_device_id, name);
+ }
return false;
}
if(!state_fio->StateCheckBuffer(name, len, 1)) {
- return false;
- }
+ if(loading) {
+ printf("Class name Error: DEVID=%d EXPECT=%s\n", device->this_device_id, name);
+ }
+ return false;
+ }
if(!device->process_state(state_fio, loading)) {
- return false;
- }
- }
+ if(loading) {
+ printf("Data loading Error: DEVID=%d\n", device->this_device_id);
+ }
+ return false;
+ }
+ }
+ // Machine specified.
state_fio->StateBuffer(ram, sizeof(ram), 1);
return true;
}
bool is_frame_skippable();
void update_config();
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
+ bool process_state(FILEIO* state_fio, bool loading);
// ----------------------------------------
// for each device
#define STATE_VERSION 1
-#include "../../statesub.h"
-
-void SUB::decl_state()
-{
- enter_decl_state(STATE_VERSION);
-
- DECL_STATE_ENTRY_FIFO(key_buffer);
- DECL_STATE_ENTRY_UINT8(key_data);
- DECL_STATE_ENTRY_BOOL(key_irq);
- DECL_STATE_ENTRY_UINT8(fdc_drive);
- DECL_STATE_ENTRY_UINT8(fdc_side);
- DECL_STATE_ENTRY_UINT8(rtc_data);
-
- leave_decl_state();
-}
-
-void SUB::save_state(FILEIO* state_fio)
-{
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
- }
-
-// state_fio->FputUint32(STATE_VERSION);
-// state_fio->FputInt32(this_device_id);
-//
-// key_buffer->save_state((void *)state_fio);
-// state_fio->FputUint8(key_data);
-// state_fio->FputBool(key_irq);
-// state_fio->FputUint8(fdc_drive);
-// state_fio->FputUint8(fdc_side);
-// state_fio->FputUint8(rtc_data);
-}
-
-bool SUB::load_state(FILEIO* state_fio)
-{
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
- }
- if(!mb) {
- return false;
- }
-
-// if(state_fio->FgetUint32() != STATE_VERSION) {
-// return false;
-// }
-// if(state_fio->FgetInt32() != this_device_id) {
-// return false;
-// }
-// if(!key_buffer->load_state((void *)state_fio)) {
-// return false;
-// }
-// key_data = state_fio->FgetUint8();
-// key_irq = state_fio->FgetBool();
-// fdc_drive = state_fio->FgetUint8();
-// fdc_side = state_fio->FgetUint8();
-// rtc_data = state_fio->FgetUint8();
- return true;
-}
-
bool SUB::process_state(FILEIO* state_fio, bool loading)
{
if(!state_fio->StateCheckUint32(STATE_VERSION)) {
uint32_t read_io8(uint32_t addr);
void write_signal(int id, uint32_t data, uint32_t mask);
void event_callback(int event_id, int err);
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
+ bool process_state(FILEIO* state_fio, bool loading);
// unique functions
void set_context_cpu(DEVICE* device)
#define STATE_VERSION 1
-#include "../../statesub.h"
-
-void CMOS::decl_state()
-{
- enter_decl_state(STATE_VERSION);
-
- DECL_STATE_ENTRY_1D_ARRAY(cmos, sizeof(cmos));
- DECL_STATE_ENTRY_BOOL(modified);
-
- leave_decl_state();
-}
-
-void CMOS::save_state(FILEIO* state_fio)
-{
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
- }
-
-// state_fio->FputUint32(STATE_VERSION);
-// state_fio->FputInt32(this_device_id);
-
-// state_fio->Fwrite(cmos, sizeof(cmos), 1);
-// state_fio->FputBool(modified);
-}
-
-bool CMOS::load_state(FILEIO* state_fio)
-{
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
- }
- if(!mb) {
- return false;
- }
-
-// if(state_fio->FgetUint32() != STATE_VERSION) {
-// return false;
-// }
-// if(state_fio->FgetInt32() != this_device_id) {
-// return false;
-// }
-// state_fio->Fread(cmos, sizeof(cmos), 1);
-// modified = state_fio->FgetBool();
- return true;
-}
-
bool CMOS::process_state(FILEIO* state_fio, bool loading)
{
if(!state_fio->StateCheckUint32(STATE_VERSION)) {
void release();
void write_io8(uint32_t addr, uint32_t data);
uint32_t read_io8(uint32_t addr);
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
+ bool process_state(FILEIO* state_fio, bool loading);
// unique function
uint8_t* get_cmos()
#define STATE_VERSION 1
-#include "../../statesub.h"
-
-void FLOPPY::decl_state()
-{
- enter_decl_state(STATE_VERSION);
-
- DECL_STATE_ENTRY_UINT8(fdcr);
- DECL_STATE_ENTRY_UINT8(fdsl);
- DECL_STATE_ENTRY_UINT8(fdst);
- DECL_STATE_ENTRY_INT32(drvsel);
- DECL_STATE_ENTRY_BOOL(irq);
- DECL_STATE_ENTRY_1D_ARRAY(changed, sizeof(changed) / sizeof(bool));
-
- leave_decl_state();
-}
-void FLOPPY::save_state(FILEIO* state_fio)
-{
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
- }
-
-// state_fio->FputUint32(STATE_VERSION);
-// state_fio->FputInt32(this_device_id);
-
-// state_fio->FputUint8(fdcr);
-// state_fio->FputUint8(fdsl);
-// state_fio->FputUint8(fdst);
-// state_fio->FputInt32(drvsel);
-// state_fio->FputBool(irq);
-// state_fio->Fwrite(changed, sizeof(changed), 1);
-}
-
-bool FLOPPY::load_state(FILEIO* state_fio)
-{
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
- }
- if(!mb) {
- return false;
- }
-
-// if(state_fio->FgetUint32() != STATE_VERSION) {
-// return false;
-// }
-// if(state_fio->FgetInt32() != this_device_id) {
-// return false;
-// }
-// fdcr = state_fio->FgetUint8();
-// fdsl = state_fio->FgetUint8();
-// fdst = state_fio->FgetUint8();
-// drvsel = state_fio->FgetInt32();
-// irq = state_fio->FgetBool();
-// state_fio->Fread(changed, sizeof(changed), 1);
- return true;
-}
-
bool FLOPPY::process_state(FILEIO* state_fio, bool loading)
{
if(!state_fio->StateCheckUint32(STATE_VERSION)) {
state_fio->StateUint8(fdst);
state_fio->StateInt32(drvsel);
state_fio->StateBool(irq);
- state_fio->StateBuffer(changed, sizeof(changed), 1);
+ //state_fio->StateBuffer(changed, sizeof(changed), 1);
+ for(int i = 0; i < (sizeof(changed) / sizeof(bool)); i++) {
+ state_fio->StateBool(changed[i]);
+ }
return true;
}
void write_io8(uint32_t addr, uint32_t data);
uint32_t read_io8(uint32_t addr);
void write_signal(int id, uint32_t data, uint32_t mask);
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
+ bool process_state(FILEIO* state_fio, bool loading);
// unique functions
void set_context_fdc(MB8877* device)
#include "cmos.h"
#include "floppy.h"
#include "keyboard.h"
-#include "memory.h"
+#include "./memory.h"
#include "rtc.h"
#include "scsi.h"
#include "serial.h"
cmos = new CMOS(this, emu);
floppy = new FLOPPY(this, emu);
keyboard = new KEYBOARD(this, emu);
- memory = new MEMORY(this, emu);
+ memory = new FMR30_MEMORY(this, emu);
rtc = new RTC(this, emu);
scsi = new SCSI(this, emu);
serial = new SERIAL(this, emu);
for(DEVICE* device = first_device; device; device = device->next_device) {
device->initialize();
}
- decl_state();
for(int drv = 0; drv < USE_HARD_DISK; drv++) {
if(!(config.last_hard_disk_path[drv][0] != _T('\0') && FILEIO::IsFileExisting(config.last_hard_disk_path[drv]))) {
create_local_path(config.last_hard_disk_path[drv], _MAX_PATH, _T("SCSI%d.DAT"), drv);
#define STATE_VERSION 7
-#include "../../statesub.h"
-#include "../../qt/gui/csp_logger.h"
-extern CSP_Logger DLL_PREFIX_I *csp_logger;
-
-void VM::decl_state(void)
-{
- state_entry = new csp_state_utils(STATE_VERSION, 0, (_TCHAR *)(_T("CSP::FMR30_SERIES_HEAD")), csp_logger);
-
- for(DEVICE* device = first_device; device; device = device->next_device) {
- device->decl_state();
- }
-}
-
-void VM::save_state(FILEIO* state_fio)
-{
- //state_fio->FputUint32(STATE_VERSION);
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
- }
- for(DEVICE* device = first_device; device; device = device->next_device) {
- device->save_state(state_fio);
- }
-}
-
-bool VM::load_state(FILEIO* state_fio)
-{
- //if(state_fio->FgetUint32() != STATE_VERSION) {
- // return false;
- //}
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
- }
- if(!mb) {
- emu->out_debug_log("INFO: HEADER DATA ERROR");
- return false;
- }
-
- for(DEVICE* device = first_device; device; device = device->next_device) {
- if(!device->load_state(state_fio)) {
- return false;
- }
- }
- return true;
-}
-
bool VM::process_state(FILEIO* state_fio, bool loading)
{
if(!state_fio->StateCheckUint32(STATE_VERSION)) {
return false;
}
- for(DEVICE* device = first_device; device; device = device->next_device) {
- const char *name = typeid(*device).name() + 6; // skip "class "
+ for(DEVICE* device = first_device; device; device = device->next_device) {
+ // Note: typeid(foo).name is fixed by recent ABI.Not dec 6.
+ // const char *name = typeid(*device).name();
+ // But, using get_device_name() instead of typeid(foo).name() 20181008 K.O
+ const char *name = device->get_device_name();
int len = strlen(name);
if(!state_fio->StateCheckInt32(len)) {
+ if(loading) {
+ printf("Class name len Error: DEVID=%d EXPECT=%s\n", device->this_device_id, name);
+ }
return false;
}
if(!state_fio->StateCheckBuffer(name, len, 1)) {
- return false;
- }
+ if(loading) {
+ printf("Class name Error: DEVID=%d EXPECT=%s\n", device->this_device_id, name);
+ }
+ return false;
+ }
if(!device->process_state(state_fio, loading)) {
- return false;
- }
+ if(loading) {
+ printf("Data loading Error: DEVID=%d\n", device->this_device_id);
+ }
+ return false;
+ }
}
return true;
}
class CMOS;
class FLOPPY;
class KEYBOARD;
-class MEMORY;
+class FMR30_MEMORY;
class RTC;
class SCSI;
class SERIAL;
CMOS* cmos;
FLOPPY* floppy;
KEYBOARD* keyboard;
- MEMORY* memory;
+ FMR30_MEMORY* memory;
RTC* rtc;
SCSI* scsi;
SERIAL* serial;
bool is_frame_skippable();
void update_config();
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
+ bool process_state(FILEIO* state_fio, bool loading);
// ----------------------------------------
// for each device
#include "../vm.h"
#include "../../emu.h"
-#include "memory.h"
+#include "./memory.h"
#include "../i8237.h"
#include "../i286.h"
} \
}
-void MEMORY::initialize()
+void FMR30_MEMORY::initialize()
{
// init memory
memset(ram, 0, sizeof(ram));
register_frame_event(this);
}
-void MEMORY::reset()
+void FMR30_MEMORY::reset()
{
// reset crtc
lcdadr = 0;
update_bank();
}
-void MEMORY::write_data8(uint32_t addr, uint32_t data)
+void FMR30_MEMORY::write_data8(uint32_t addr, uint32_t data)
{
addr &= 0xffffff;
wbank[addr >> 12][addr & 0xfff] = data;
}
-uint32_t MEMORY::read_data8(uint32_t addr)
+uint32_t FMR30_MEMORY::read_data8(uint32_t addr)
{
addr &= 0xffffff;
return rbank[addr >> 12][addr & 0xfff];
}
-void MEMORY::write_io8(uint32_t addr, uint32_t data)
+void FMR30_MEMORY::write_io8(uint32_t addr, uint32_t data)
{
switch(addr & 0xffff) {
// memory controller
}
}
-uint32_t MEMORY::read_io8(uint32_t addr)
+uint32_t FMR30_MEMORY::read_io8(uint32_t addr)
{
uint32_t val = 0xff;
return 0xff;
}
-void MEMORY::event_frame()
+void FMR30_MEMORY::event_frame()
{
blinkcnt++;
}
-void MEMORY::update_bank()
+void FMR30_MEMORY::update_bank()
{
if(!(mcr2 & 1)) {
// $c0000-$cffff: vram
}
}
-void MEMORY::draw_screen()
+void FMR30_MEMORY::draw_screen()
{
// render screen
memset(screen_txt, 0, sizeof(screen_txt));
}
}
-void MEMORY::draw_text40()
+void FMR30_MEMORY::draw_text40()
{
uint8_t *ank8 = ipl;
uint8_t *ank16 = ipl + 0x800;
}
}
-void MEMORY::draw_text80()
+void FMR30_MEMORY::draw_text80()
{
uint8_t *ank8 = ipl;
uint8_t *ank16 = ipl + 0x800;
}
}
-void MEMORY::draw_cg()
+void FMR30_MEMORY::draw_cg()
{
uint8_t* plane = vram + ((dcr1 >> 8) & 3) * 0x8000;
int ptr = 0;
#define STATE_VERSION 2
-#include "../../statesub.h"
-
-void MEMORY::decl_state()
-{
- enter_decl_state(STATE_VERSION);
-
- DECL_STATE_ENTRY_1D_ARRAY(ram, sizeof(ram));
- DECL_STATE_ENTRY_1D_ARRAY(vram, sizeof(vram));
- DECL_STATE_ENTRY_1D_ARRAY(cvram, sizeof(cvram));
- DECL_STATE_ENTRY_1D_ARRAY(kvram, sizeof(kvram));
- DECL_STATE_ENTRY_UINT8(mcr1);
- DECL_STATE_ENTRY_UINT8(mcr2);
- DECL_STATE_ENTRY_UINT8(a20);
- DECL_STATE_ENTRY_UINT8(lcdadr);
- DECL_STATE_ENTRY_1D_ARRAY(lcdreg, sizeof(lcdreg));
- DECL_STATE_ENTRY_UINT16(dcr1);
- DECL_STATE_ENTRY_UINT16(dcr2);
- DECL_STATE_ENTRY_INT32(kj_h);
- DECL_STATE_ENTRY_INT32(kj_l);
- DECL_STATE_ENTRY_INT32(kj_ofs);
- DECL_STATE_ENTRY_INT32(kj_row);
- DECL_STATE_ENTRY_INT32(blinkcnt);
-
- leave_decl_state();
-}
-
-void MEMORY::save_state(FILEIO* state_fio)
-{
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
- }
-
-// state_fio->FputUint32(STATE_VERSION);
-// state_fio->FputInt32(this_device_id);
-
-// state_fio->Fwrite(ram, sizeof(ram), 1);
-// state_fio->Fwrite(vram, sizeof(vram), 1);
-// state_fio->Fwrite(cvram, sizeof(cvram), 1);
-// state_fio->Fwrite(kvram, sizeof(kvram), 1);
-// state_fio->FputUint8(mcr1);
-// state_fio->FputUint8(mcr2);
-// state_fio->FputUint8(a20);
-// state_fio->FputUint8(lcdadr);
-// state_fio->Fwrite(lcdreg, sizeof(lcdreg), 1);
-// state_fio->FputUint16(dcr1);
-// state_fio->FputUint16(dcr2);
-// state_fio->FputInt32(kj_h);
-// state_fio->FputInt32(kj_l);
-// state_fio->FputInt32(kj_ofs);
-// state_fio->FputInt32(kj_row);
-// state_fio->FputInt32(blinkcnt);
-}
-
-bool MEMORY::load_state(FILEIO* state_fio)
-{
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
- }
- if(!mb) {
- return false;
- }
-
-// if(state_fio->FgetUint32() != STATE_VERSION) {
-// return false;
-// }
-// if(state_fio->FgetInt32() != this_device_id) {
-// return false;
-// }
-// state_fio->Fread(ram, sizeof(ram), 1);
-// state_fio->Fread(vram, sizeof(vram), 1);
-// state_fio->Fread(cvram, sizeof(cvram), 1);
-// state_fio->Fread(kvram, sizeof(kvram), 1);
-// mcr1 = state_fio->FgetUint8();
-// mcr2 = state_fio->FgetUint8();
-// a20 = state_fio->FgetUint8();
-// lcdadr = state_fio->FgetUint8();
-// state_fio->Fread(lcdreg, sizeof(lcdreg), 1);
-// dcr1 = state_fio->FgetUint16();
-// dcr2 = state_fio->FgetUint16();
-// kj_h = state_fio->FgetInt32();
-// kj_l = state_fio->FgetInt32();
-// kj_ofs = state_fio->FgetInt32();
-// kj_row = state_fio->FgetInt32();
-// blinkcnt = state_fio->FgetInt32();
-
- // post process
- update_bank();
- return true;
-}
-
-bool MEMORY::process_state(FILEIO* state_fio, bool loading)
+bool FMR30_MEMORY::process_state(FILEIO* state_fio, bool loading)
{
if(!state_fio->StateCheckUint32(STATE_VERSION)) {
return false;
[ memory ]
*/
-#ifndef _MEMORY_H_
-#define _MEMORY_H_
+#ifndef _FMR30_MEMORY_H_
+#define _FMR30_MEMORY_H_
#include "../vm.h"
#include "../../emu.h"
#define SIG_MEMORY_DISP 0
#define SIG_MEMORY_VSYNC 1
-class MEMORY : public DEVICE
+class FMR30_MEMORY : public DEVICE
{
private:
DEVICE *d_cpu, *d_dma;
void draw_cg();
public:
- MEMORY(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
+ FMR30_MEMORY(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
{
set_device_name(_T("Memory Bus"));
}
- ~MEMORY() {}
+ ~FMR30_MEMORY() {}
// common functions
void initialize();
void write_io8(uint32_t addr, uint32_t data);
uint32_t read_io8(uint32_t addr);
void event_frame();
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
+ bool process_state(FILEIO* state_fio, bool loading);
// unique functions
void set_context_cpu(DEVICE* device)
#define STATE_VERSION 1
-#include "../../statesub.h"
-
-void RTC::decl_state()
-{
- enter_decl_state(STATE_VERSION);
-
- DECL_STATE_ENTRY_CUR_TIME_T(cur_time);
- DECL_STATE_ENTRY_INT32(register_id);
- DECL_STATE_ENTRY_UINT16(rtcmr);
- DECL_STATE_ENTRY_UINT16(rtdsr);
- DECL_STATE_ENTRY_UINT16(rtadr);
- DECL_STATE_ENTRY_UINT16(rtobr);
- DECL_STATE_ENTRY_UINT16(rtibr);
- DECL_STATE_ENTRY_1D_ARRAY(regs, sizeof(regs));
-
- leave_decl_state();
-}
-
-void RTC::save_state(FILEIO* state_fio)
-{
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
- }
-
-// state_fio->FputUint32(STATE_VERSION);
-// state_fio->FputInt32(this_device_id);
-
-// cur_time.save_state((void *)state_fio);
-// state_fio->FputInt32(register_id);
-// state_fio->FputUint16(rtcmr);
-// state_fio->FputUint16(rtdsr);
-// state_fio->FputUint16(rtadr);
-// state_fio->FputUint16(rtobr);
-// state_fio->FputUint16(rtibr);
-// state_fio->Fwrite(regs, sizeof(regs), 1);
-}
-
-bool RTC::load_state(FILEIO* state_fio)
-{
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
- }
- if(!mb) {
- return false;
- }
-
-// if(state_fio->FgetUint32() != STATE_VERSION) {
-// return false;
-// }
-// if(state_fio->FgetInt32() != this_device_id) {
-// return false;
-// }
-// if(!cur_time.load_state((void *)state_fio)) {
-// return false;
-// }
-// register_id = state_fio->FgetInt32();
-// rtcmr = state_fio->FgetUint16();
-// rtdsr = state_fio->FgetUint16();
-// rtadr = state_fio->FgetUint16();
-// rtobr = state_fio->FgetUint16();
-// rtibr = state_fio->FgetUint16();
-// state_fio->Fread(regs, sizeof(regs), 1);
- return true;
-}
-
bool RTC::process_state(FILEIO* state_fio, bool loading)
{
if(!state_fio->StateCheckUint32(STATE_VERSION)) {
void write_io16(uint32_t addr, uint32_t data);
uint32_t read_io16(uint32_t addr);
void event_callback(int event_id, int err);
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
+ bool process_state(FILEIO* state_fio, bool loading);
// unique function
void set_context_pic(DEVICE* device)
#define STATE_VERSION 1
-#include "../../statesub.h"
-
-void SCSI::decl_state()
-{
- enter_decl_state(STATE_VERSION);
-
- DECL_STATE_ENTRY_UINT8(ctrl_reg);
- DECL_STATE_ENTRY_UINT8(intm_reg);
- DECL_STATE_ENTRY_BOOL(phase_status);
- DECL_STATE_ENTRY_BOOL(eop_status);
-
- leave_decl_state();
-}
-
-void SCSI::save_state(FILEIO* state_fio)
-{
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
- }
-
-// state_fio->FputUint32(STATE_VERSION);
-// state_fio->FputInt32(this_device_id);
-
-// state_fio->FputUint8(ctrl_reg);
-// state_fio->FputUint8(intm_reg);
-// state_fio->FputBool(phase_status);
-// state_fio->FputBool(eop_status);
-}
-
-bool SCSI::load_state(FILEIO* state_fio)
-{
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
- }
- if(!mb) {
- return false;
- }
-
-// if(state_fio->FgetUint32() != STATE_VERSION) {
-// return false;
-// }
-// if(state_fio->FgetInt32() != this_device_id) {
-// return false;
-// }
-// ctrl_reg = state_fio->FgetUint8();
-// intm_reg = state_fio->FgetUint8();
-// phase_status = state_fio->FgetBool();
-// eop_status = state_fio->FgetBool();
- return true;
-}
-
bool SCSI::process_state(FILEIO* state_fio, bool loading)
{
if(!state_fio->StateCheckUint32(STATE_VERSION)) {
{
d_host = device;
}
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
};
#endif
#define STATE_VERSION 1
-#include "../../statesub.h"
-
-void SERIAL::decl_state()
-{
- enter_decl_state(STATE_VERSION);
-
- DECL_STATE_ENTRY_UINT8_STRIDE((sioctrl[0].baud), 4, sizeof(sioctrl[0]));
- DECL_STATE_ENTRY_UINT8_STRIDE((sioctrl[0].ctrl), 4, sizeof(sioctrl[0]));
- DECL_STATE_ENTRY_BOOL_STRIDE((sioctrl[0].rxrdy), 4, sizeof(sioctrl[0]));
- DECL_STATE_ENTRY_BOOL_STRIDE((sioctrl[0].txrdy), 4, sizeof(sioctrl[0]));
- DECL_STATE_ENTRY_UINT8_STRIDE((sioctrl[0].intmask), 4, sizeof(sioctrl[0]));
- DECL_STATE_ENTRY_UINT8_STRIDE((sioctrl[0].intstat), 4, sizeof(sioctrl[0]));
-
- leave_decl_state();
-}
-
-void SERIAL::save_state(FILEIO* state_fio)
-{
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
- }
-
-// state_fio->FputUint32(STATE_VERSION);
-// state_fio->FputInt32(this_device_id);
-
-// state_fio->Fwrite(sioctrl, sizeof(sioctrl), 1);
-}
-
-bool SERIAL::load_state(FILEIO* state_fio)
-{
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
- }
- if(!mb) {
- return false;
- }
-
-// if(state_fio->FgetUint32() != STATE_VERSION) {
-// return false;
-// }
-// if(state_fio->FgetInt32() != this_device_id) {
-// return false;
-// }
-// state_fio->Fread(sioctrl, sizeof(sioctrl), 1);
- return true;
-}
-
bool SERIAL::process_state(FILEIO* state_fio, bool loading)
{
if(!state_fio->StateCheckUint32(STATE_VERSION)) {
if(!state_fio->StateCheckInt32(this_device_id)) {
return false;
}
- state_fio->StateBuffer(sioctrl, sizeof(sioctrl), 1);
+ //state_fio->StateBuffer(sioctrl, sizeof(sioctrl), 1);
+ for(int i = 0; i < 4; i++) {
+ state_fio->StateUint8(sioctrl[i].baud);
+ state_fio->StateUint8(sioctrl[i].ctrl);
+ state_fio->StateBool(sioctrl[i].rxrdy);
+ state_fio->StateBool(sioctrl[i].txrdy);
+ state_fio->StateUint8(sioctrl[i].intmask);
+ state_fio->StateUint8(sioctrl[i].intstat);
+ }
return true;
}
void write_io8(uint32_t addr, uint32_t data);
uint32_t read_io8(uint32_t addr);
void write_signal(int id, uint32_t data, uint32_t mask);
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
+ bool process_state(FILEIO* state_fio, bool loading);
// unique functions
void set_context_pic(DEVICE* device)
#define STATE_VERSION 1
-#include "../../statesub.h"
-
-void SYSTEM::decl_state()
-{
- enter_decl_state(STATE_VERSION);
-
- DECL_STATE_ENTRY_UINT8(arr);
- DECL_STATE_ENTRY_UINT8(nmistat);
- DECL_STATE_ENTRY_UINT8(nmimask);
-
- leave_decl_state();
-}
-
-void SYSTEM::save_state(FILEIO* state_fio)
-{
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
- }
-
-// state_fio->FputUint32(STATE_VERSION);
-// state_fio->FputInt32(this_device_id);
-
-// state_fio->FputUint8(arr);
-// state_fio->FputUint8(nmistat);
-// state_fio->FputUint8(nmimask);
-}
-
-bool SYSTEM::load_state(FILEIO* state_fio)
-{
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
- }
- if(!mb) {
- return false;
- }
-
-// if(state_fio->FgetUint32() != STATE_VERSION) {
-// return false;
-// }
-// if(state_fio->FgetInt32() != this_device_id) {
-// return false;
-// }
-// arr = state_fio->FgetUint8();
-// nmistat = state_fio->FgetUint8();
-// nmimask = state_fio->FgetUint8();
- return true;
-}
bool SYSTEM::process_state(FILEIO* state_fio, bool loading)
{
void initialize();
void write_io8(uint32_t addr, uint32_t data);
uint32_t read_io8(uint32_t addr);
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
+ bool process_state(FILEIO* state_fio, bool loading);
};
#endif
#define STATE_VERSION 1
-#include "../../statesub.h"
-
-void TIMER::decl_state()
-{
- enter_decl_state(STATE_VERSION);
-
- DECL_STATE_ENTRY_UINT8(ctrl);
- DECL_STATE_ENTRY_UINT8(status);
-
- leave_decl_state();
-}
-void TIMER::save_state(FILEIO* state_fio)
-{
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
- }
-
-// state_fio->FputUint32(STATE_VERSION);
-// state_fio->FputInt32(this_device_id);
-
-// state_fio->FputUint8(ctrl);
-// state_fio->FputUint8(status);
-}
-
-bool TIMER::load_state(FILEIO* state_fio)
-{
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
- }
- if(!mb) {
- return false;
- }
-
-// if(state_fio->FgetUint32() != STATE_VERSION) {
-// return false;
-// }
-// if(state_fio->FgetInt32() != this_device_id) {
-// return false;
-// }
-// ctrl = state_fio->FgetUint8();
-// status = state_fio->FgetUint8();
- return true;
-}
bool TIMER::process_state(FILEIO* state_fio, bool loading)
{
void write_io8(uint32_t addr, uint32_t data);
uint32_t read_io8(uint32_t addr);
void write_signal(int id, uint32_t data, uint32_t mask);
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
+ bool process_state(FILEIO* state_fio, bool loading);
// unique function
void set_context_pic(DEVICE* device)
#define STATE_VERSION 5
-#include "../statesub.h"
-
-void BIOS::decl_state()
-{
- enter_decl_state(STATE_VERSION);
-
- DECL_STATE_ENTRY_INT32(secnum);
- DECL_STATE_ENTRY_INT32(timeout);
- DECL_STATE_ENTRY_1D_ARRAY(drive_mode1, sizeof(drive_mode1));
- DECL_STATE_ENTRY_1D_ARRAY(drive_mode2, sizeof(drive_mode2) / sizeof(uint16_t));
- DECL_STATE_ENTRY_1D_ARRAY(scsi_blocks, sizeof(scsi_blocks) / sizeof(int));
-
- leave_decl_state();
-
- for(int i = 0; i < MAX_DRIVE; i++) {
- if(disk[i] != NULL) disk[i]->decl_state(p_logger);
- }
-}
-void BIOS::save_state(FILEIO* state_fio)
-{
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
- }
-// state_fio->FputUint32(STATE_VERSION);
-// state_fio->FputInt32(this_device_id);
-
- for(int i = 0; i < MAX_DRIVE; i++) {
- if(disk[i] != NULL) disk[i]->save_state(state_fio);
- }
-// state_fio->FputInt32(secnum);
-// state_fio->FputInt32(timeout);
-// state_fio->Fwrite(drive_mode1, sizeof(drive_mode1), 1);
-// state_fio->Fwrite(drive_mode2, sizeof(drive_mode2), 1);
-// state_fio->Fwrite(scsi_blocks, sizeof(scsi_blocks), 1);
-}
-
-bool BIOS::load_state(FILEIO* state_fio)
-{
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
- }
- if(!mb) return false;
-// if(state_fio->FgetUint32() != STATE_VERSION) {
-// return false;
-// }
-// if(state_fio->FgetInt32() != this_device_id) {
-// return false;
-// }
- for(int i = 0; i < MAX_DRIVE; i++) {
- if(disk[i] != NULL) {
- if(!disk[i]->load_state(state_fio)) {
- return false;
- }
- }
- }
-// secnum = state_fio->FgetInt32();
-// timeout = state_fio->FgetInt32();
-// state_fio->Fread(drive_mode1, sizeof(drive_mode1), 1);
-// state_fio->Fread(drive_mode2, sizeof(drive_mode2), 1);
-// state_fio->Fread(scsi_blocks, sizeof(scsi_blocks), 1);
- return true;
-}
-
bool BIOS::process_state(FILEIO* state_fio, bool loading)
{
if(!state_fio->StateCheckUint32(STATE_VERSION)) {
state_fio->StateInt32(secnum);
state_fio->StateInt32(timeout);
state_fio->StateBuffer(drive_mode1, sizeof(drive_mode1), 1);
- state_fio->StateBuffer(drive_mode2, sizeof(drive_mode2), 1);
- state_fio->StateBuffer(scsi_blocks, sizeof(scsi_blocks), 1);
+ //state_fio->StateBuffer(drive_mode2, sizeof(drive_mode2), 1);
+ for(int i = 0; i < (sizeof(drive_mode2) / sizeof(uint16_t)); i++) {
+ state_fio->StateUint16(drive_mode2[i]);
+ }
+ //state_fio->StateBuffer(scsi_blocks, sizeof(scsi_blocks), 1);
+ for(int i = 0; i < (sizeof(scsi_blocks) / sizeof(int)); i++) {
+ state_fio->StateInt32(scsi_blocks[i]);
+ }
return true;
}
bool bios_call_far_i86(uint32_t PC, uint16_t regs[], uint16_t sregs[], int32_t* ZeroFlag, int32_t* CarryFlag);
bool bios_int_i86(int intnum, uint16_t regs[], uint16_t sregs[], int32_t* ZeroFlag, int32_t* CarryFlag);
uint32_t read_signal(int ch);
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
+ bool process_state(FILEIO* state_fio, bool loading);
// unique functions
void set_context_mem(DEVICE* device)
#define STATE_VERSION 1
-#include "../../statesub.h"
-
-void CMOS::decl_state()
-{
- enter_decl_state(STATE_VERSION);
-
-#ifdef _FMRCARD
- DECL_STATE_ENTRY_2D_ARRAY(cmos, 4, 0x800);
-#else
- DECL_STATE_ENTRY_2D_ARRAY(cmos, 1, 0x800);
-#endif
- DECL_STATE_ENTRY_BOOL(modified);
- DECL_STATE_ENTRY_UINT8(bank);
-
- leave_decl_state();
-}
-
-void CMOS::save_state(FILEIO* state_fio)
-{
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
- }
-
-// state_fio->FputUint32(STATE_VERSION);
-// state_fio->FputInt32(this_device_id);
-
-// state_fio->Fwrite(cmos, sizeof(cmos), 1);
-// state_fio->FputBool(modified);
-// state_fio->FputUint8(bank);
-}
-
-bool CMOS::load_state(FILEIO* state_fio)
-{
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
- }
- if(!mb) {
- return false;
- }
-
-// if(state_fio->FgetUint32() != STATE_VERSION) {
-// return false;
-// }
-// if(state_fio->FgetInt32() != this_device_id) {
-// return false;
-// }
-// state_fio->Fread(cmos, sizeof(cmos), 1);
-// modified = state_fio->FgetBool();
-// bank = state_fio->FgetUint8();
- return true;
-}
-
bool CMOS::process_state(FILEIO* state_fio, bool loading)
{
if(!state_fio->StateCheckUint32(STATE_VERSION)) {
void reset();
void write_io8(uint32_t addr, uint32_t data);
uint32_t read_io8(uint32_t addr);
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
+ bool process_state(FILEIO* state_fio, bool loading);
// unique function
uint8_t* get_cmos()
#define STATE_VERSION 1
-#include "../../statesub.h"
-
-void FLOPPY::decl_state()
-{
- enter_decl_state(STATE_VERSION);
-
- DECL_STATE_ENTRY_INT32(drvreg);
- DECL_STATE_ENTRY_INT32(drvsel);
- DECL_STATE_ENTRY_BOOL(irq);
- DECL_STATE_ENTRY_BOOL(irqmsk);
- DECL_STATE_ENTRY_1D_ARRAY(changed, sizeof(changed) / sizeof(bool));
-
- leave_decl_state();
-}
-
-void FLOPPY::save_state(FILEIO* state_fio)
-{
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
- }
-
-// state_fio->FputUint32(STATE_VERSION);
-// state_fio->FputInt32(this_device_id);
-//
-// state_fio->FputInt32(drvreg);
-// state_fio->FputInt32(drvsel);
-// state_fio->FputBool(irq);
-// state_fio->FputBool(irqmsk);
-// state_fio->Fwrite(changed, sizeof(changed), 1);
-}
-
-bool FLOPPY::load_state(FILEIO* state_fio)
-{
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
- }
- if(!mb) {
- return false;
- }
-
-// if(state_fio->FgetUint32() != STATE_VERSION) {
-// return false;
-// }
-// if(state_fio->FgetInt32() != this_device_id) {
-// return false;
-// }
-// drvreg = state_fio->FgetInt32();
-// drvsel = state_fio->FgetInt32();
-// irq = state_fio->FgetBool();
-// irqmsk = state_fio->FgetBool();
-// state_fio->Fread(changed, sizeof(changed), 1);
- return true;
-}
-
bool FLOPPY::process_state(FILEIO* state_fio, bool loading)
{
if(!state_fio->StateCheckUint32(STATE_VERSION)) {
state_fio->StateInt32(drvsel);
state_fio->StateBool(irq);
state_fio->StateBool(irqmsk);
- state_fio->StateBuffer(changed, sizeof(changed), 1);
+ //state_fio->StateBuffer(changed, sizeof(changed), 1);
+ for(int i = 0; i < (sizeof(changed) / sizeof(bool)); i++) {
+ state_fio->StateBool(changed[i]);
+ }
return true;
}
void write_io8(uint32_t addr, uint32_t data);
uint32_t read_io8(uint32_t addr);
void write_signal(int id, uint32_t data, uint32_t mask);
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
+ bool process_state(FILEIO* state_fio, bool loading);
// unique functions
void set_context_fdc(MB8877* device)
#include "cmos.h"
#include "floppy.h"
#include "keyboard.h"
-#include "memory.h"
+#include "./memory.h"
#include "scsi.h"
//#include "serial.h"
#include "timer.h"
cmos = new CMOS(this, emu);
floppy = new FLOPPY(this, emu);
keyboard = new KEYBOARD(this, emu);
- memory = new MEMORY(this, emu);
+ memory = new FMR50_MEMORY(this, emu);
scsi = new SCSI(this, emu);
// serial = new SERIAL(this, emu);
timer = new TIMER(this, emu);
bios->set_hard_disk_handler(drv, scsi_hdd[drv]->get_disk_handler(0));
}
}
- decl_state();
}
VM::~VM()
#define STATE_VERSION 6
-#include "../../statesub.h"
-#include "../../qt/gui/csp_logger.h"
-extern CSP_Logger DLL_PREFIX_I *csp_logger;
-
-void VM::decl_state(void)
-{
-#if defined(_FMR50)
-# if defined(HAS_I286)
- state_entry = new csp_state_utils(STATE_VERSION, 0, (_TCHAR *)(_T("CSP::FMR_50_I286_HEAD")), csp_logger);
-# elif defined(HAS_I386)
- state_entry = new csp_state_utils(STATE_VERSION, 0, (_TCHAR *)(_T("CSP::FMR_50_I386_HEAD")), csp_logger);
-# elif defined(HAS_I486)
- state_entry = new csp_state_utils(STATE_VERSION, 0, (_TCHAR *)(_T("CSP::FMR_50_I486_HEAD")), csp_logger);
-# elif defined(HAS_PENTIUM)
- state_entry = new csp_state_utils(STATE_VERSION, 0, (_TCHAR *)(_T("CSP::FMR_250_HEAD")), csp_logger);
-# else
- state_entry = new csp_state_utils(STATE_VERSION, 0, (_TCHAR *)(_T("CSP::FMR_50_SERIES_HEAD")), csp_logger);
-# endif
-#elif defined(_FMR60)
-# if defined(HAS_I286)
- state_entry = new csp_state_utils(STATE_VERSION, 0, (_TCHAR *)(_T("CSP::FMR_60_HEAD")), csp_logger);
-# elif defined(HAS_I386)
- state_entry = new csp_state_utils(STATE_VERSION, 0, (_TCHAR *)(_T("CSP::FMR_70_HEAD")), csp_logger);
-# elif defined(HAS_I486)
- state_entry = new csp_state_utils(STATE_VERSION, 0, (_TCHAR *)(_T("CSP::FMR_80_HEAD")), csp_logger);
-# elif defined(HAS_PENTIUM)
- state_entry = new csp_state_utils(STATE_VERSION, 0, (_TCHAR *)(_T("CSP::FMR_280_HEAD")), csp_logger);
-# else
- state_entry = new csp_state_utils(STATE_VERSION, 0, (_TCHAR *)(_T("CSP::FMR_60_SERIES_HEAD")), csp_logger);
-# endif
-#endif
-
- for(DEVICE* device = first_device; device; device = device->next_device) {
- device->decl_state();
- }
-}
-
-void VM::save_state(FILEIO* state_fio)
-{
- //state_fio->FputUint32(STATE_VERSION);
-
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
- }
- for(DEVICE* device = first_device; device; device = device->next_device) {
- device->save_state(state_fio);
- }
-}
-
-bool VM::load_state(FILEIO* state_fio)
-{
- //if(state_fio->FgetUint32() != STATE_VERSION) {
- // return false;
- //}
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
- }
- if(!mb) {
- emu->out_debug_log("INFO: HEADER DATA ERROR");
- return false;
- }
- for(DEVICE* device = first_device; device; device = device->next_device) {
- if(!device->load_state(state_fio)) {
- return false;
- }
- }
- return true;
-}
-
bool VM::process_state(FILEIO* state_fio, bool loading)
{
if(!state_fio->StateCheckUint32(STATE_VERSION)) {
return false;
}
- for(DEVICE* device = first_device; device; device = device->next_device) {
- const char *name = typeid(*device).name() + 6; // skip "class "
+ for(DEVICE* device = first_device; device; device = device->next_device) {
+ // Note: typeid(foo).name is fixed by recent ABI.Not dec 6.
+ // const char *name = typeid(*device).name();
+ // But, using get_device_name() instead of typeid(foo).name() 20181008 K.O
+ const char *name = device->get_device_name();
int len = strlen(name);
if(!state_fio->StateCheckInt32(len)) {
+ if(loading) {
+ printf("Class name len Error: DEVID=%d EXPECT=%s\n", device->this_device_id, name);
+ }
return false;
}
if(!state_fio->StateCheckBuffer(name, len, 1)) {
- return false;
- }
+ if(loading) {
+ printf("Class name Error: DEVID=%d EXPECT=%s\n", device->this_device_id, name);
+ }
+ return false;
+ }
if(!device->process_state(state_fio, loading)) {
- return false;
- }
- }
+ if(loading) {
+ printf("Data loading Error: DEVID=%d\n", device->this_device_id);
+ }
+ return false;
+ }
+ }
+ // Machine specified.
return true;
}
class CMOS;
class FLOPPY;
class KEYBOARD;
-class MEMORY;
+class FMR50_MEMORY;
//class SERIAL;
class SCSI;
class TIMER;
CMOS* cmos;
FLOPPY* floppy;
KEYBOARD* keyboard;
- MEMORY* memory;
+ FMR50_MEMORY* memory;
SCSI* scsi;
// SERIAL* serial;
TIMER* timer;
bool is_frame_skippable();
void update_config();
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
+ bool process_state(FILEIO* state_fio, bool loading);
// ----------------------------------------
// for each device
#define STATE_VERSION 1
-#include "../../statesub.h"
-
-void KEYBOARD::decl_state()
-{
- enter_decl_state(STATE_VERSION);
-
- DECL_STATE_ENTRY_FIFO(key_buf);
- DECL_STATE_ENTRY_UINT8(kbstat);
- DECL_STATE_ENTRY_UINT8(kbdata);
- DECL_STATE_ENTRY_UINT8(kbint);
- DECL_STATE_ENTRY_UINT8(kbmsk);
- DECL_STATE_ENTRY_1D_ARRAY(table, sizeof(table));
-
- leave_decl_state();
-}
-
-void KEYBOARD::save_state(FILEIO* state_fio)
-{
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
- }
-
-// state_fio->FputUint32(STATE_VERSION);
-// state_fio->FputInt32(this_device_id);
-
-// key_buf->save_state((void *)state_fio);
-// state_fio->FputUint8(kbstat);
-// state_fio->FputUint8(kbdata);
-// state_fio->FputUint8(kbint);
-// state_fio->FputUint8(kbmsk);
-// state_fio->Fwrite(table, sizeof(table), 1);
-}
-
-bool KEYBOARD::load_state(FILEIO* state_fio)
-{
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
- }
- if(!mb) {
- return false;
- }
-
-// if(state_fio->FgetUint32() != STATE_VERSION) {
-// return false;
-// }
-// if(state_fio->FgetInt32() != this_device_id) {
-// return false;
-// }
-// if(!key_buf->load_state((void *)state_fio)) {
-// return false;
-// }
-// kbstat = state_fio->FgetUint8();
-// kbdata = state_fio->FgetUint8();
-// kbint = state_fio->FgetUint8();
-// kbmsk = state_fio->FgetUint8();
-// state_fio->Fread(table, sizeof(table), 1);
- return true;
-}
-
bool KEYBOARD::process_state(FILEIO* state_fio, bool loading)
{
if(!state_fio->StateCheckUint32(STATE_VERSION)) {
void write_io8(uint32_t addr, uint32_t data);
uint32_t read_io8(uint32_t addr);
void event_frame();
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
+ bool process_state(FILEIO* state_fio, bool loading);
// unique functions
void set_context_pic(DEVICE* device)
[ memory and crtc ]
*/
-#include "memory.h"
+#include "./memory.h"
#if defined(HAS_I286)
#include "../i286.h"
#else
} \
}
-void MEMORY::initialize()
+void FMR50_MEMORY::initialize()
{
// init memory
memset(ram, 0, sizeof(ram));
register_frame_event(this);
}
-void MEMORY::reset()
+void FMR50_MEMORY::reset()
{
// reset memory
protect = rst = 0;
d_cpu->set_address_mask(0x00ffffff);
}
-void MEMORY::write_data8(uint32_t addr, uint32_t data)
+void FMR50_MEMORY::write_data8(uint32_t addr, uint32_t data)
{
if(addr & 0xff000000) {
// > 16MB
wbank[addr >> 11][addr & 0x7ff] = data;
}
-uint32_t MEMORY::read_data8(uint32_t addr)
+uint32_t FMR50_MEMORY::read_data8(uint32_t addr)
{
if(addr & 0xff000000) {
// > 16MB
return rbank[addr >> 11][addr & 0x7ff];
}
-void MEMORY::write_dma_data8(uint32_t addr, uint32_t data)
+void FMR50_MEMORY::write_dma_data8(uint32_t addr, uint32_t data)
{
write_data8(addr & dma_addr_mask, data);
}
-uint32_t MEMORY::read_dma_data8(uint32_t addr)
+uint32_t FMR50_MEMORY::read_dma_data8(uint32_t addr)
{
return read_data8(addr & dma_addr_mask);
}
-void MEMORY::write_io8(uint32_t addr, uint32_t data)
+void FMR50_MEMORY::write_io8(uint32_t addr, uint32_t data)
{
switch(addr & 0xffff) {
case 0x20:
}
}
-uint32_t MEMORY::read_io8(uint32_t addr)
+uint32_t FMR50_MEMORY::read_io8(uint32_t addr)
{
uint32_t val = 0xff;
return 0xff;
}
-void MEMORY::write_signal(int id, uint32_t data, uint32_t mask)
+void FMR50_MEMORY::write_signal(int id, uint32_t data, uint32_t mask)
{
if(id == SIG_MEMORY_DISP) {
disp = ((data & mask) != 0);
}
}
-void MEMORY::event_frame()
+void FMR50_MEMORY::event_frame()
{
blink++;
}
-void MEMORY::update_bank()
+void FMR50_MEMORY::update_bank()
{
if(!mainmem) {
#ifdef _FMR60
}
}
-void MEMORY::update_dma_addr_mask()
+void FMR50_MEMORY::update_dma_addr_mask()
{
switch(dma_addr_reg & 3) {
case 0:
}
#ifndef _FMR60
-void MEMORY::point(int x, int y, int col)
+void FMR50_MEMORY::point(int x, int y, int col)
{
if(x < 640 && y < 400) {
int ofs = ((lofs & 0x3fff) + (x >> 3) + y * 80) & 0x7fff;
}
}
-void MEMORY::line()
+void FMR50_MEMORY::line()
{
int nx = lsx, ny = lsy;
int dx = abs(lex - lsx) * 2;
}
#endif
-void MEMORY::draw_screen()
+void FMR50_MEMORY::draw_screen()
{
// render screen
memset(screen_txt, 0, sizeof(screen_txt));
}
#ifdef _FMR60
-void MEMORY::draw_text()
+void FMR50_MEMORY::draw_text()
{
int src = ((chreg[12] << 9) | (chreg[13] << 1)) & 0x1fff;
int caddr = ((chreg[8] & 0xc0) == 0xc0) ? -1 : (((chreg[14] << 9) | (chreg[15] << 1)) & 0x1fff);
}
}
#else
-void MEMORY::draw_text40()
+void FMR50_MEMORY::draw_text40()
{
int src = ((chreg[12] << 9) | (chreg[13] << 1)) & 0xfff;
int caddr = ((chreg[8] & 0xc0) == 0xc0) ? -1 : (((chreg[14] << 9) | (chreg[15] << 1) | (mix & 0x20 ? 1 : 0)) & 0x7ff);
}
}
-void MEMORY::draw_text80()
+void FMR50_MEMORY::draw_text80()
{
int src = ((chreg[12] << 9) | (chreg[13] << 1)) & 0xfff;
int caddr = ((chreg[8] & 0xc0) == 0xc0) ? -1 : (((chreg[14] << 9) | (chreg[15] << 1) | (mix & 0x20 ? 1 : 0)) & 0x7ff);
}
#endif
-void MEMORY::draw_cg()
+void FMR50_MEMORY::draw_cg()
{
#ifdef _FMR60
uint8_t* p0 = &vram[0x00000];
#define STATE_VERSION 1
-#include "../../statesub.h"
-
-void MEMORY::decl_state()
-{
- enter_decl_state(STATE_VERSION);
-
- DECL_STATE_ENTRY_1D_ARRAY(ram, sizeof(ram));
- DECL_STATE_ENTRY_1D_ARRAY(vram, sizeof(vram));
- DECL_STATE_ENTRY_1D_ARRAY(cvram, sizeof(cvram));
-#ifdef _FMR60
- DECL_STATE_ENTRY_1D_ARRAY(avram, sizeof(avram));
-#else
- DECL_STATE_ENTRY_1D_ARRAY(kvram, sizeof(kvram));
-#endif
- DECL_STATE_ENTRY_UINT8(machine_id);
- DECL_STATE_ENTRY_UINT8(protect);
- DECL_STATE_ENTRY_UINT8(rst);
- DECL_STATE_ENTRY_UINT8(mainmem);
- DECL_STATE_ENTRY_UINT8(rplane);
- DECL_STATE_ENTRY_UINT8(wplane);
- DECL_STATE_ENTRY_UINT8(dma_addr_reg);
- DECL_STATE_ENTRY_UINT8(dma_wrap_reg);
- DECL_STATE_ENTRY_UINT32(dma_addr_mask);
- DECL_STATE_ENTRY_BOOL(disp);
- DECL_STATE_ENTRY_BOOL(vsync);
- DECL_STATE_ENTRY_INT32(blink);
- DECL_STATE_ENTRY_2D_ARRAY(apal, 16, 3);
- DECL_STATE_ENTRY_UINT8(apalsel);
- DECL_STATE_ENTRY_1D_ARRAY(dpal, sizeof(dpal));
- DECL_STATE_ENTRY_UINT8(outctrl);
-#ifndef _FMR60
- DECL_STATE_ENTRY_UINT8(pagesel);
- DECL_STATE_ENTRY_UINT8(ankcg);
- DECL_STATE_ENTRY_UINT8(dispctrl);
- DECL_STATE_ENTRY_UINT8(mix);
- DECL_STATE_ENTRY_UINT16(accaddr);
- DECL_STATE_ENTRY_UINT16(dispaddr);
- DECL_STATE_ENTRY_INT32(kj_h);
- DECL_STATE_ENTRY_INT32(kj_l);
- DECL_STATE_ENTRY_INT32(kj_ofs);
- DECL_STATE_ENTRY_INT32(kj_row);
- DECL_STATE_ENTRY_UINT8(cmdreg);
- DECL_STATE_ENTRY_UINT8(imgcol);
- DECL_STATE_ENTRY_UINT8(maskreg);
- DECL_STATE_ENTRY_1D_ARRAY(compreg, sizeof(compreg));
- DECL_STATE_ENTRY_UINT8(compbit);
- DECL_STATE_ENTRY_UINT8(bankdis);
- DECL_STATE_ENTRY_1D_ARRAY(tilereg, sizeof(tilereg));
- DECL_STATE_ENTRY_UINT16(lofs);
- DECL_STATE_ENTRY_UINT16(lsty);
- DECL_STATE_ENTRY_UINT16(lsx);
- DECL_STATE_ENTRY_UINT16(lsy);
- DECL_STATE_ENTRY_UINT16(lex);
- DECL_STATE_ENTRY_UINT16(ley);
-#endif
- // ToDo: Generate Generic value(s).
- DECL_STATE_ENTRY_SCRNTYPE_T_1D_ARRAY(palette_cg, sizeof(palette_cg) / sizeof(scrntype_t));
- leave_decl_state();
-}
-
-void MEMORY::save_state(FILEIO* state_fio)
-{
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
- }
-
-// state_fio->FputUint32(STATE_VERSION);
-// state_fio->FputInt32(this_device_id);
-
-// state_fio->Fwrite(ram, sizeof(ram), 1);
-// state_fio->Fwrite(vram, sizeof(vram), 1);
-// state_fio->Fwrite(cvram, sizeof(cvram), 1);
-//#ifdef _FMR60
-// state_fio->Fwrite(avram, sizeof(avram), 1);
-//#else
-// state_fio->Fwrite(kvram, sizeof(kvram), 1);
-//#endif
-// state_fio->FputUint8(machine_id);
-// state_fio->FputUint8(protect);
-// state_fio->FputUint8(rst);
-// state_fio->FputUint8(mainmem);
-// state_fio->FputUint8(rplane);
-// state_fio->FputUint8(wplane);
-// state_fio->FputUint8(dma_addr_reg);
-// state_fio->FputUint8(dma_wrap_reg);
-// state_fio->FputUint32(dma_addr_mask);
-// state_fio->FputBool(disp);
-// state_fio->FputBool(vsync);
-// state_fio->FputInt32(blink);
-// state_fio->Fwrite(apal, sizeof(apal), 1);
-// state_fio->FputUint8(apalsel);
-// state_fio->Fwrite(dpal, sizeof(dpal), 1);
-// state_fio->FputUint8(outctrl);
-//#ifndef _FMR60
-// state_fio->FputUint8(pagesel);
-// state_fio->FputUint8(ankcg);
-// state_fio->FputUint8(dispctrl);
-// state_fio->FputUint8(mix);
-// state_fio->FputUint16(accaddr);
-// state_fio->FputUint16(dispaddr);
-// state_fio->FputInt32(kj_h);
-// state_fio->FputInt32(kj_l);
-// state_fio->FputInt32(kj_ofs);
-// state_fio->FputInt32(kj_row);
-// state_fio->FputUint8(cmdreg);
-// state_fio->FputUint8(imgcol);
-// state_fio->FputUint8(maskreg);
-// state_fio->Fwrite(compreg, sizeof(compreg), 1);
-// state_fio->FputUint8(compbit);
-// state_fio->FputUint8(bankdis);
-// state_fio->Fwrite(tilereg, sizeof(tilereg), 1);
-// state_fio->FputUint16(lofs);
-// state_fio->FputUint16(lsty);
-// state_fio->FputUint16(lsx);
-// state_fio->FputUint16(lsy);
-// state_fio->FputUint16(lex);
-// state_fio->FputUint16(ley);
-//#endif
-// state_fio->Fwrite(palette_cg, sizeof(palette_cg), 1);
-}
-
-bool MEMORY::load_state(FILEIO* state_fio)
-{
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
- }
- if(!mb) {
- return false;
- }
-
-// if(state_fio->FgetUint32() != STATE_VERSION) {
-// return false;
-// }
-// if(state_fio->FgetInt32() != this_device_id) {
-// return false;
-// }
-// state_fio->Fread(ram, sizeof(ram), 1);
-// state_fio->Fread(vram, sizeof(vram), 1);
-// state_fio->Fread(cvram, sizeof(cvram), 1);
-//#ifdef _FMR60
-// state_fio->Fread(avram, sizeof(avram), 1);
-//#else
-// state_fio->Fread(kvram, sizeof(kvram), 1);
-//#endif
-// machine_id = state_fio->FgetUint8();
-// protect = state_fio->FgetUint8();
-// rst = state_fio->FgetUint8();
-// mainmem = state_fio->FgetUint8();
-// rplane = state_fio->FgetUint8();
-// wplane = state_fio->FgetUint8();
-// dma_addr_reg = state_fio->FgetUint8();
-// dma_wrap_reg = state_fio->FgetUint8();
-// dma_addr_mask = state_fio->FgetUint32();
-// disp = state_fio->FgetBool();
-// vsync = state_fio->FgetBool();
-// blink = state_fio->FgetInt32();
-// state_fio->Fread(apal, sizeof(apal), 1);
-// apalsel = state_fio->FgetUint8();
-// state_fio->Fread(dpal, sizeof(dpal), 1);
-// outctrl = state_fio->FgetUint8();
-//#ifndef _FMR60
-// pagesel = state_fio->FgetUint8();
-// ankcg = state_fio->FgetUint8();
-// dispctrl = state_fio->FgetUint8();
-// mix = state_fio->FgetUint8();
-// accaddr = state_fio->FgetUint16();
-// dispaddr = state_fio->FgetUint16();
-// kj_h = state_fio->FgetInt32();
-// kj_l = state_fio->FgetInt32();
-// kj_ofs = state_fio->FgetInt32();
-// kj_row = state_fio->FgetInt32();
-// cmdreg = state_fio->FgetUint8();
-// imgcol = state_fio->FgetUint8();
-// maskreg = state_fio->FgetUint8();
-// state_fio->Fread(compreg, sizeof(compreg), 1);
-// compbit = state_fio->FgetUint8();
-// bankdis = state_fio->FgetUint8();
-// state_fio->Fread(tilereg, sizeof(tilereg), 1);
-// lofs = state_fio->FgetUint16();
-// lsty = state_fio->FgetUint16();
-// lsx = state_fio->FgetUint16();
-// lsy = state_fio->FgetUint16();
-// lex = state_fio->FgetUint16();
-// ley = state_fio->FgetUint16();
-//#endif
-// state_fio->Fread(palette_cg, sizeof(palette_cg), 1);
-
- // post process
- update_bank();
- return true;
-}
-
-bool MEMORY::process_state(FILEIO* state_fio, bool loading)
+bool FMR50_MEMORY::process_state(FILEIO* state_fio, bool loading)
{
if(!state_fio->StateCheckUint32(STATE_VERSION)) {
return false;
state_fio->StateUint16(lex);
state_fio->StateUint16(ley);
#endif
- state_fio->StateBuffer(palette_cg, sizeof(palette_cg), 1);
-
+ //state_fio->StateBuffer(palette_cg, sizeof(palette_cg), 1);
+ if(loading) {
+ for(int i = 0; i < (sizeof(palette_cg) / sizeof(scrntype_t)); i++) {
+ uint8_t r, g, b;
+ r = state_fio->FgetUint8();
+ g = state_fio->FgetUint8();
+ b = state_fio->FgetUint8();
+ palette_cg[i] = RGB_COLOR(r, g, b);
+ }
+ } else {
+ for(int i = 0; i < (sizeof(palette_cg) / sizeof(scrntype_t)); i++) {
+ uint8_t r, g, b;
+ r = R_OF_COLOR(palette_cg[i]);
+ g = G_OF_COLOR(palette_cg[i]);
+ b = B_OF_COLOR(palette_cg[i]);
+ state_fio->FputUint8(r);
+ state_fio->FputUint8(g);
+ state_fio->FputUint8(b);
+ }
+ }
+ if(loading) {
+ for(int i = 0; i < (sizeof(palette_txt) / sizeof(scrntype_t)); i++) {
+ uint8_t r, g, b;
+ r = state_fio->FgetUint8();
+ g = state_fio->FgetUint8();
+ b = state_fio->FgetUint8();
+ palette_txt[i] = RGB_COLOR(r, g, b);
+ }
+ } else {
+ for(int i = 0; i < (sizeof(palette_txt) / sizeof(scrntype_t)); i++) {
+ uint8_t r, g, b;
+ r = R_OF_COLOR(palette_txt[i]);
+ g = G_OF_COLOR(palette_txt[i]);
+ b = B_OF_COLOR(palette_txt[i]);
+ state_fio->FputUint8(r);
+ state_fio->FputUint8(g);
+ state_fio->FputUint8(b);
+ }
+ }
// post process
if(loading) {
update_bank();
[ memory ]
*/
-#ifndef _MEMORY_H_
-#define _MEMORY_H_
+#ifndef _FMR50_MEMORY_H_
+#define _FMR50_MEMORY_H_
#include "../vm.h"
#include "../../emu.h"
class I386;
#endif
-class MEMORY : public DEVICE
+class FMR50_MEMORY : public DEVICE
{
private:
#if defined(HAS_I286)
void draw_cg();
public:
- MEMORY(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
+ FMR50_MEMORY(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
{
set_device_name(_T("Memory Bus"));
}
- ~MEMORY() {}
+ ~FMR50_MEMORY() {}
// common functions
void initialize();
uint32_t read_io8(uint32_t addr);
void write_signal(int id, uint32_t data, uint32_t mask);
void event_frame();
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
+ bool process_state(FILEIO* state_fio, bool loading);
// unique functions
#if defined(HAS_I286)
#define STATE_VERSION 1
-#include "../../statesub.h"
-
-void SCSI::decl_state()
-{
- enter_decl_state(STATE_VERSION);
-
- DECL_STATE_ENTRY_UINT8(ctrl_reg);
- DECL_STATE_ENTRY_BOOL(irq_status);
-
- leave_decl_state();
-}
-
-void SCSI::save_state(FILEIO* state_fio)
-{
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
- }
-
-// state_fio->FputUint32(STATE_VERSION);
-// state_fio->FputInt32(this_device_id);
-
-// state_fio->FputUint8(ctrl_reg);
-// state_fio->FputBool(irq_status);
-}
-
-bool SCSI::load_state(FILEIO* state_fio)
-{
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
- }
- if(!mb) {
- return false;
- }
-
-// if(state_fio->FgetUint32() != STATE_VERSION) {
-// return false;
-// }
-// if(state_fio->FgetInt32() != this_device_id) {
-// return false;
-// }
-// ctrl_reg = state_fio->FgetUint8();
-// irq_status = state_fio->FgetBool();
- return true;
-}
-
bool SCSI::process_state(FILEIO* state_fio, bool loading)
{
if(!state_fio->StateCheckUint32(STATE_VERSION)) {
{
d_host = device;
}
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
};
#endif
#define STATE_VERSION 1
-#include "../statesub.h"
-
-void TIMER::decl_state()
-{
- enter_decl_state(STATE_VERSION);
-
- DECL_STATE_ENTRY_UINT16(free_run_counter);
- DECL_STATE_ENTRY_UINT8(intr_reg);
- DECL_STATE_ENTRY_UINT8(rtc_data);
- DECL_STATE_ENTRY_BOOL(tmout0);
- DECL_STATE_ENTRY_BOOL(tmout1);
-
- leave_decl_state();
-}
-void TIMER::save_state(FILEIO* state_fio)
-{
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
- }
-// state_fio->FputUint32(STATE_VERSION);
-// state_fio->FputInt32(this_device_id);
-
-// state_fio->FputUint16(free_run_counter);
-// state_fio->FputUint8(intr_reg);
-// state_fio->FputUint8(rtc_data);
-// state_fio->FputBool(tmout0);
-// state_fio->FputBool(tmout1);
-}
-
-bool TIMER::load_state(FILEIO* state_fio)
-{
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
- }
- if(!mb) return false;
-// if(state_fio->FgetUint32() != STATE_VERSION) {
-// return false;
-// }
-// if(state_fio->FgetInt32() != this_device_id) {
-// return false;
-// }
-// free_run_counter = state_fio->FgetUint16();
-// intr_reg = state_fio->FgetUint8();
-// rtc_data = state_fio->FgetUint8();
-// tmout0 = state_fio->FgetBool();
-// tmout1 = state_fio->FgetBool();
- return true;
-}
-
bool TIMER::process_state(FILEIO* state_fio, bool loading)
{
if(!state_fio->StateCheckUint32(STATE_VERSION)) {
void write_io8(uint32_t addr, uint32_t data);
uint32_t read_io8(uint32_t addr);
void write_signal(int id, uint32_t data, uint32_t mask);
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
+ bool process_state(FILEIO* state_fio, bool loading);
// unique functions
void set_context_pcm(DEVICE* device)
#endif
#include "keyboard.h"
-#include "memory.h"
+#include "./memory.h"
#include "system.h"
// ----------------------------------------------------------------------------
cpu = new Z80(this, emu);
key = new KEYBOARD(this, emu);
- memory = new MEMORY(this, emu);
+ memory = new SMS_MEMORY(this, emu);
system = new SYSTEM(this, emu);
// set contexts
event->set_context_cpu(cpu);
if(!state_fio->StateCheckUint32(STATE_VERSION)) {
return false;
}
- for(DEVICE* device = first_device; device; device = device->next_device) {
- const char *name = typeid(*device).name() + 6; // skip "class "
- int len = strlen(name);
-
- if(!state_fio->StateCheckInt32(len)) {
- return false;
- }
- if(!state_fio->StateCheckBuffer(name, len, 1)) {
- return false;
- }
- if(!device->process_state(state_fio, loading)) {
- return false;
- }
- }
- return true;
-}
-
-bool VM::process_state(FILEIO* state_fio, bool loading)
-{
- if(!state_fio->StateCheckUint32(STATE_VERSION)) {
- return false;
- }
- for(DEVICE* device = first_device; device; device = device->next_device) {
- const char *name = typeid(*device).name() + 6; // skip "class "
+ for(DEVICE* device = first_device; device; device = device->next_device) {
+ // Note: typeid(foo).name is fixed by recent ABI.Not dec 6.
+ // const char *name = typeid(*device).name();
+ // But, using get_device_name() instead of typeid(foo).name() 20181008 K.O
+ const char *name = device->get_device_name();
int len = strlen(name);
if(!state_fio->StateCheckInt32(len)) {
+ if(loading) {
+ printf("Class name len Error: DEVID=%d EXPECT=%s\n", device->this_device_id, name);
+ }
return false;
}
if(!state_fio->StateCheckBuffer(name, len, 1)) {
- return false;
- }
+ if(loading) {
+ printf("Class name Error: DEVID=%d EXPECT=%s\n", device->this_device_id, name);
+ }
+ return false;
+ }
if(!device->process_state(state_fio, loading)) {
- return false;
- }
- }
+ if(loading) {
+ printf("Data loading Error: DEVID=%d\n", device->this_device_id);
+ }
+ return false;
+ }
+ }
return true;
}
class Z80;
class KEYBOARD;
-class MEMORY;
+class SMS_MEMORY;
class SYSTEM;
class VM : public VM_TEMPLATE
Z80* cpu;
KEYBOARD* key;
- MEMORY* memory;
+ SMS_MEMORY* memory;
SYSTEM* system;
public:
#endif
#include "keyboard.h"
-#include "memory.h"
+#include "./memory.h"
#include "system.h"
// ----------------------------------------------------------------------------
cpu = new Z80(this, emu);
key = new KEYBOARD(this, emu);
- memory = new MEMORY(this, emu);
+ memory = new SMS_MEMORY(this, emu);
system = new SYSTEM(this, emu);
// set contexts
if(!state_fio->StateCheckUint32(STATE_VERSION)) {
return false;
}
- for(DEVICE* device = first_device; device; device = device->next_device) {
- const char *name = typeid(*device).name() + 6; // skip "class "
+ for(DEVICE* device = first_device; device; device = device->next_device) {
+ // Note: typeid(foo).name is fixed by recent ABI.Not dec 6.
+ // const char *name = typeid(*device).name();
+ // But, using get_device_name() instead of typeid(foo).name() 20181008 K.O
+ const char *name = device->get_device_name();
int len = strlen(name);
if(!state_fio->StateCheckInt32(len)) {
+ if(loading) {
+ printf("Class name len Error: DEVID=%d EXPECT=%s\n", device->this_device_id, name);
+ }
return false;
}
if(!state_fio->StateCheckBuffer(name, len, 1)) {
- return false;
- }
+ if(loading) {
+ printf("Class name Error: DEVID=%d EXPECT=%s\n", device->this_device_id, name);
+ }
+ return false;
+ }
if(!device->process_state(state_fio, loading)) {
- return false;
- }
- }
+ if(loading) {
+ printf("Data loading Error: DEVID=%d\n", device->this_device_id);
+ }
+ return false;
+ }
+ }
+ // Machine specified.
return true;
}
-bool VM::process_state(FILEIO* state_fio, bool loading)
-{
- if(!state_fio->StateCheckUint32(STATE_VERSION)) {
- return false;
- }
- for(DEVICE* device = first_device; device; device = device->next_device) {
- const char *name = typeid(*device).name() + 6; // skip "class "
- int len = strlen(name);
-
- if(!state_fio->StateCheckInt32(len)) {
- return false;
- }
- if(!state_fio->StateCheckBuffer(name, len, 1)) {
- return false;
- }
- if(!device->process_state(state_fio, loading)) {
- return false;
- }
- }
- return true;
-}
class Z80;
class KEYBOARD;
-class MEMORY;
+class SMS_MEMORY;
class SYSTEM;
class VM : public VM_TEMPLATE
Z80* cpu;
KEYBOARD* key;
- MEMORY* memory;
+ SMS_MEMORY* memory;
SYSTEM* system;
public:
#include "memory.h"
-void MEMORY::sms_mapper_w(uint32_t addr, uint32_t data)
+void SMS_MEMORY::sms_mapper_w(uint32_t addr, uint32_t data)
{
/* Calculate ROM page index */
uint8_t page = (data % pages);
}
}
-void MEMORY::initialize()
+void SMS_MEMORY::initialize()
{
cart=NULL;
inserted = false;
}
-void MEMORY::release()
+void SMS_MEMORY::release()
{
if (cart) free(cart);
}
-void MEMORY::bios()
+void SMS_MEMORY::bios()
{
FILEIO* fio = new FILEIO();
delete fio;
}
-void MEMORY::write_data8(uint32_t addr, uint32_t data)
+void SMS_MEMORY::write_data8(uint32_t addr, uint32_t data)
{
cpu_writemap[(addr >> 13)][(addr & 0x1FFF)] = data;
if (pages < 4) return;
if (addr >= 0xFFFC) sms_mapper_w(addr & 3, data);
}
-uint32_t MEMORY::read_data8(uint32_t addr)
+uint32_t SMS_MEMORY::read_data8(uint32_t addr)
{
return cpu_readmap[(addr >> 13)][(addr & 0x1FFF)];
}
-void MEMORY::write_signal(int id, uint32_t data, uint32_t mask)
+void SMS_MEMORY::write_signal(int id, uint32_t data, uint32_t mask)
{
// from PIO-P6
if(data & mask) {
}
}
-void MEMORY::open_cart(const _TCHAR* file_path)
+void SMS_MEMORY::open_cart(const _TCHAR* file_path)
{
FILEIO* fio = new FILEIO();
fcr[3] = 0x00;
}
-void MEMORY::close_cart()
+void SMS_MEMORY::close_cart()
{
if (cart) free(cart);
initialize();
[ memory ]
*/
-#ifndef _MEMORY_H_
-#define _MEMORY_H_
+#ifndef _SMS_MEMORY_H_
+#define _SMS_MEMORY_H_
#include "../vm.h"
#include "../../emu.h"
#define SIG_MEMORY_SEL 0
-class MEMORY : public DEVICE
+class SMS_MEMORY : public DEVICE
{
private:
DEVICE *d_cpu;
void sms_mapper_w(uint32_t addr, uint32_t data);
public:
- MEMORY(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
+ SMS_MEMORY(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
{
set_device_name(_T("Memory Bus"));
}
- ~MEMORY() {}
+ ~SMS_MEMORY() {}
// common functions
void initialize();
#define STATE_VERSION 1
-#include "../../statesub.h"
-
-void JOYSTICK::decl_state()
-{
- enter_decl_state(STATE_VERSION);
-
- DECL_STATE_ENTRY_INT32(select);
-
- leave_decl_state();
-}
-
-void JOYSTICK::save_state(FILEIO* state_fio)
-{
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
- }
-// state_fio->FputUint32(STATE_VERSION);
-// state_fio->FputInt32(this_device_id);
-
-// state_fio->FputInt32(select);
-}
-
-bool JOYSTICK::load_state(FILEIO* state_fio)
-{
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
- }
- if(!mb) {
- return false;
- }
-// if(state_fio->FgetUint32() != STATE_VERSION) {
-// return false;
-// }
-// if(state_fio->FgetInt32() != this_device_id) {
-// return false;
-// }
-// select = state_fio->FgetInt32();
- return true;
-}
-
bool JOYSTICK::process_state(FILEIO* state_fio, bool loading)
{
if(!state_fio->StateCheckUint32(STATE_VERSION)) {
void initialize();
void event_frame();
void write_signal(int id, uint32_t data, uint32_t mask);
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
+ bool process_state(FILEIO* state_fio, bool loading);
// unique function
void set_context_psg(DEVICE* device)
#define STATE_VERSION 2
-#include "../../statesub.h"
-
-void KEYBOARD::decl_state()
-{
- enter_decl_state(STATE_VERSION);
-
- DECL_STATE_ENTRY_UINT8(column);
-// DECL_STATE_ENTRY_BOOL(break_pressed);
- leave_decl_state();
-}
-
-void KEYBOARD::save_state(FILEIO* state_fio)
-{
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
- }
-// state_fio->FputUint32(STATE_VERSION);
-// state_fio->FputInt32(this_device_id);
-
-// state_fio->FputUint8(column);
-//// state_fio->FputBool(break_pressed);
-}
-
-bool KEYBOARD::load_state(FILEIO* state_fio)
-{
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
- }
- if(!mb) {
- return false;
- }
-// if(state_fio->FgetUint32() != STATE_VERSION) {
-// return false;
-// }
-// if(state_fio->FgetInt32() != this_device_id) {
-// return false;
-// }
-// column = state_fio->FgetUint8();
-//// break_pressed = state_fio->FgetBool();
- return true;
-}
-
bool KEYBOARD::process_state(FILEIO* state_fio, bool loading)
{
if(!state_fio->StateCheckUint32(STATE_VERSION)) {
void initialize();
void event_frame();
void write_signal(int id, uint32_t data, uint32_t mask);
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
+ bool process_state(FILEIO* state_fio, bool loading);
// unique functions
// void set_context_cpu(DEVICE* device)
// memory bus
#if !defined(_PX7)
-void MEMORY::initialize()
+void MSX_MEMORY::initialize()
{
for(int i = 0; i < MAX_DRIVE; i++) {
disk[i] = new DISK(emu);
}
}
-void MEMORY::release()
+void MSX_MEMORY::release()
{
for(int i = 0; i < MAX_DRIVE; i++) {
if(disk[i]) {
}
#endif
-void MEMORY::reset()
+void MSX_MEMORY::reset()
{
#if !defined(_PX7)
for(int i = 0; i < MAX_DRIVE; i++) {
update_map((0 << 0) | (1 << 2) | (2 << 4) | (3 << 6));
}
-void MEMORY::write_data8(uint32_t addr, uint32_t data)
+void MSX_MEMORY::write_data8(uint32_t addr, uint32_t data)
{
addr &= 0xffff;
d_map[addr >> 14]->write_data8(addr, data);
}
-uint32_t MEMORY::read_data8(uint32_t addr)
+uint32_t MSX_MEMORY::read_data8(uint32_t addr)
{
addr &= 0xffff;
return d_map[addr >> 14]->read_data8(addr);
}
-uint32_t MEMORY::fetch_op(uint32_t addr, int* wait)
+uint32_t MSX_MEMORY::fetch_op(uint32_t addr, int* wait)
{
*wait = 1;
return read_data8(addr);
}
-void MEMORY::write_io8(uint32_t addr, uint32_t data)
+void MSX_MEMORY::write_io8(uint32_t addr, uint32_t data)
{
#if !defined(_PX7)
// if(d_map[3] == d_slot[3]) {
#endif
}
-void MEMORY::write_signal(int id, uint32_t data, uint32_t mask)
+void MSX_MEMORY::write_signal(int id, uint32_t data, uint32_t mask)
{
if(id == SIG_MEMORY_SEL) {
if(slot_select != (data & mask)) {
}
}
-void MEMORY::update_map(uint32_t val)
+void MSX_MEMORY::update_map(uint32_t val)
{
d_map[0] = d_slot[(val >> 0) & 3];
d_map[1] = d_slot[(val >> 2) & 3];
return false;
}
-uint32_t MEMORY::read_signal(int id)
+uint32_t MSX_MEMORY::read_signal(int id)
{
uint32_t stat = 0;
for(int i = 0; i < MAX_DRIVE; i++) {
return stat;
}
-bool MEMORY::bios_ret_z80(uint16_t PC, pair_t* af, pair_t* bc, pair_t* de, pair_t* hl, pair_t* ix, pair_t* iy, uint8_t* iff1)
+bool MSX_MEMORY::bios_ret_z80(uint16_t PC, pair_t* af, pair_t* bc, pair_t* de, pair_t* hl, pair_t* ix, pair_t* iy, uint8_t* iff1)
{
#define AF af->w.l
#define A af->b.h
return false;
}
-void MEMORY::open_disk(int drv, const _TCHAR* file_path, int bank)
+void MSX_MEMORY::open_disk(int drv, const _TCHAR* file_path, int bank)
{
if(drv < MAX_DRIVE) {
disk[drv]->open(file_path, bank);
}
}
-void MEMORY::close_disk(int drv)
+void MSX_MEMORY::close_disk(int drv)
{
if(drv < MAX_DRIVE && disk[drv]->inserted) {
disk[drv]->close();
}
}
-bool MEMORY::is_disk_inserted(int drv)
+bool MSX_MEMORY::is_disk_inserted(int drv)
{
if(drv < MAX_DRIVE) {
return disk[drv]->inserted;
return false;
}
-void MEMORY::is_disk_protected(int drv, bool value)
+void MSX_MEMORY::is_disk_protected(int drv, bool value)
{
if(drv < MAX_DRIVE) {
disk[drv]->write_protected = value;
}
}
-bool MEMORY::is_disk_protected(int drv)
+bool MSX_MEMORY::is_disk_protected(int drv)
{
if(drv < MAX_DRIVE) {
return disk[drv]->write_protected;
#define STATE_VERSION 1
-bool MEMORY::process_state(FILEIO* state_fio, bool loading)
+bool MSX_MEMORY::process_state(FILEIO* state_fio, bool loading)
{
if(!state_fio->StateCheckUint32(STATE_VERSION)) {
return false;
return true;
}
-bool SLOT0::process_state(FILEIO* state_fio, bool loading)
-{
- if(!state_fio->StateCheckUint32(SLOT0_STATE_VERSION)) {
- return false;
- }
- if(!state_fio->StateCheckInt32(this_device_id)) {
- return false;
- }
-#if defined(_PX7)
- state_fio->StateBuffer(ram, sizeof(ram), 1);
-#endif
- return true;
-}
-bool SLOT1::process_state(FILEIO* state_fio, bool loading)
-{
- if(!state_fio->StateCheckUint32(SLOT1_STATE_VERSION)) {
- return false;
- }
- if(!state_fio->StateCheckInt32(this_device_id)) {
- return false;
- }
- state_fio->StateBool(inserted);
-#if defined(_MSX2)
- state_fio->StateBuffer(mapper, sizeof(mapper), 1);
-#endif
-
- // post process
- if(loading) {
- if(inserted) {
- SET_BANK(0x0000, 0xffff, wdmy, rom);
-#if defined(_MSX2)
- } else if(mapper[0] < 4) {
- SET_BANK(0x0000, 0x3fff, wdmy, rdmy);
- SET_BANK(0x4000, 0x7fff, wdmy, rom + mapper[0] * 0x4000);
- SET_BANK(0x8000, 0xbfff, wdmy, rom + mapper[1] * 0x4000);
- SET_BANK(0xc000, 0xffff, wdmy, rdmy);
-#endif
- } else {
- SET_BANK(0x0000, 0xffff, wdmy, rdmy);
- }
- }
- return true;
-}
-bool SLOT2::process_state(FILEIO* state_fio, bool loading)
-{
- if(!state_fio->StateCheckUint32(SLOT2_STATE_VERSION)) {
- return false;
- }
- if(!state_fio->StateCheckInt32(this_device_id)) {
- return false;
- }
- state_fio->StateBool(clock);
- state_fio->StateBool(exv);
- state_fio->StateBool(ack);
- state_fio->StateBool(super_impose);
- state_fio->StateBool(req_intr);
- state_fio->StateBool(pc4);
- state_fio->StateBool(mute_l);
- state_fio->StateBool(mute_r);
- return true;
-}
-bool SLOT3::process_state(FILEIO* state_fio, bool loading)
-{
- if(!state_fio->StateCheckUint32(SLOT3_STATE_VERSION)) {
- return false;
- }
- if(!state_fio->StateCheckInt32(this_device_id)) {
- return false;
- }
- state_fio->StateBuffer(ram, sizeof(ram), 1);
- state_fio->StateBool(inserted);
- state_fio->StateBuffer(mapper, sizeof(mapper), 1);
-
- // post process
- if(loading) {
- if(inserted) {
- SET_BANK(0x0000, 0xffff, wdmy, rom);
- } else {
- SET_BANK(0x0000, 0x3fff, ram + mapper[0] * 0x4000, ram + mapper[0] * 0x4000);
- SET_BANK(0x4000, 0x7fff, ram + mapper[1] * 0x4000, ram + mapper[1] * 0x4000);
- SET_BANK(0x8000, 0xbfff, ram + mapper[2] * 0x4000, ram + mapper[2] * 0x4000);
- SET_BANK(0xc000, 0xffff, ram + mapper[3] * 0x4000, ram + mapper[3] * 0x4000);
- }
- }
- return true;
-}
-bool MEMORY::process_state(FILEIO* state_fio, bool loading)
-{
- if(!state_fio->StateCheckUint32(STATE_VERSION)) {
- return false;
- }
- if(!state_fio->StateCheckInt32(this_device_id)) {
- return false;
- }
-#if !defined(_PX7)
- for(int i = 0; i < MAX_DRIVE; i++) {
- if(!disk[i]->process_state(state_fio, loading)) {
- return false;
- }
- }
-#endif
- state_fio->StateUint32(slot_select);
-
- // post process
- if(loading) {
- update_map(slot_select);
- }
- return true;
-}
[ memory ]
*/
-#ifndef _MEMORY_H_
-#define _MEMORY_H_
+#ifndef _MSX_MEMORY_H_
+#define _MSX_MEMORY_H_
#include "../vm.h"
#include "../../emu.h"
// memory bus
-class MEMORY : public DEVICE
+class MSX_MEMORY : public DEVICE
{
private:
DEVICE *d_slot[4];
void update_map(uint32_t val);
public:
- MEMORY(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
+ MSX_MEMORY(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
{
set_device_name(_T("Memory Bus"));
}
- ~MEMORY() {}
+ ~MSX_MEMORY() {}
// common functions
#if !defined(_PX7)
#define SLOT_MAINROM_STATE_VERSION 1
-
-void SLOT_MAINROM::decl_state()
-{
- enter_decl_state(SLOT_MAINROM_STATE_VERSION);
-
-#ifdef MAINROM_PLUS_RAM_32K
- DECL_STATE_ENTRY_1D_ARRAY(ram, sizeof(ram));
-#endif
-
- leave_decl_state();
-}
-
-void SLOT_MAINROM::save_state(FILEIO* state_fio)
-{
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
- }
-// state_fio->FputUint32(SLOT_MAINROM_STATE_VERSION);
-// state_fio->FputInt32(this_device_id);
-
-//#ifdef MAINROM_PLUS_RAM_32K
-// state_fio->Fwrite(ram, sizeof(ram), 1);
-//#endif
-}
-
-bool SLOT_MAINROM::load_state(FILEIO* state_fio)
+bool SLOT_MAINROM::process_state(FILEIO* state_fio, bool loading)
{
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
+ if(!state_fio->StateCheckUint32(SLOT_MAINROM_STATE_VERSION)) {
+ return false;
}
- if(!mb) {
+ if(!state_fio->StateCheckInt32(this_device_id)) {
return false;
}
-// if(state_fio->FgetUint32() != SLOT_MAINROM_STATE_VERSION) {
-// return false;
-// }
-// if(state_fio->FgetInt32() != this_device_id) {
-// return false;
-// }
-//#ifdef MAINROM_PLUS_RAM_32K
-// state_fio->Fread(ram, sizeof(ram), 1);
-//#endif
+#ifdef MAINROM_PLUS_RAM_32K
+ state_fio->StateBuffer(ram, sizeof(ram), 1);
+#endif
return true;
}
#define SLOT_CART_STATE_VERSION 1
-void SLOT_CART::decl_state()
-{
- enter_decl_state(SLOT_CART_STATE_VERSION);
-
- DECL_STATE_ENTRY_BOOL(inserted);
-#ifdef USE_MEGAROM
- DECL_STATE_ENTRY_INT32(type);
- DECL_STATE_ENTRY_BOOL(bank_scc);
- /* Todo: MEGA ROM bank select */
- /* is this OK? */
- DECL_STATE_ENTRY_1D_ARRAY(tmp_rbank_ptr, 8);
-
- //DECL_STATE_ENTRY_INT32(rbank[0]==rdmy ? (-1) : rbank[0] - rom);
- //DECL_STATE_ENTRY_INT32(rbank[1]==rdmy ? (-1) : rbank[1] - rom);
- //DECL_STATE_ENTRY_INT32(rbank[2]==rdmy ? (-1) : rbank[2] - rom);
- //DECL_STATE_ENTRY_INT32(rbank[3]==rdmy ? (-1) : rbank[3] - rom);
- //DECL_STATE_ENTRY_INT32(rbank[4]==rdmy ? (-1) : rbank[4] - rom);
- //DECL_STATE_ENTRY_INT32(rbank[5]==rdmy ? (-1) : rbank[5] - rom);
- //DECL_STATE_ENTRY_INT32(rbank[6]==rdmy ? (-1) : rbank[6] - rom);
- //DECL_STATE_ENTRY_INT32(rbank[7]==rdmy ? (-1) : rbank[7] - rom);
-#endif
-
- leave_decl_state();
-}
-void SLOT_CART::save_state(FILEIO* state_fio)
-{
-#ifdef USE_MEGAROM
- for(int i = 0; i < 8; i++) {
- tmp_rbank_ptr[i] = (rbank[i]==rdmy) ? (-1) : (int)(rbank[i] - rom);
- }
-#endif
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
- }
-// state_fio->FputUint32(SLOT_CART_STATE_VERSION);
-// state_fio->FputInt32(this_device_id);
-
-// state_fio->FputBool(inserted);
-//#ifdef USE_MEGAROM
-// state_fio->FputInt32(type);
-// state_fio->FputBool(bank_scc);
- /* Todo: MEGA ROM bank select */
- /* is this OK? */
-// if(inserted) {
-// state_fio->FputInt32(rbank[0]==rdmy ? (-1) : rbank[0] - rom);
-// state_fio->FputInt32(rbank[1]==rdmy ? (-1) : rbank[1] - rom);
-// state_fio->FputInt32(rbank[2]==rdmy ? (-1) : rbank[2] - rom);
-// state_fio->FputInt32(rbank[3]==rdmy ? (-1) : rbank[3] - rom);
-// state_fio->FputInt32(rbank[4]==rdmy ? (-1) : rbank[4] - rom);
-// state_fio->FputInt32(rbank[5]==rdmy ? (-1) : rbank[5] - rom);
-// state_fio->FputInt32(rbank[6]==rdmy ? (-1) : rbank[6] - rom);
-// state_fio->FputInt32(rbank[7]==rdmy ? (-1) : rbank[7] - rom);
-// }
-//#endif
-}
-
-bool SLOT_CART::load_state(FILEIO* state_fio)
+bool SLOT_CART::process_state(FILEIO* state_fio, bool loading)
{
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
+ if(!state_fio->StateCheckUint32(SLOT_CART_STATE_VERSION)) {
+ return false;
}
- if(!mb) {
+ if(!state_fio->StateCheckInt32(this_device_id)) {
return false;
}
-// if(state_fio->FgetUint32() != SLOT_CART_STATE_VERSION) {
-// return false;
-// }
-// if(state_fio->FgetInt32() != this_device_id) {
-// return false;
-// }
-// inserted = state_fio->FgetBool();
-
- // post process
+ state_fio->StateBool(inserted);
#ifdef USE_MEGAROM
-// type = state_fio->FgetInt32();
-// bank_scc = state_fio->FgetBool();
+ state_fio->StateInt32(type);
+ state_fio->StateBool(bank_scc);
/* Todo: MEGA ROM bank select */
/* is this OK? */
- if(inserted) {
- SET_BANK(0x0000, 0xffff, wdmy, rom);
-// int i32;
-// i32 = state_fio->FgetInt32() ; rbank[0] = ((i32 == -1) ? rdmy : rom + i32);
-// i32 = state_fio->FgetInt32() ; rbank[1] = ((i32 == -1) ? rdmy : rom + i32);
-// i32 = state_fio->FgetInt32() ; rbank[2] = ((i32 == -1) ? rdmy : rom + i32);
-// i32 = state_fio->FgetInt32() ; rbank[3] = ((i32 == -1) ? rdmy : rom + i32);
-// i32 = state_fio->FgetInt32() ; rbank[4] = ((i32 == -1) ? rdmy : rom + i32);
-// i32 = state_fio->FgetInt32() ; rbank[5] = ((i32 == -1) ? rdmy : rom + i32);
-// i32 = state_fio->FgetInt32() ; rbank[6] = ((i32 == -1) ? rdmy : rom + i32);
-// i32 = state_fio->FgetInt32() ; rbank[7] = ((i32 == -1) ? rdmy : rom + i32);
- for(int i = 0; i < 8; i++) {
- rbank[i] = ((tmp_rbank_ptr[i] == -1) ? rdmy : rom + tmp_rbank_ptr[i]);
+ if(loading) {
+ if(inserted) {
+ SET_BANK(0x0000, 0xffff, wdmy, rom);
+ int i32;
+ i32 = state_fio->FgetInt32_LE() ; rbank[0] = ((i32 == -1) ? rdmy : rom + i32);
+ i32 = state_fio->FgetInt32_LE() ; rbank[1] = ((i32 == -1) ? rdmy : rom + i32);
+ i32 = state_fio->FgetInt32_LE() ; rbank[2] = ((i32 == -1) ? rdmy : rom + i32);
+ i32 = state_fio->FgetInt32_LE() ; rbank[3] = ((i32 == -1) ? rdmy : rom + i32);
+ i32 = state_fio->FgetInt32_LE() ; rbank[4] = ((i32 == -1) ? rdmy : rom + i32);
+ i32 = state_fio->FgetInt32_LE() ; rbank[5] = ((i32 == -1) ? rdmy : rom + i32);
+ i32 = state_fio->FgetInt32_LE() ; rbank[6] = ((i32 == -1) ? rdmy : rom + i32);
+ i32 = state_fio->FgetInt32_LE() ; rbank[7] = ((i32 == -1) ? rdmy : rom + i32);
+ } else {
+ SET_BANK(0x0000, 0xffff, wdmy, rdmy);
}
} else {
- SET_BANK(0x0000, 0xffff, wdmy, rdmy);
+ if(inserted) {
+ state_fio->FputInt32_LE(rbank[0]==rdmy ? (-1) : rbank[0] - rom);
+ state_fio->FputInt32_LE(rbank[1]==rdmy ? (-1) : rbank[1] - rom);
+ state_fio->FputInt32_LE(rbank[2]==rdmy ? (-1) : rbank[2] - rom);
+ state_fio->FputInt32_LE(rbank[3]==rdmy ? (-1) : rbank[3] - rom);
+ state_fio->FputInt32_LE(rbank[4]==rdmy ? (-1) : rbank[4] - rom);
+ state_fio->FputInt32_LE(rbank[5]==rdmy ? (-1) : rbank[5] - rom);
+ state_fio->FputInt32_LE(rbank[6]==rdmy ? (-1) : rbank[6] - rom);
+ state_fio->FputInt32_LE(rbank[7]==rdmy ? (-1) : rbank[7] - rom);
+ }
}
- //return false;
- return true;
#else
- if(inserted) {
- SET_BANK(0x0000, 0xffff, wdmy, rom);
- } else {
- SET_BANK(0x0000, 0xffff, wdmy, rdmy);
+ // post process
+ if(loading) {
+ if(inserted) {
+ SET_BANK(0x0000, 0xffff, wdmy, rom);
+ } else {
+ SET_BANK(0x0000, 0xffff, wdmy, rdmy);
+ }
}
- return true;
#endif
+ return true;
}
-
// MSXDOS2
#if defined(MSXDOS2_SLOT)
#define SLOT_MSXDOS2_STATE_VERSION 1
-void SLOT_MSXDOS2::decl_state()
-{
- enter_decl_state(SLOT_MSXDOS2_STATE_VERSION);
-
- DECL_STATE_ENTRY_1D_ARRAY(mapper, sizeof(mapper));
-
- leave_decl_state();
-}
-
-void SLOT_MSXDOS2::save_state(FILEIO* state_fio)
-{
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
- }
-// state_fio->FputUint32(SLOT_MSXDOS2_STATE_VERSION);
-// state_fio->FputInt32(this_device_id);
-
-// state_fio->Fwrite(mapper, sizeof(mapper), 1);
-}
-
-bool SLOT_MSXDOS2::load_state(FILEIO* state_fio)
+bool SLOT_MSXDOS2::process_state(FILEIO* state_fio, bool loading)
{
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
+ if(!state_fio->StateCheckUint32(SLOT_MSXDOS2_STATE_VERSION)) {
+ return false;
}
- if(!mb) {
+ if(!state_fio->StateCheckInt32(this_device_id)) {
return false;
}
-// if(state_fio->FgetUint32() != SLOT_MSXDOS2_STATE_VERSION) {
-// return false;
-// }
-// if(state_fio->FgetInt32() != this_device_id) {
-// return false;
-// }
-// state_fio->Fread(mapper, sizeof(mapper), 1);
+ state_fio->StateBuffer(mapper, sizeof(mapper), 1);
// post process
- if(mapper[0] < 4) {
- SET_BANK(0x0000, 0x3fff, wdmy, rdmy);
- SET_BANK(0x4000, 0x7fff, wdmy, rom + mapper[0] * 0x4000);
- SET_BANK(0x8000, 0xbfff, wdmy, rom + mapper[1] * 0x4000);
- SET_BANK(0xc000, 0xffff, wdmy, rdmy);
- } else {
- SET_BANK(0x0000, 0xffff, wdmy, rdmy);
+ if(loading) {
+ if(mapper[0] < 4) {
+ SET_BANK(0x0000, 0x3fff, wdmy, rdmy);
+ SET_BANK(0x4000, 0x7fff, wdmy, rom + mapper[0] * 0x4000);
+ SET_BANK(0x8000, 0xbfff, wdmy, rom + mapper[1] * 0x4000);
+ SET_BANK(0xc000, 0xffff, wdmy, rdmy);
+ } else {
+ SET_BANK(0x0000, 0xffff, wdmy, rdmy);
+ }
}
return true;
}
+
#endif
// LD Control
#define SLOT_LDC_STATE_VERSION 1
-void SLOT_LDC::decl_state()
-{
- enter_decl_state(SLOT_LDC_STATE_VERSION);
-
- DECL_STATE_ENTRY_BOOL(clock);
- DECL_STATE_ENTRY_BOOL(exv);
- DECL_STATE_ENTRY_BOOL(ack);
- DECL_STATE_ENTRY_BOOL(super_impose);
- DECL_STATE_ENTRY_BOOL(req_intr);
- DECL_STATE_ENTRY_BOOL(pc4);
- DECL_STATE_ENTRY_BOOL(mute_l);
- DECL_STATE_ENTRY_BOOL(mute_r);
-
- leave_decl_state();
-}
-
-void SLOT_LDC::save_state(FILEIO* state_fio)
-{
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
- }
-// state_fio->FputUint32(SLOT_LDC_STATE_VERSION);
-// state_fio->FputInt32(this_device_id);
-
-// state_fio->FputBool(clock);
-// state_fio->FputBool(exv);
-// state_fio->FputBool(ack);
-// state_fio->FputBool(super_impose);
-// state_fio->FputBool(req_intr);
-// state_fio->FputBool(pc4);
-// state_fio->FputBool(mute_l);
-// state_fio->FputBool(mute_r);
-}
-
-bool SLOT_LDC::load_state(FILEIO* state_fio)
+bool SLOT_LDC::process_state(FILEIO* state_fio, bool loading)
{
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
+ if(!state_fio->StateCheckUint32(SLOT_LDC_STATE_VERSION)) {
+ return false;
}
- if(!mb) {
+ if(!state_fio->StateCheckInt32(this_device_id)) {
return false;
}
-// if(state_fio->FgetUint32() != SLOT_LDC_STATE_VERSION) {
-// return false;
-// }
-// if(state_fio->FgetInt32() != this_device_id) {
-// return false;
-// }
-// clock = state_fio->FgetBool();
-// exv = state_fio->FgetBool();
-// ack = state_fio->FgetBool();
-// super_impose = state_fio->FgetBool();
-// req_intr = state_fio->FgetBool();
-// pc4 = state_fio->FgetBool();
-// mute_l = state_fio->FgetBool();
-// mute_r = state_fio->FgetBool();
+ state_fio->StateBool(clock);
+ state_fio->StateBool(exv);
+ state_fio->StateBool(ack);
+ state_fio->StateBool(super_impose);
+ state_fio->StateBool(req_intr);
+ state_fio->StateBool(pc4);
+ state_fio->StateBool(mute_l);
+ state_fio->StateBool(mute_r);
return true;
}
#endif
#define SLOT_MAPPERRAM_STATE_VERSION 1
-void SLOT_MAPPERRAM::decl_state()
-{
- enter_decl_state(SLOT_MAPPERRAM_STATE_VERSION);
-
- DECL_STATE_ENTRY_1D_ARRAY(ram, sizeof(ram));
- DECL_STATE_ENTRY_1D_ARRAY(mapper, sizeof(mapper));
-
- leave_decl_state();
-}
-
-void SLOT_MAPPERRAM::save_state(FILEIO* state_fio)
-{
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
- }
-// state_fio->FputUint32(SLOT_MAPPERRAM_STATE_VERSION);
-// state_fio->FputInt32(this_device_id);
-
-// state_fio->Fwrite(ram, sizeof(ram), 1);
-// state_fio->Fwrite(mapper, sizeof(mapper), 1);
-}
-
-bool SLOT_MAPPERRAM::load_state(FILEIO* state_fio)
+bool SLOT_MAPPERRAM::process_state(FILEIO* state_fio, bool loading)
{
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
+ if(!state_fio->StateCheckUint32(SLOT_MAPPERRAM_STATE_VERSION)) {
+ return false;
}
- if(!mb) {
+ if(!state_fio->StateCheckInt32(this_device_id)) {
return false;
}
-// if(state_fio->FgetUint32() != SLOT_MAPPERRAM_STATE_VERSION) {
-// return false;
-// }
-// if(state_fio->FgetInt32() != this_device_id) {
-// return false;
-// }
-// state_fio->Fread(ram, sizeof(ram), 1);
-// state_fio->Fread(mapper, sizeof(mapper), 1);
+ state_fio->StateBuffer(ram, sizeof(ram), 1);
+ state_fio->StateBuffer(mapper, sizeof(mapper), 1);
// post process
- SET_BANK(0x0000, 0x3fff, ram + mapper[0] * 0x4000, ram + mapper[0] * 0x4000);
- SET_BANK(0x4000, 0x7fff, ram + mapper[1] * 0x4000, ram + mapper[1] * 0x4000);
- SET_BANK(0x8000, 0xbfff, ram + mapper[2] * 0x4000, ram + mapper[2] * 0x4000);
- SET_BANK(0xc000, 0xffff, ram + mapper[3] * 0x4000, ram + mapper[3] * 0x4000);
+ if(loading) {
+ SET_BANK(0x0000, 0x3fff, ram + mapper[0] * 0x4000, ram + mapper[0] * 0x4000);
+ SET_BANK(0x4000, 0x7fff, ram + mapper[1] * 0x4000, ram + mapper[1] * 0x4000);
+ SET_BANK(0x8000, 0xbfff, ram + mapper[2] * 0x4000, ram + mapper[2] * 0x4000);
+ SET_BANK(0xc000, 0xffff, ram + mapper[3] * 0x4000, ram + mapper[3] * 0x4000);
+ }
return true;
}
#endif
#define SLOT_RAM64K_STATE_VERSION 1
-void SLOT_RAM64K::decl_state()
-{
- enter_decl_state(SLOT_RAM64K_STATE_VERSION);
-
- DECL_STATE_ENTRY_1D_ARRAY(ram, sizeof(ram));
-
- leave_decl_state();
-}
-
-void SLOT_RAM64K::save_state(FILEIO* state_fio)
-{
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
- }
-// state_fio->FputUint32(SLOT_RAM64K_STATE_VERSION);
-// state_fio->FputInt32(this_device_id);
-
-// state_fio->Fwrite(ram, sizeof(ram), 1);
-}
-
-bool SLOT_RAM64K::load_state(FILEIO* state_fio)
+bool SLOT_RAM64K::process_state(FILEIO* state_fio, bool loading)
{
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
+ if(!state_fio->StateCheckUint32(SLOT_RAM64K_STATE_VERSION)) {
+ return false;
}
- if(!mb) {
+ if(!state_fio->StateCheckInt32(this_device_id)) {
return false;
}
-// if(state_fio->FgetUint32() != SLOT_RAM64K_STATE_VERSION) {
-// return false;
-// }
-// if(state_fio->FgetInt32() != this_device_id) {
-// return false;
-// }
-// state_fio->Fread(ram, sizeof(ram), 1);
+ state_fio->StateBuffer(ram, sizeof(ram), 1);
return true;
}
#endif
#define STATE_VERSION 1
-void MEMORY_EX::decl_state()
-{
- enter_decl_state(STATE_VERSION);
-
- DECL_STATE_ENTRY_UINT8(psl);
- DECL_STATE_ENTRY_UINT8(ssl[0]);
- DECL_STATE_ENTRY_UINT8(ssl[1]);
- DECL_STATE_ENTRY_UINT8(ssl[2]);
- DECL_STATE_ENTRY_UINT8(ssl[3]);
-
- leave_decl_state();
-
-#if defined(FDD_PATCH_SLOT)
- for(int i = 0; i < MAX_DRIVE; i++) {
- if(disk[i] != NULL) disk[i]->decl_state((void *)p_logger);
- }
-#endif
-}
-
-void MEMORY_EX::save_state(FILEIO* state_fio)
-{
-// state_fio->FputUint32(STATE_VERSION);
-// state_fio->FputInt32(this_device_id);
-
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
- }
-#if defined(FDD_PATCH_SLOT)
- for(int i = 0; i < MAX_DRIVE; i++) {
- disk[i]->save_state(state_fio);
- }
-#endif
-// DECL_STATE_ENTRY_UINT8(psl);
-// DECL_STATE_ENTRY_UINT8(ssl[0]);
-// DECL_STATE_ENTRY_UINT8(ssl[1]);
-// DECL_STATE_ENTRY_UINT8(ssl[2]);
-// DECL_STATE_ENTRY_UINT8(ssl[3]);
-}
-
-bool MEMORY_EX::load_state(FILEIO* state_fio)
-{
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
- }
- if(!mb) {
- return false;
- }
-// if(state_fio->FgetUint32() != STATE_VERSION) {
-// return false;
-// }
-// if(state_fio->FgetInt32() != this_device_id) {
-// return false;
-// }
-#if defined(FDD_PATCH_SLOT)
- for(int i = 0; i < MAX_DRIVE; i++) {
- if(!disk[i]->load_state(state_fio)) {
- return false;
- }
- }
-#endif
-// psl = state_fio->FgetUint8();
-// ssl[0] = state_fio->FgetUint8();
-// ssl[1] = state_fio->FgetUint8();
-// ssl[2] = state_fio->FgetUint8();
-// ssl[3] = state_fio->FgetUint8();
-
- // post process
- update_map(psl);
- return true;
-}
-
-bool SLOT_MAINROM::process_state(FILEIO* state_fio, bool loading)
-{
- if(!state_fio->StateCheckUint32(SLOT_MAINROM_STATE_VERSION)) {
- return false;
- }
- if(!state_fio->StateCheckInt32(this_device_id)) {
- return false;
- }
-#ifdef MAINROM_PLUS_RAM_32K
- state_fio->StateBuffer(ram, sizeof(ram), 1);
-#endif
- return true;
-}
-bool SLOT_CART::process_state(FILEIO* state_fio, bool loading)
-{
- if(!state_fio->StateCheckUint32(SLOT_CART_STATE_VERSION)) {
- return false;
- }
- if(!state_fio->StateCheckInt32(this_device_id)) {
- return false;
- }
- state_fio->StateBool(inserted);
-#ifdef USE_MEGAROM
- state_fio->StateInt32(type);
- state_fio->StateBool(bank_scc);
- /* Todo: MEGA ROM bank select */
- /* is this OK? */
- if(loading) {
- if(inserted) {
- SET_BANK(0x0000, 0xffff, wdmy, rom);
- int i32;
- i32 = state_fio->FgetInt32_LE() ; rbank[0] = ((i32 == -1) ? rdmy : rom + i32);
- i32 = state_fio->FgetInt32_LE() ; rbank[1] = ((i32 == -1) ? rdmy : rom + i32);
- i32 = state_fio->FgetInt32_LE() ; rbank[2] = ((i32 == -1) ? rdmy : rom + i32);
- i32 = state_fio->FgetInt32_LE() ; rbank[3] = ((i32 == -1) ? rdmy : rom + i32);
- i32 = state_fio->FgetInt32_LE() ; rbank[4] = ((i32 == -1) ? rdmy : rom + i32);
- i32 = state_fio->FgetInt32_LE() ; rbank[5] = ((i32 == -1) ? rdmy : rom + i32);
- i32 = state_fio->FgetInt32_LE() ; rbank[6] = ((i32 == -1) ? rdmy : rom + i32);
- i32 = state_fio->FgetInt32_LE() ; rbank[7] = ((i32 == -1) ? rdmy : rom + i32);
- } else {
- SET_BANK(0x0000, 0xffff, wdmy, rdmy);
- }
- } else {
- if(inserted) {
- state_fio->FputInt32_LE(rbank[0]==rdmy ? (-1) : rbank[0] - rom);
- state_fio->FputInt32_LE(rbank[1]==rdmy ? (-1) : rbank[1] - rom);
- state_fio->FputInt32_LE(rbank[2]==rdmy ? (-1) : rbank[2] - rom);
- state_fio->FputInt32_LE(rbank[3]==rdmy ? (-1) : rbank[3] - rom);
- state_fio->FputInt32_LE(rbank[4]==rdmy ? (-1) : rbank[4] - rom);
- state_fio->FputInt32_LE(rbank[5]==rdmy ? (-1) : rbank[5] - rom);
- state_fio->FputInt32_LE(rbank[6]==rdmy ? (-1) : rbank[6] - rom);
- state_fio->FputInt32_LE(rbank[7]==rdmy ? (-1) : rbank[7] - rom);
- }
- }
-#else
- // post process
- if(loading) {
- if(inserted) {
- SET_BANK(0x0000, 0xffff, wdmy, rom);
- } else {
- SET_BANK(0x0000, 0xffff, wdmy, rdmy);
- }
- }
-#endif
- return true;
-}
-bool SLOT_MSXDOS2::process_state(FILEIO* state_fio, bool loading)
-{
- if(!state_fio->StateCheckUint32(SLOT_MSXDOS2_STATE_VERSION)) {
- return false;
- }
- if(!state_fio->StateCheckInt32(this_device_id)) {
- return false;
- }
- state_fio->StateBuffer(mapper, sizeof(mapper), 1);
-
- // post process
- if(loading) {
- if(mapper[0] < 4) {
- SET_BANK(0x0000, 0x3fff, wdmy, rdmy);
- SET_BANK(0x4000, 0x7fff, wdmy, rom + mapper[0] * 0x4000);
- SET_BANK(0x8000, 0xbfff, wdmy, rom + mapper[1] * 0x4000);
- SET_BANK(0xc000, 0xffff, wdmy, rdmy);
- } else {
- SET_BANK(0x0000, 0xffff, wdmy, rdmy);
- }
- }
- return true;
-}
-bool SLOT_LDC::process_state(FILEIO* state_fio, bool loading)
-{
- if(!state_fio->StateCheckUint32(SLOT_LDC_STATE_VERSION)) {
- return false;
- }
- if(!state_fio->StateCheckInt32(this_device_id)) {
- return false;
- }
- state_fio->StateBool(clock);
- state_fio->StateBool(exv);
- state_fio->StateBool(ack);
- state_fio->StateBool(super_impose);
- state_fio->StateBool(req_intr);
- state_fio->StateBool(pc4);
- state_fio->StateBool(mute_l);
- state_fio->StateBool(mute_r);
- return true;
-}
-bool SLOT_MAPPERRAM::process_state(FILEIO* state_fio, bool loading)
-{
- if(!state_fio->StateCheckUint32(SLOT_MAPPERRAM_STATE_VERSION)) {
- return false;
- }
- if(!state_fio->StateCheckInt32(this_device_id)) {
- return false;
- }
- state_fio->StateBuffer(ram, sizeof(ram), 1);
- state_fio->StateBuffer(mapper, sizeof(mapper), 1);
-
- // post process
- if(loading) {
- SET_BANK(0x0000, 0x3fff, ram + mapper[0] * 0x4000, ram + mapper[0] * 0x4000);
- SET_BANK(0x4000, 0x7fff, ram + mapper[1] * 0x4000, ram + mapper[1] * 0x4000);
- SET_BANK(0x8000, 0xbfff, ram + mapper[2] * 0x4000, ram + mapper[2] * 0x4000);
- SET_BANK(0xc000, 0xffff, ram + mapper[3] * 0x4000, ram + mapper[3] * 0x4000);
- }
- return true;
-}
-bool SLOT_RAM64K::process_state(FILEIO* state_fio, bool loading)
-{
- if(!state_fio->StateCheckUint32(SLOT_RAM64K_STATE_VERSION)) {
- return false;
- }
- if(!state_fio->StateCheckInt32(this_device_id)) {
- return false;
- }
- state_fio->StateBuffer(ram, sizeof(ram), 1);
- return true;
-}
bool MEMORY_EX::process_state(FILEIO* state_fio, bool loading)
{
if(!state_fio->StateCheckUint32(STATE_VERSION)) {
}
return true;
}
+
void initialize();
void write_data8(uint32_t addr, uint32_t data);
uint32_t read_data8(uint32_t addr);
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
+ bool process_state(FILEIO* state_fio, bool loading);
};
// Cart
void initialize();
void write_data8(uint32_t addr, uint32_t data);
uint32_t read_data8(uint32_t addr);
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
+ bool process_state(FILEIO* state_fio, bool loading);
#ifdef USE_MEGAROM
void event_callback(int event_id, int err);
int event_register_id;
void initialize();
void write_data8(uint32_t addr, uint32_t data);
uint32_t read_data8(uint32_t addr);
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
+ bool process_state(FILEIO* state_fio, bool loading);
};
#endif
uint32_t read_data8(uint32_t addr);
void write_signal(int id, uint32_t data, uint32_t mask);
void event_callback(int event_id, int err);
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
+ bool process_state(FILEIO* state_fio, bool loading);
// unique functions
void set_context_cpu(DEVICE* device)
void write_data8(uint32_t addr, uint32_t data);
uint32_t read_data8(uint32_t addr);
void write_io8(uint32_t addr, uint32_t data);
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
+ bool process_state(FILEIO* state_fio, bool loading);
};
#endif
void initialize();
void write_data8(uint32_t addr, uint32_t data);
uint32_t read_data8(uint32_t addr);
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
+ bool process_state(FILEIO* state_fio, bool loading);
};
#endif
uint32_t read_signal(int id);
bool bios_ret_z80(uint16_t PC, pair_t* af, pair_t* bc, pair_t* de, pair_t* hl, pair_t* ix, pair_t* iy, uint8_t* iff1);
#endif
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
+ bool process_state(FILEIO* state_fio, bool loading);
// unique functions
void set_context_slot_dummy(DEVICE *device)
#include "joystick.h"
#include "keyboard.h"
-#include "memory.h"
+#include "./memory.h"
#if defined(_MSX2)
#include "rtcif.h"
#endif
cpu = new Z80(this, emu);
joystick = new JOYSTICK(this, emu);
keyboard = new KEYBOARD(this, emu);
- memory = new MEMORY(this, emu);
+ memory = new MSX_MEMORY(this, emu);
#if defined(_MSX2)
rtcif = new RTCIF(this, emu);
#endif
if(!state_fio->StateCheckUint32(STATE_VERSION)) {
return false;
}
- for(DEVICE* device = first_device; device; device = device->next_device) {
- const char *name = typeid(*device).name() + 6; // skip "class "
+ for(DEVICE* device = first_device; device; device = device->next_device) {
+ // Note: typeid(foo).name is fixed by recent ABI.Not dec 6.
+ // const char *name = typeid(*device).name();
+ // But, using get_device_name() instead of typeid(foo).name() 20181008 K.O
+ const char *name = device->get_device_name();
int len = strlen(name);
if(!state_fio->StateCheckInt32(len)) {
+ if(loading) {
+ printf("Class name len Error: DEVID=%d EXPECT=%s\n", device->this_device_id, name);
+ }
return false;
}
if(!state_fio->StateCheckBuffer(name, len, 1)) {
- return false;
- }
+ if(loading) {
+ printf("Class name Error: DEVID=%d EXPECT=%s\n", device->this_device_id, name);
+ }
+ return false;
+ }
if(!device->process_state(state_fio, loading)) {
- return false;
- }
- }
+ if(loading) {
+ printf("Data loading Error: DEVID=%d\n", device->this_device_id);
+ }
+ return false;
+ }
+ }
+ // Machine specified.
return true;
}
class JOYSTICK;
class KEYBOARD;
-class MEMORY;
+class MSX_MEMORY;
#if defined(_MSX2)
class RTCIF;
#endif
JOYSTICK* joystick;
KEYBOARD* keyboard;
- MEMORY* memory;
+ MSX_MEMORY* memory;
#ifdef _MSX2
RTCIF* rtcif;
#endif
for(DEVICE* device = first_device; device; device = device->next_device) {
device->initialize();
}
- decl_state();
}
VM::~VM()
#define STATE_VERSION 5
-#include "../../statesub.h"
-#include "../../qt/gui/csp_logger.h"
-extern CSP_Logger DLL_PREFIX_I *csp_logger;
-
-void VM::decl_state(void)
-{
- state_entry = new csp_state_utils(STATE_VERSION, 0, (_TCHAR *)(_T("CSP::MSX_SERIES_HEAD")), csp_logger);
- for(DEVICE* device = first_device; device; device = device->next_device) {
- device->decl_state();
- }
-}
-
-void VM::save_state(FILEIO* state_fio)
-{
- //state_fio->FputUint32(STATE_VERSION);
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
- }
- for(DEVICE* device = first_device; device; device = device->next_device) {
- device->save_state(state_fio);
- }
-}
-
-bool VM::load_state(FILEIO* state_fio)
-{
- //if(state_fio->FgetUint32() != STATE_VERSION) {
- // return false;
- //}
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
- }
- if(!mb) {
- emu->out_debug_log("INFO: HEADER DATA ERROR");
- return false;
- }
- for(DEVICE* device = first_device; device; device = device->next_device) {
- if(!device->load_state(state_fio)) {
- return false;
- }
- }
- return true;
-}
-
bool VM::process_state(FILEIO* state_fio, bool loading)
{
if(!state_fio->StateCheckUint32(STATE_VERSION)) {
return false;
}
- for(DEVICE* device = first_device; device; device = device->next_device) {
- const char *name = typeid(*device).name() + 6; // skip "class "
+ for(DEVICE* device = first_device; device; device = device->next_device) {
+ // Note: typeid(foo).name is fixed by recent ABI.Not dec 6.
+ // const char *name = typeid(*device).name();
+ // But, using get_device_name() instead of typeid(foo).name() 20181008 K.O
+ const char *name = device->get_device_name();
int len = strlen(name);
if(!state_fio->StateCheckInt32(len)) {
+ if(loading) {
+ printf("Class name len Error: DEVID=%d EXPECT=%s\n", device->this_device_id, name);
+ }
return false;
}
if(!state_fio->StateCheckBuffer(name, len, 1)) {
- return false;
- }
+ if(loading) {
+ printf("Class name Error: DEVID=%d EXPECT=%s\n", device->this_device_id, name);
+ }
+ return false;
+ }
if(!device->process_state(state_fio, loading)) {
- return false;
- }
- }
+ if(loading) {
+ printf("Data loading Error: DEVID=%d\n", device->this_device_id);
+ }
+ return false;
+ }
+ }
+ // Machine specified.
return true;
}
#define USE_SOUND_TYPE 2
#endif
#define USE_CPU_Z80
+#define SUPPORT_TV_RENDER
#include "../../common.h"
#include "../../fileio.h"
bool is_frame_skippable();
void update_config();
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
+ bool process_state(FILEIO* state_fio, bool loading);
// ----------------------------------------
// for each device
#define STATE_VERSION 1
-#include "../../statesub.h"
-
-void RTCIF::decl_state()
-{
- enter_decl_state(STATE_VERSION);
-
- DECL_STATE_ENTRY_UINT8(adrs);
-
- leave_decl_state();
-}
-
-void RTCIF::save_state(FILEIO* state_fio)
-{
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
- }
-// state_fio->FputUint32(STATE_VERSION);
-// state_fio->FputInt32(this_device_id);
-
-// state_fio->FputUint8(adrs);
-}
-
-bool RTCIF::load_state(FILEIO* state_fio)
-{
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
- }
- if(!mb) {
- return false;
- }
-// if(state_fio->FgetUint32() != STATE_VERSION) {
-// return false;
-// }
-// if(state_fio->FgetInt32() != this_device_id) {
-// return false;
-// }
-// adrs = state_fio->FgetUint8();
- return true;
-}
-
bool RTCIF::process_state(FILEIO* state_fio, bool loading)
{
if(!state_fio->StateCheckUint32(STATE_VERSION)) {
// common functions
void write_io8(uint32_t addr, uint32_t data);
uint32_t read_io8(uint32_t addr);
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
+ bool process_state(FILEIO* state_fio, bool loading);
// unique function
void set_context_rtc(DEVICE* device)
void SCC::release()
{
SCC_delete(emu2212);
- delete state_entry;
}
void SCC::reset()
emu2212 = SCC_new(clock, rate);
this->reset();
this->initialize();
- this->decl_state();
}
void SCC::set_volume(int ch, int decibel_l, int decibel_r)
#define STATE_VERSION 1
-#include "../../statesub.h"
+bool SCC::process_state(FILEIO* state_fio, bool loading)
+{
+ if(!state_fio->StateCheckUint32(STATE_VERSION)) {
+ return false;
+ }
+ if(!state_fio->StateCheckInt32(this_device_id)) {
+ return false;
+ }
+ save_load_state(state_fio, !loading);
+ return true;
+}
+#if 0
void SCC::decl_state_scc()
{
DECL_STATE_ENTRY_UINT32((emu2212->clk));
DECL_STATE_ENTRY_INT32((emu2212->refresh));
DECL_STATE_ENTRY_1D_ARRAY(emu2212->rotate, 5) ;
}
+#endif
-void SCC::decl_state()
-{
- enter_decl_state(STATE_VERSION);
-
- decl_state_scc();
-
- leave_decl_state();
-}
-void SCC::save_state(FILEIO* state_fio)
-{
- if(state_entry != NULL) {
- state_entry->save_state(state_fio);
- }
-// state_fio->FputUint32(STATE_VERSION);
-// state_fio->FputInt32(this_device_id);
-
-// save_load_state(state_fio, true);
-}
-
-bool SCC::load_state(FILEIO* state_fio)
-{
- bool mb = false;
- if(state_entry != NULL) {
- mb = state_entry->load_state(state_fio);
- }
- if(!mb) {
- return false;
- }
-// if(state_fio->FgetUint32() != STATE_VERSION) {
-// return false;
-// }
-// if(state_fio->FgetInt32() != this_device_id) {
-// return false;
-// }
-
-// save_load_state(state_fio, false);
- return true;
-}
-
+// ToDo: Dedicate endianness. 20181017 K.O.
void SCC::save_load_state(FILEIO* state_fio, bool is_save)
{
#define STATE_ENTRY(x) {&(x), sizeof(x)}
return;
}
-bool SCC::process_state(FILEIO* state_fio, bool loading)
-{
- if(!state_fio->StateCheckUint32(STATE_VERSION)) {
- return false;
- }
- if(!state_fio->StateCheckInt32(this_device_id)) {
- return false;
- }
- save_load_state(state_fio, !loading);
- return true;
-}
EMU2212 *emu2212;
int volume_l, volume_r;
void save_load_state(FILEIO* state_fio, bool is_save);
- void decl_state_scc();
public:
SCC(VM_TEMPLATE* parent_vm, EMU* parent_emu);
void reset();
void mix(int32_t* buffer, int cnt);
void set_volume(int ch, int decibel_l, int decibel_r);
- void decl_state();
- void save_state(FILEIO* state_fio);
- bool load_state(FILEIO* state_fio);
+ bool process_state(FILEIO* state_fio, bool loading);
// unique functions
void initialize_sound(int rate, int clock, int samples);
} \
}
-void MEMORY::initialize()
+void X1_MEMORY::initialize()
{
// init memory
memset(rom, 0xff, sizeof(rom));
#endif
}
-void MEMORY::reset()
+void X1_MEMORY::reset()
{
SET_BANK(0x0000, 0x7fff, ram, rom);
SET_BANK(0x8000, 0xffff, ram + 0x8000, ram + 0x8000);
#endif
}
-void MEMORY::write_data8(uint32_t addr, uint32_t data)
+void X1_MEMORY::write_data8(uint32_t addr, uint32_t data)
{
addr &= 0xffff;
wbank[addr >> 12][addr & 0xfff] = data;
}
-uint32_t MEMORY::read_data8(uint32_t addr)
+uint32_t X1_MEMORY::read_data8(uint32_t addr)
{
addr &= 0xffff;
return rbank[addr >> 12][addr & 0xfff];
}
#ifndef _X1TURBO_FEATURE
-uint32_t MEMORY::fetch_op(uint32_t addr, int *wait)
+uint32_t X1_MEMORY::fetch_op(uint32_t addr, int *wait)
{
*wait = m1_cycle;
return read_data8(addr);
}
#endif
-void MEMORY::write_io8(uint32_t addr, uint32_t data)
+void X1_MEMORY::write_io8(uint32_t addr, uint32_t data)
{
bool update_map_required = false;
}
}
-uint32_t MEMORY::read_io8(uint32_t addr)
+uint32_t X1_MEMORY::read_io8(uint32_t addr)
{
switch(addr & 0xff00) {
case 0x1e00: // thanks Mr.Sato
return 0xff;
}
-void MEMORY::update_map()
+void X1_MEMORY::update_map()
{
#ifdef _X1TURBO_FEATURE
if(!(bank & 0x10)) {
#define STATE_VERSION 1
-bool MEMORY::process_state(FILEIO* state_fio, bool loading)
+bool X1_MEMORY::process_state(FILEIO* state_fio, bool loading)
{
if(!state_fio->StateCheckUint32(STATE_VERSION)) {
return false;
[ memory ]
*/
-#ifndef _MEMORY_H_
-#define _MEMORY_H_
+#ifndef _X1_MEMORY_H_
+#define _X1_MEMORY_H_
#include "../vm.h"
#include "../../emu.h"
#include "../device.h"
-class MEMORY : public DEVICE
+class X1_MEMORY : public DEVICE
{
private:
#ifdef _X1TURBO_FEATURE
void update_map();
public:
- MEMORY(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
+ X1_MEMORY(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
{
set_device_name(_T("Memory Bus"));
}
- ~MEMORY() {}
+ ~X1_MEMORY() {}
// common functions
void initialize();
#include "floppy.h"
#include "iobus.h"
#include "joystick.h"
-#include "memory.h"
+#include "./memory.h"
#include "mouse.h"
#include "psub.h"
#include "sasi.h"
floppy = new FLOPPY(this, emu);
iobus = new IOBUS(this, emu);
joy = new JOYSTICK(this, emu);
- memory = new MEMORY(this, emu);
+ memory = new X1_MEMORY(this, emu);
mouse = new MOUSE(this, emu);
sasi = new SASI(this, emu);
class FLOPPY;
class IOBUS;
class JOYSTICK;
-class MEMORY;
+class X1_MEMORY;
class MOUSE;
class PSUB;
class SASI;
FLOPPY* floppy;
IOBUS* iobus;
JOYSTICK* joy;
- MEMORY* memory;
+ X1_MEMORY* memory;
MOUSE* mouse;
PSUB* psub;
SASI* sasi;
OSDN Git Service
