[VM][FM7] .

diff --git a/source/src/vm/fm7/fm7.h b/source/src/vm/fm7/fm7.h
index 8984266..19db02f 100644 (file)
--- a/source/src/vm/fm7/fm7.h
+++ b/source/src/vm/fm7/fm7.h
@@ -616,9 +616,7 @@ public:
        void push_apss_forward(int drv);
        void push_apss_rewind(int drv);
        void update_config();
-       void save_state(FILEIO* state_fio);
-       bool load_state(FILEIO* state_fio);
-       void decl_state(void);
+       bool process_state(FILEIO* state_fio, bool loading);
        
 #if defined(USE_BUBBLE)
        void open_bubble_casette(int drv, const _TCHAR *path, int bank);

diff --git a/source/src/vm/fm7/fm7_keyboard.h b/source/src/vm/fm7/fm7_keyboard.h
index f49fd56..f25f8a5 100644 (file)
--- a/source/src/vm/fm7/fm7_keyboard.h
+++ b/source/src/vm/fm7/fm7_keyboard.h
@@ -142,7 +142,7 @@ private:
        void write_data8(uint32_t addr, uint32_t data);
        void reset(void);
        void release(void);
-       void decl_state();
+       bool decl_state(FILEIO *state_fio, bool loading);
        void save_state(FILEIO *f);
        bool load_state(FILEIO *f);
        void set_context_rxrdy(DEVICE *p, int id, uint32_t mask) {

diff --git a/source/src/vm/fm7/fm7_mainio.cpp b/source/src/vm/fm7/fm7_mainio.cpp
index 216df18..2a320e2 100644 (file)
--- a/source/src/vm/fm7/fm7_mainio.cpp
+++ b/source/src/vm/fm7/fm7_mainio.cpp
@@ -1942,170 +1942,173 @@ void FM7_MAINIO::event_vline(int v, int clock)
 }
 
 
-#define STATE_VERSION 16
-#include "../../statesub.h"
+#define STATE_VERSION 17
 
-void FM7_MAINIO::decl_state(void)
+bool FM7_MAINIO::decl_state(FILEIO *state_fio, bool loading)
 {
-       enter_decl_state(STATE_VERSION);
+       if(!state_fio->StateCheckUint32(STATE_VERSION)) {
+               return false;
+       }
+       if(!state_fio->StateCheckInt32(this_device_id)) {
+               return false;
+       }
 
-       DECL_STATE_ENTRY_MULTI(void, io_w_latch, sizeof(io_w_latch));
+       state_fio->StateBuffer(io_w_latch, sizeof(io_w_latch), 1);
        
-       DECL_STATE_ENTRY_BOOL(clock_fast);
-       DECL_STATE_ENTRY_BOOL(lpt_strobe);
-       DECL_STATE_ENTRY_BOOL(lpt_slctin);
-       DECL_STATE_ENTRY_BOOL(beep_flag);
-       DECL_STATE_ENTRY_BOOL(beep_snd);
-       
-               // FD01
-       DECL_STATE_ENTRY_UINT8(lpt_outdata);
+       state_fio->StateBool(clock_fast);
+       state_fio->StateBool(lpt_strobe);
+       state_fio->StateBool(lpt_slctin);
+       state_fio->StateBool(beep_flag);
+       state_fio->StateBool(beep_snd);
+       
+       // FD01
+       state_fio->StateUint8(lpt_outdata);
        // FD02
-       DECL_STATE_ENTRY_BOOL(cmt_indat);
-       DECL_STATE_ENTRY_BOOL(cmt_invert);
-       DECL_STATE_ENTRY_BOOL(lpt_det2);
-       DECL_STATE_ENTRY_BOOL(lpt_det1);
-       DECL_STATE_ENTRY_BOOL(lpt_pe);
-       DECL_STATE_ENTRY_BOOL(lpt_ackng_inv);
-       DECL_STATE_ENTRY_BOOL(lpt_error_inv);
-       DECL_STATE_ENTRY_UINT8(irqmask_reg0);
+       state_fio->StateBool(cmt_indat);
+       state_fio->StateBool(cmt_invert);
+       state_fio->StateBool(lpt_det2);
+       state_fio->StateBool(lpt_det1);
+       state_fio->StateBool(lpt_pe);
+       state_fio->StateBool(lpt_ackng_inv);
+       state_fio->StateBool(lpt_error_inv);
+       state_fio->StateUint8(irqmask_reg0);
        
-       DECL_STATE_ENTRY_BOOL(irqmask_syndet);
-       DECL_STATE_ENTRY_BOOL(irqmask_rxrdy);
-       DECL_STATE_ENTRY_BOOL(irqmask_txrdy);
-       DECL_STATE_ENTRY_BOOL(irqmask_mfd);
-       DECL_STATE_ENTRY_BOOL(irqmask_timer);
-       DECL_STATE_ENTRY_BOOL(irqmask_printer);
-       DECL_STATE_ENTRY_BOOL(irqmask_keyboard);
-
-       DECL_STATE_ENTRY_BOOL(irqreq_syndet);
-       DECL_STATE_ENTRY_BOOL(irqreq_rxrdy);
-       DECL_STATE_ENTRY_BOOL(irqreq_txrdy);
-       DECL_STATE_ENTRY_BOOL(irqreq_printer);
-       DECL_STATE_ENTRY_BOOL(irqreq_keyboard);
-       DECL_STATE_ENTRY_UINT8(irqstat_reg0);
-               
-       DECL_STATE_ENTRY_BOOL(irqstat_timer);
-       DECL_STATE_ENTRY_BOOL(irqstat_printer);
-       DECL_STATE_ENTRY_BOOL(irqstat_keyboard);
-               
-               // FD04
+       state_fio->StateBool(irqmask_syndet);
+       state_fio->StateBool(irqmask_rxrdy);
+       state_fio->StateBool(irqmask_txrdy);
+       state_fio->StateBool(irqmask_mfd);
+       state_fio->StateBool(irqmask_timer);
+       state_fio->StateBool(irqmask_printer);
+       state_fio->StateBool(irqmask_keyboard);
+
+       state_fio->StateBool(irqreq_syndet);
+       state_fio->StateBool(irqreq_rxrdy);
+       state_fio->StateBool(irqreq_txrdy);
+       state_fio->StateBool(irqreq_printer);
+       state_fio->StateBool(irqreq_keyboard);
+       state_fio->StateUint8(irqstat_reg0);
+               
+       state_fio->StateBool(irqstat_timer);
+       state_fio->StateBool(irqstat_printer);
+       state_fio->StateBool(irqstat_keyboard);
+               
+       // FD04
 #if defined(_FM77_VARIANTS)
-       DECL_STATE_ENTRY_BOOL(stat_fdmode_2hd);
-       DECL_STATE_ENTRY_BOOL(stat_kanjirom);
+       state_fio->StateBool(stat_fdmode_2hd);
+       state_fio->StateBool(stat_kanjirom);
 #elif defined(_FM77AV40) || defined(_FM77AV40EX) || defined(_FM77AV40SX) || \
-       defined(_FM77AV20) || defined(_FM77AV20EX) || defined(_FM77AV20SX)
-       DECL_STATE_ENTRY_BOOL(stat_kanjirom);
+       defined(_FM77AV20) || defined(_FM77AV20EX) || defined(_FM77AV20SX)
+       state_fio->StateBool(stat_kanjirom);
 #endif
-       DECL_STATE_ENTRY_BOOL(firq_break_key);
-       DECL_STATE_ENTRY_BOOL(firq_sub_attention);
+       state_fio->StateBool(firq_break_key);
+       state_fio->StateBool(firq_sub_attention);
        
-       DECL_STATE_ENTRY_BOOL(intmode_fdc);
+       state_fio->StateBool(intmode_fdc);
        // FD05
-       DECL_STATE_ENTRY_BOOL(extdet_neg);
-       DECL_STATE_ENTRY_BOOL(sub_halt);
-       DECL_STATE_ENTRY_BOOL(sub_cancel);
+       state_fio->StateBool(extdet_neg);
+       state_fio->StateBool(sub_halt);
+       state_fio->StateBool(sub_cancel);
        // FD06, 07
-       DECL_STATE_ENTRY_BOOL(intstat_syndet);
-       DECL_STATE_ENTRY_BOOL(intstat_rxrdy);
-       DECL_STATE_ENTRY_BOOL(intstat_txrdy);
+       state_fio->StateBool(intstat_syndet);
+       state_fio->StateBool(intstat_rxrdy);
+       state_fio->StateBool(intstat_txrdy);
        
        
-       DECL_STATE_ENTRY_BOOL(intstat_opn);
-       DECL_STATE_ENTRY_BOOL(intstat_mouse);
-       DECL_STATE_ENTRY_BOOL(mouse_enable);
+       state_fio->StateBool(intstat_opn);
+       state_fio->StateBool(intstat_mouse);
+       state_fio->StateBool(mouse_enable);
        
-       DECL_STATE_ENTRY_BOOL(intstat_whg);
-       DECL_STATE_ENTRY_BOOL(intstat_thg);
+       state_fio->StateBool(intstat_whg);
+       state_fio->StateBool(intstat_thg);
        
        // FDC
-       DECL_STATE_ENTRY_BOOL(connect_fdc);
-       DECL_STATE_ENTRY_UINT8(fdc_statreg);
-       DECL_STATE_ENTRY_UINT8(fdc_cmdreg);
-       DECL_STATE_ENTRY_UINT8(fdc_trackreg);
-       DECL_STATE_ENTRY_UINT8(fdc_sectreg);
-       DECL_STATE_ENTRY_UINT8(fdc_datareg);
-       DECL_STATE_ENTRY_UINT8(fdc_headreg);
-       DECL_STATE_ENTRY_UINT8(fdc_drvsel);
-       DECL_STATE_ENTRY_UINT8(irqreg_fdc);
-       DECL_STATE_ENTRY_BOOL(fdc_motor);
-       DECL_STATE_ENTRY_BOOL(irqstat_fdc);
+       state_fio->StateBool(connect_fdc);
+       state_fio->StateUint8(fdc_statreg);
+       state_fio->StateUint8(fdc_cmdreg);
+       state_fio->StateUint8(fdc_trackreg);
+       state_fio->StateUint8(fdc_sectreg);
+       state_fio->StateUint8(fdc_datareg);
+       state_fio->StateUint8(fdc_headreg);
+       state_fio->StateUint8(fdc_drvsel);
+       state_fio->StateUint8(irqreg_fdc);
+       state_fio->StateBool(fdc_motor);
+       state_fio->StateBool(irqstat_fdc);
        // KANJI ROM
-       DECL_STATE_ENTRY_BOOL(connect_kanjiroml1);
+       state_fio->StateBool(connect_kanjiroml1);
 #if defined(_FM77AV_VARIANTS)
-       DECL_STATE_ENTRY_BOOL(connect_kanjiroml2);
-       
-       DECL_STATE_ENTRY_BOOL(boot_ram);
-       DECL_STATE_ENTRY_BOOL(hotreset);
-               // FD13
-       DECL_STATE_ENTRY_UINT8(sub_monitor_type);
+       state_fio->StateBool(connect_kanjiroml2);
+       state_fio->StateBool(boot_ram);
+       state_fio->StateBool(hotreset);
+       // FD13
+       state_fio->StateUint8(sub_monitor_type);
 #endif 
-               // MMR
-       //V2
-       {
-               DECL_STATE_ENTRY_INT(event_beep);
-               DECL_STATE_ENTRY_INT(event_beep_oneshot);
-               DECL_STATE_ENTRY_INT(event_timerirq);
-       }               
-       { // V3
-               DECL_STATE_ENTRY_INT(event_fdc_motor);
+       { // V2
+               state_fio->StateInt32(event_beep);
+               state_fio->StateInt32(event_beep_oneshot);
+               state_fio->StateInt32(event_timerirq);
+       }               
+       {  // V3
+               state_fio->StateInt32(event_fdc_motor);
 #if defined(_FM77AV40) || defined(_FM77AV40EX) || defined(_FM77AV40SX)|| \
-    defined(_FM77AV20) || defined(_FM77AV20SX) || defined(_FM77AV20EX)
-               DECL_STATE_ENTRY_UINT8_ARRAY(fdc_drive_table, 4);
-               DECL_STATE_ENTRY_UINT8(fdc_reg_fd1e);
+       defined(_FM77AV20) || defined(_FM77AV20SX) || defined(_FM77AV20EX)
+               state_fio->StateBuffer(fdc_drive_table, sizeof(fdc_drive_table), 1);
+               state_fio->StateUint8(fdc_reg_fd1e);
 #endif 
 #if defined(HAS_DMA)
-               DECL_STATE_ENTRY_BOOL(intstat_dma);
-               DECL_STATE_ENTRY_UINT8(dma_addr);
+               state_fio->StateBool(intstat_dma);
+               state_fio->StateUint8(dma_addr);
 #endif                 
 #if defined(_FM77AV_VARIANTS)
-               DECL_STATE_ENTRY_UINT8(reg_fd12);
+               state_fio->StateUint8(reg_fd12);
 #endif         
-       }
+       }
 // FD05
-       DECL_STATE_ENTRY_BOOL(req_z80run);
-       DECL_STATE_ENTRY_BOOL(z80_run);
-
-       // UART
-       DECL_STATE_ENTRY_BOOL(rs232c_enabled);
-       DECL_STATE_ENTRY_BOOL(rs232c_dcd);
-       DECL_STATE_ENTRY_BOOL_ARRAY(uart_enabled, 3);
+       state_fio->StateBool(req_z80run);
+       state_fio->StateBool(z80_run);
+ 
+       // UART
+       state_fio->StateBool(rs232c_enabled);
+       state_fio->StateBool(rs232c_dcd);
+       state_fio->StateBuffer(uart_enabled, sizeof(uart_enabled), 1);
        
-       DECL_STATE_ENTRY_BOOL(modem_irqmask_rxrdy);
-       DECL_STATE_ENTRY_BOOL(modem_irqmask_txrdy);
-       DECL_STATE_ENTRY_BOOL(modem_syndet);
-       DECL_STATE_ENTRY_BOOL(modem_rxrdy);
-       DECL_STATE_ENTRY_BOOL(modem_txrdy);
-
-       DECL_STATE_ENTRY_BOOL(midi_uart_irqmask);
-       DECL_STATE_ENTRY_BOOL(midi_syndet);
-       DECL_STATE_ENTRY_BOOL(midi_rxrdy);
-       DECL_STATE_ENTRY_BOOL(midi_txrdy);
+       state_fio->StateBool(modem_irqmask_rxrdy);
+       state_fio->StateBool(modem_irqmask_txrdy);
+       state_fio->StateBool(modem_syndet);
+       state_fio->StateBool(modem_rxrdy);
+       state_fio->StateBool(modem_txrdy);
+
+       state_fio->StateBool(midi_uart_irqmask);
+       state_fio->StateBool(midi_syndet);
+       state_fio->StateBool(midi_rxrdy);
+       state_fio->StateBool(midi_txrdy);
 #if defined(HAS_2HD)
-       DECL_STATE_ENTRY_INT(event_fdc_motor_2HD);
-       DECL_STATE_ENTRY_BOOL(connect_fdc_2HD);
-       DECL_STATE_ENTRY_UINT8(fdc_2HD_statreg);
-       DECL_STATE_ENTRY_UINT8(fdc_2HD_cmdreg);
-       DECL_STATE_ENTRY_UINT8(fdc_2HD_trackreg);
-       DECL_STATE_ENTRY_UINT8(fdc_2HD_sectreg);
-       DECL_STATE_ENTRY_UINT8(fdc_2HD_datareg);
-       DECL_STATE_ENTRY_UINT8(fdc_2HD_headreg);
-       DECL_STATE_ENTRY_UINT8(fdc_2HD_drvsel);
-       DECL_STATE_ENTRY_UINT8(irqreg_fdc_2HD);
-       DECL_STATE_ENTRY_BOOL(fdc_2HD_motor);
-       //state_fio->FputBool(irqstat_fdc);
-       DECL_STATE_ENTRY_INT(event_2hd_nmi);
-       DECL_STATE_ENTRY_UINT32(nmi_delay);
-       DECL_STATE_ENTRY_BOOL(irqstat_fdc_2hd);
-       DECL_STATE_ENTRY_BOOL(drqstat_fdc_2hd);
+       state_fio->StateInt32(event_fdc_motor_2HD);
+       state_fio->StateBool(connect_fdc_2HD);
+       state_fio->StateUint8(fdc_2HD_statreg);
+       state_fio->StateUint8(fdc_2HD_cmdreg);
+       state_fio->StateUint8(fdc_2HD_trackreg);
+       state_fio->StateUint8(fdc_2HD_sectreg);
+       state_fio->StateUint8(fdc_2HD_datareg);
+       state_fio->StateUint8(fdc_2HD_headreg);
+       state_fio->StateUint8(fdc_2HD_drvsel);
+       state_fio->StateUint8(irqreg_fdc_2HD);
+       state_fio->StateBool(fdc_2HD_motor);
+       state_fio->StateInt32(event_2hd_nmi);
+       state_fio->StateUint32(nmi_delay);
+       state_fio->StateBool(irqstat_fdc_2hd);
+       state_fio->StateBool(drqstat_fdc_2hd);
 #endif
        
-       decl_state_opn();
+       if(!decl_state_opn(state_fio, loading)) {
+               return false;
+       }
        
-       leave_decl_state();
+       return true;
 }
+
 void FM7_MAINIO::save_state(FILEIO *state_fio)
 {
-       if(state_entry != NULL) state_entry->save_state(state_fio);
+       decl_state(state_fio, false);
 #if 0
        // Debug
        for(int i = 0; i < 3; i++) {
@@ -2119,24 +2122,20 @@ void FM7_MAINIO::save_state(FILEIO *state_fio)
                                                  opn_regs[i][ladr + 8],  opn_regs[i][ladr + 9],  opn_regs[i][ladr + 10], opn_regs[i][ladr + 11],
                                                  opn_regs[i][ladr + 12], opn_regs[i][ladr + 13], opn_regs[i][ladr + 14], opn_regs[i][ladr + 15]);
                }
-       }
+       }
 #endif 
 }
-
+ 
 bool FM7_MAINIO::load_state(FILEIO *state_fio)
 {
-       int ch;
        int addr;
        //bool stat = false;
        uint32_t version;
-       bool mb = false;
-       if(state_entry != NULL) {
-               mb = state_entry->load_state(state_fio);
-               if(mb) {
+       bool mb = decl_state(state_fio, true);
+       if(mb) {
 #if defined(HAS_DMA)
-                       dma_addr = dma_addr & 0x1f;
+               dma_addr = dma_addr & 0x1f;
 #endif
-               }
        }
 #if 0
        for(int i = 0; i < 3; i++) {
@@ -2150,9 +2149,8 @@ bool FM7_MAINIO::load_state(FILEIO *state_fio)
                                                  opn_regs[i][ladr + 8],  opn_regs[i][ladr + 9],  opn_regs[i][ladr + 10], opn_regs[i][ladr + 11],
                                                  opn_regs[i][ladr + 12], opn_regs[i][ladr + 13], opn_regs[i][ladr + 14], opn_regs[i][ladr + 15]);
                }
-       }
-#endif
+       }
        this->out_debug_log(_T("Load State: MAINIO: id=%d stat=%s\n"), this_device_id, (mb) ? _T("OK") : _T("NG"));
        return mb;
 }
-         
+         

diff --git a/source/src/vm/fm7/fm7_mainio.h b/source/src/vm/fm7/fm7_mainio.h
index 75501f5..b31b205 100644 (file)
--- a/source/src/vm/fm7/fm7_mainio.h
+++ b/source/src/vm/fm7/fm7_mainio.h
@@ -495,7 +495,8 @@ class FM7_MAINIO : public DEVICE {
                return static_cast<T *>(np)->read_dma_data8(addr);
        }
 
-       void decl_state_opn(void);
+       bool decl_state_opn(FILEIO *state_fio, bool loading);
+
 public:
        FM7_MAINIO(VM_TEMPLATE* parent_vm, EMU* parent_emu);
        ~FM7_MAINIO();
@@ -522,7 +523,7 @@ public:
        virtual void update_config();
        virtual void save_state(FILEIO *state_fio);
        virtual bool load_state(FILEIO *state_fio);
-       virtual void decl_state(void);
+       virtual bool decl_state(FILEIO *state_fio, bool loading);
        
        void set_context_printer(DEVICE *p)
        {

diff --git a/source/src/vm/fm7/fm7_mainmem.cpp b/source/src/vm/fm7/fm7_mainmem.cpp
index 0f79baf..a69e2e0 100644 (file)
--- a/source/src/vm/fm7/fm7_mainmem.cpp
+++ b/source/src/vm/fm7/fm7_mainmem.cpp
@@ -518,132 +518,133 @@ void FM7_MAINMEM::update_config()
        setclock(config.cpu_type);
 }
 
-#define STATE_VERSION 7
+#define STATE_VERSION 8
 
-#include "../../statesub.h"
-
-void FM7_MAINMEM::decl_state(void)
+bool FM7_MAINMEM::decl_state(FILEIO *state_fio, bool loading)
 {
-       enter_decl_state(STATE_VERSION);
-       
-       DECL_STATE_ENTRY_BOOL(ioaccess_wait);
-       DECL_STATE_ENTRY_INT32(waitfactor);
-       DECL_STATE_ENTRY_INT32(waitcount);
-       DECL_STATE_ENTRY_BOOL(sub_halted);
+       if(!state_fio->StateCheckUint32(STATE_VERSION)) {
+               return false;
+       }
+       if(!state_fio->StateCheckInt32(this_device_id)) {
+               return false;
+       }
        
-       DECL_STATE_ENTRY_BOOL(diag_load_basicrom);
-       DECL_STATE_ENTRY_BOOL(diag_load_bootrom_bas);
-       DECL_STATE_ENTRY_BOOL(diag_load_bootrom_dos);
-       DECL_STATE_ENTRY_BOOL(diag_load_bootrom_mmr);
-       DECL_STATE_ENTRY_BOOL(diag_load_bootrom_bubble);
-       DECL_STATE_ENTRY_BOOL(diag_load_bootrom_bubble_128k);
-       DECL_STATE_ENTRY_BOOL(diag_load_bootrom_sfd8);
-       DECL_STATE_ENTRY_BOOL(diag_load_bootrom_2hd);
-
-       DECL_STATE_ENTRY_1D_ARRAY(fm7_mainmem_omote, sizeof(fm7_mainmem_omote));
-       DECL_STATE_ENTRY_1D_ARRAY(fm7_mainmem_ura, sizeof(fm7_mainmem_ura));
-       DECL_STATE_ENTRY_1D_ARRAY(fm7_mainmem_basicrom, sizeof(fm7_mainmem_basicrom));
-       DECL_STATE_ENTRY_1D_ARRAY(fm7_mainmem_bioswork, sizeof(fm7_mainmem_bioswork));
-       DECL_STATE_ENTRY_1D_ARRAY(fm7_mainmem_bootrom_vector, sizeof(fm7_mainmem_bootrom_vector));
-       DECL_STATE_ENTRY_1D_ARRAY(fm7_mainmem_reset_vector, sizeof(fm7_mainmem_reset_vector));
+       state_fio->StateBool(ioaccess_wait);
+       state_fio->StateInt32(waitfactor);
+       state_fio->StateInt32(waitcount);
+       state_fio->StateBool(sub_halted);
        
-       DECL_STATE_ENTRY_1D_ARRAY(fm7_mainmem_null, sizeof(fm7_mainmem_null));
+       state_fio->StateBool(diag_load_basicrom);
+       state_fio->StateBool(diag_load_bootrom_bas);
+       state_fio->StateBool(diag_load_bootrom_dos);
+       state_fio->StateBool(diag_load_bootrom_mmr);
+       state_fio->StateBool(diag_load_bootrom_bubble);
+       state_fio->StateBool(diag_load_bootrom_bubble_128k);
+       state_fio->StateBool(diag_load_bootrom_sfd8);
+       state_fio->StateBool(diag_load_bootrom_2hd);
+
+       state_fio->StateBuffer(fm7_mainmem_omote, sizeof(fm7_mainmem_omote), 1);
+       state_fio->StateBuffer(fm7_mainmem_ura, sizeof(fm7_mainmem_ura), 1);
+       state_fio->StateBuffer(fm7_mainmem_basicrom, sizeof(fm7_mainmem_basicrom), 1);
+       state_fio->StateBuffer(fm7_mainmem_bioswork, sizeof(fm7_mainmem_bioswork), 1);
+       state_fio->StateBuffer(fm7_mainmem_bootrom_vector, sizeof(fm7_mainmem_bootrom_vector), 1);
+       state_fio->StateBuffer(fm7_mainmem_reset_vector, sizeof(fm7_mainmem_reset_vector), 1);
+       
+       state_fio->StateBuffer(fm7_mainmem_null, sizeof(fm7_mainmem_null), 1);
 
 #if defined(_FM77AV_VARIANTS) || defined(_FM77_VARIANTS)
-       DECL_STATE_ENTRY_1D_ARRAY(fm7_bootram, sizeof(fm7_bootram));
+       state_fio->StateBuffer(fm7_bootram, sizeof(fm7_bootram), 1);
 #endif 
 #if defined(_FM77_VARIANTS) || defined(_FM8)
-       for(int i = 0; i < 8; i++) DECL_STATE_ENTRY_1D_ARRAY_MEMBER(fm7_bootroms[i], 0x200, i);
+       for(int i = 0; i < 8; i++) state_fio->StateBuffer(fm7_bootroms[i], 0x200, 1);
 #elif defined(_FM7) || defined(_FMNEW7)
-       for(int i = 0; i < 4; i++) DECL_STATE_ENTRY_1D_ARRAY_MEMBER(fm7_bootroms[i], 0x200, i);
+       for(int i = 0; i < 4; i++) state_fio->StateBuffer(fm7_bootroms[i], 0x200, 1);
 #endif 
 
 #if defined(_FM8)
-       DECL_STATE_ENTRY_BOOL(diag_load_sm11_14);
-       DECL_STATE_ENTRY_BOOL(diag_load_sm11_15);
+       state_fio->StateBool(diag_load_sm11_14);
+       state_fio->StateBool(diag_load_sm11_15);
 #elif defined(_FM77_VARIANTS)
-       DECL_STATE_ENTRY_BOOL(diag_load_wb11_12);
+       state_fio->StateBool(diag_load_wb11_12);
 #elif defined(_FM7) || defined(_FMNEW7)
-       DECL_STATE_ENTRY_BOOL(diag_load_tl11_11);
+       state_fio->StateBool(diag_load_tl11_11);
 #  if defined(_FMNEW7)
-       DECL_STATE_ENTRY_BOOL(diag_load_tl11_12);
+       state_fio->StateBool(diag_load_tl11_12);
 #  endif       
 #elif defined(_FM77AV_VARIANTS)
-       DECL_STATE_ENTRY_BOOL(dictrom_connected);
-       DECL_STATE_ENTRY_BOOL(use_page2_extram);
-       
-       DECL_STATE_ENTRY_BOOL(diag_load_initrom);
-       DECL_STATE_ENTRY_BOOL(diag_load_dictrom);
-       DECL_STATE_ENTRY_BOOL(diag_load_learndata);
-       DECL_STATE_ENTRY_1D_ARRAY(fm7_mainmem_initrom, sizeof(fm7_mainmem_initrom));
-       DECL_STATE_ENTRY_1D_ARRAY(fm77av_hidden_bootmmr, sizeof(fm77av_hidden_bootmmr));
-       
-       DECL_STATE_ENTRY_1D_ARRAY(fm7_mainmem_mmrbank_0, sizeof(fm7_mainmem_mmrbank_0));
-       DECL_STATE_ENTRY_1D_ARRAY(fm7_mainmem_mmrbank_2, sizeof(fm7_mainmem_mmrbank_2));
-       
+       state_fio->StateBool(dictrom_connected);
+       state_fio->StateBool(use_page2_extram);
+       
+       state_fio->StateBool(diag_load_initrom);
+       state_fio->StateBool(diag_load_dictrom);
+       state_fio->StateBool(diag_load_learndata);
+       state_fio->StateBuffer(fm7_mainmem_initrom, sizeof(fm7_mainmem_initrom), 1);
+       state_fio->StateBuffer(fm77av_hidden_bootmmr, sizeof(fm77av_hidden_bootmmr), 1);
+       
+       state_fio->StateBuffer(fm7_mainmem_mmrbank_0, sizeof(fm7_mainmem_mmrbank_0), 1);
+       state_fio->StateBuffer(fm7_mainmem_mmrbank_2, sizeof(fm7_mainmem_mmrbank_2), 1);
+       
 # if defined(_FM77AV40EX) || defined(_FM77AV40SX)
-       DECL_STATE_ENTRY_BOOL(diag_load_extrarom);
-       DECL_STATE_ENTRY_1D_ARRAY(fm7_mainmem_extrarom, sizeof(fm7_mainmem_extrarom));
+       state_fio->StateBool(diag_load_extrarom);
+       state_fio->StateBuffer(fm7_mainmem_extrarom, sizeof(fm7_mainmem_extrarom), 1);
 # endif
 # if defined(CAPABLE_DICTROM)
-       DECL_STATE_ENTRY_1D_ARRAY(fm7_mainmem_dictrom, sizeof(fm7_mainmem_dictrom));
-       DECL_STATE_ENTRY_1D_ARRAY(fm7_mainmem_learndata, sizeof(fm7_mainmem_learndata));
+       state_fio->StateBuffer(fm7_mainmem_dictrom, sizeof(fm7_mainmem_dictrom), 1);
+       state_fio->StateBuffer(fm7_mainmem_learndata, sizeof(fm7_mainmem_learndata), 1);
 # endif
 #endif
 
 #ifdef HAS_MMR
-       DECL_STATE_ENTRY_BOOL(extram_connected);
+       state_fio->StateBool(extram_connected);
 # if defined(_FM77AV40) || defined(_FM77AV40EX) || defined(_FM77AV40SX) || \
-        defined(_FM77_VARIANTS)
-       DECL_STATE_ENTRY_INT32(extram_pages);
-       DECL_STATE_ENTRY_VARARRAY_VAR(fm7_mainmem_extram, extram_size);
+       defined(_FM77_VARIANTS)
+       state_fio->StateInt32(extram_pages);
+       state_fio->StateBuffer(fm7_mainmem_extram, extram_size, 1);
 #  if defined(_FM77_VARIANTS)
-       DECL_STATE_ENTRY_1D_ARRAY(fm77_shadowram, sizeof(fm77_shadowram));
+       state_fio->StateBuffer(fm77_shadowram, sizeof(fm77_shadowram), 1);
 #  endif
 # endif
 #endif
                                                          
-       { // V2;
-               DECL_STATE_ENTRY_BOOL(is_basicrom);
-               DECL_STATE_ENTRY_BOOL(clockmode);
-               DECL_STATE_ENTRY_BOOL(basicrom_fd0f);
-               DECL_STATE_ENTRY_UINT32(bootmode);
+       { // V2;
+               state_fio->StateBool(is_basicrom);
+               state_fio->StateBool(clockmode);
+               state_fio->StateBool(basicrom_fd0f);
+               state_fio->StateUint32(bootmode);
 #if defined(_FM77AV_VARIANTS)
-               DECL_STATE_ENTRY_UINT32(extcard_bank);
-               DECL_STATE_ENTRY_BOOL(extrom_bank);
-               DECL_STATE_ENTRY_BOOL(initiator_enabled);
-               DECL_STATE_ENTRY_BOOL(dictrom_enabled);
-               DECL_STATE_ENTRY_BOOL(dictram_enabled);
+               state_fio->StateUint32(extcard_bank);
+               state_fio->StateBool(extrom_bank);
+               state_fio->StateBool(initiator_enabled);
+               state_fio->StateBool(dictrom_enabled);
+               state_fio->StateBool(dictram_enabled);
 #endif
 #if defined(_FM77AV_VARIANTS) || defined(_FM77_VARIANTS)
-               DECL_STATE_ENTRY_BOOL(boot_ram_write);
+               state_fio->StateBool(boot_ram_write);
 #endif         
 #if defined(HAS_MMR)
-               DECL_STATE_ENTRY_BOOL(window_enabled);
-               DECL_STATE_ENTRY_BOOL(mmr_enabled);
-               DECL_STATE_ENTRY_BOOL(mmr_fast);
-               DECL_STATE_ENTRY_BOOL(mmr_extend);
-               
-               DECL_STATE_ENTRY_UINT16(window_offset);
-               DECL_STATE_ENTRY_BOOL(window_fast);
-               DECL_STATE_ENTRY_BOOL(refresh_fast);
-               DECL_STATE_ENTRY_UINT8(mmr_segment);
-               DECL_STATE_ENTRY_1D_ARRAY(mmr_map_data, sizeof(mmr_map_data));
+               state_fio->StateBool(window_enabled);
+               state_fio->StateBool(mmr_enabled);
+               state_fio->StateBool(mmr_fast);
+               state_fio->StateBool(mmr_extend);
+               
+               state_fio->StateUint16(window_offset);
+               state_fio->StateBool(window_fast);
+               state_fio->StateBool(refresh_fast);
+               state_fio->StateUint8(mmr_segment);
+               state_fio->StateBuffer(mmr_map_data, sizeof(mmr_map_data), 1);
 #endif
-       }
-       DECL_STATE_ENTRY_UINT32(mem_waitfactor); // OK?
-       DECL_STATE_ENTRY_UINT32(mem_waitcount); // OK?
-
-       DECL_STATE_ENTRY_UINT32(cpu_clocks); // OK?
+       }
+       state_fio->StateUint32(mem_waitfactor); // OK?
+       state_fio->StateUint32(mem_waitcount); // OK?
 
-       leave_decl_state();
+       state_fio->StateInt32(cpu_clocks); // OK?
+ 
+       return true;
 }
 
 void FM7_MAINMEM::save_state(FILEIO *state_fio)
 {
-       if(state_entry != NULL) {
-               state_entry->save_state(state_fio);
-       }
+       decl_state(state_fio, false);
 #if defined(HAS_MMR)
 #  if defined(_FM77_VARIANTS)
        if(extram_pages > 3) extram_pages = 3;
@@ -656,12 +657,10 @@ void FM7_MAINMEM::save_state(FILEIO *state_fio)
 
 bool FM7_MAINMEM::load_state(FILEIO *state_fio)
 {
-       bool mb = false;
-       if(state_entry != NULL) {
-               mb = state_entry->load_state(state_fio);
-               this->out_debug_log(_T("Load State: MAINIO: id=%d stat=%s\n"), this_device_id, (mb) ? _T("OK") : _T("NG"));
-               if(!mb) return false;
-       }
+       bool mb = decl_state(state_fio, true);
+       this->out_debug_log(_T("Load State: MAINMEM: id=%d stat=%s\n"), this_device_id, (mb) ? _T("OK") : _T("NG"));
+       if(!mb) return false;
+       
 #if defined(HAS_MMR)
 #  if defined(_FM77_VARIANTS)
        if(extram_pages > 3) extram_pages = 3;
@@ -670,7 +669,7 @@ bool FM7_MAINMEM::load_state(FILEIO *state_fio)
 #  endif
 #endif
        //extram_size = extram_pages * 0x10000;
-       init_data_table();
-       update_all_mmr_jumptable();
-       return true;
+       init_data_table();
+       update_all_mmr_jumptable();
+       return true;
 }

diff --git a/source/src/vm/fm7/fm7_mainmem.h b/source/src/vm/fm7/fm7_mainmem.h
index 7f5ba5a..1c57383 100644 (file)
--- a/source/src/vm/fm7/fm7_mainmem.h
+++ b/source/src/vm/fm7/fm7_mainmem.h
@@ -249,10 +249,11 @@ class FM7_MAINMEM : public DEVICE
        bool get_loadstat_basicrom(void);
        bool get_loadstat_bootrom_bas(void);
        bool get_loadstat_bootrom_dos(void);
-       void decl_state();
-       void save_state(FILEIO *state_fio);
        void update_config();
+       
+       void save_state(FILEIO *state_fio);
        bool load_state(FILEIO *state_fio);
+       bool decl_state(FILEIO *state_fio, bool loading);
 
        void set_context_display(DEVICE *p){
                display = (DISPLAY *)p;

diff --git a/source/src/vm/fm7/fm8_mainio.cpp b/source/src/vm/fm7/fm8_mainio.cpp
index 9df5edc..97ae868 100644 (file)
--- a/source/src/vm/fm7/fm8_mainio.cpp
+++ b/source/src/vm/fm7/fm8_mainio.cpp
@@ -456,26 +456,23 @@ void FM8_MAINIO::update_config()
        mainmem->write_signal(FM7_MAINIO_BOOTMODE, bootmode, 0xffffffff);
 }
 
-
-#include "../../statesub.h"
-void FM8_MAINIO::decl_state(void)
+bool FM8_MAINIO::decl_state(FILEIO *state_fio, bool loading)
 {
-       FM7_MAINIO::decl_state();
-       DECL_STATE_ENTRY_BOOL(connect_psg);
+       if(!FM7_MAINIO::decl_state(state_fio, loading)) {
+               return false;
+       }
+       state_fio->StateBool(connect_psg);
+
+       return true;
 }
 
 void FM8_MAINIO::save_state(FILEIO *state_fio)
 {
-       if(state_entry != NULL) {
-               state_entry->save_state(state_fio);
-       }
+       decl_state(state_fio, false);
 }
-
+ 
 bool FM8_MAINIO::load_state(FILEIO *state_fio)
 {
-       bool mb = false;
-       if(state_entry != NULL) {
-               mb = state_entry->load_state(state_fio);
-       }
+       bool mb = decl_state(state_fio, true);
        return mb;
 }

diff --git a/source/src/vm/fm7/fm8_mainio.h b/source/src/vm/fm7/fm8_mainio.h
index 5bb3cd5..8de3506 100644 (file)
--- a/source/src/vm/fm7/fm8_mainio.h
+++ b/source/src/vm/fm7/fm8_mainio.h
@@ -57,7 +57,7 @@ public:
        void update_config();
        void save_state(FILEIO *state_fio) override;
        bool load_state(FILEIO *state_fio) override;
-       void decl_state(void) override;
+       bool decl_state(FILEIO *state_fio, bool loading) override;
 
        void set_context_kanjirom_class2(DEVICE *p)
        {

diff --git a/source/src/vm/fm7/hd6844.cpp b/source/src/vm/fm7/hd6844.cpp
index 254c6d3..00e1cb0 100644 (file)
--- a/source/src/vm/fm7/hd6844.cpp
+++ b/source/src/vm/fm7/hd6844.cpp
@@ -444,49 +444,38 @@ void HD6844::event_callback(int event_id, int err)
        }
 }
 
-#define STATE_VERSION 4
+#define STATE_VERSION 5
 
-void HD6844::decl_state(void)
+bool HD6844::process_state(FILEIO *state_fio, bool loading)
 {
-       enter_decl_state(STATE_VERSION);
 
-       DECL_STATE_ENTRY_INT(this_device_id);
-       DECL_STATE_ENTRY_UINT32_ARRAY(addr_reg, 4);
-       DECL_STATE_ENTRY_UINT16_ARRAY(words_reg, 4);
-       DECL_STATE_ENTRY_UINT8_ARRAY(channel_control, 4);
-       
-       DECL_STATE_ENTRY_UINT8(priority_reg);
-       DECL_STATE_ENTRY_UINT8(interrupt_reg);
-       DECL_STATE_ENTRY_UINT8(datachain_reg);
-       DECL_STATE_ENTRY_UINT8(num_reg);
-       DECL_STATE_ENTRY_UINT32(addr_offset);
+       if(!state_fio->StateCheckUint32(STATE_VERSION)) {
+               return false;
+       }
+       if(!state_fio->StateCheckInt32(this_device_id)) {
+               return false;
+       }
+       for(int i = 0; i < 4; i++) {
+               state_fio->StateUint32(addr_reg[i]);
+               state_fio->StateUint16(words_reg[i]);
+               state_fio->StateUint8(channel_control[i]);
+       }
+       state_fio->StateUint8(priority_reg);
+       state_fio->StateUint8(interrupt_reg);
+       state_fio->StateUint8(datachain_reg);
+       state_fio->StateUint8(num_reg);
+       state_fio->StateUint32(addr_offset);
                
-       DECL_STATE_ENTRY_BOOL_ARRAY(transfering, 4);
-       DECL_STATE_ENTRY_BOOL_ARRAY(first_transfer, 4);
-       DECL_STATE_ENTRY_BOOL_ARRAY(cycle_steal, 4);
-       DECL_STATE_ENTRY_BOOL_ARRAY(halt_flag, 4);
+       for(int i = 0; i < 4; i++) {
+               state_fio->StateBool(transfering[i]);
+               state_fio->StateBool(first_transfer[i]);
+               state_fio->StateBool(cycle_steal[i]);
+               state_fio->StateBool(halt_flag[i]);
                
-       DECL_STATE_ENTRY_UINT32_ARRAY(fixed_addr, 4);
-       DECL_STATE_ENTRY_UINT8_ARRAY(data_reg, 4);
-       DECL_STATE_ENTRY_INT32_ARRAY(event_dmac, 4);
-
-       leave_decl_state();
-}
-
-void HD6844::save_state(FILEIO *state_fio)
-{
-       if(state_entry != NULL) {
-               state_entry->save_state(state_fio);
-               out_debug_log(_T("Save State: HD6844: id=%d ver=%d"), this_device_id, STATE_VERSION);
+               state_fio->StateUint32(fixed_addr[i]);
+               state_fio->StateUint8(data_reg[i]);
+               state_fio->StateInt32(event_dmac[i]);
        }
+       return true;
 }
 
-bool HD6844::load_state(FILEIO *state_fio)
-{
-       bool mb = false;
-       if(state_entry != NULL) {
-               mb = state_entry->load_state(state_fio);
-               out_debug_log(_T("Load State: HD6844: id=%d stat=%s"), this_device_id, (mb) ? _T("OK") : _T("NG"));
-       }
-       return mb;
-}

diff --git a/source/src/vm/fm7/hd6844.h b/source/src/vm/fm7/hd6844.h
index 21ce137..7235426 100644 (file)
--- a/source/src/vm/fm7/hd6844.h
+++ b/source/src/vm/fm7/hd6844.h
@@ -112,9 +112,7 @@ protected:
        void initialize(void);
        void reset(void);
        //void update_config(void);
-       void save_state(FILEIO *state_fio);
-       bool load_state(FILEIO *state_fio);
-       void decl_state(void);
+       bool process_state(FILEIO *state_fio, bool loading);
        
        void set_context_int_line(DEVICE *p, int id, uint32_t mask) {
                register_output_signal(&interrupt_line, p, id, mask);

diff --git a/source/src/vm/fm7/jcommcard.cpp b/source/src/vm/fm7/jcommcard.cpp
index 523bd7d..4498fef 100644 (file)
--- a/source/src/vm/fm7/jcommcard.cpp
+++ b/source/src/vm/fm7/jcommcard.cpp
@@ -216,71 +216,42 @@ void FM7_JCOMMCARD::reset(void)
        }
 }
 
-#define STATE_VERSION 3
-#include "../../statesub.h"
+#define STATE_VERSION 4
 
-void FM7_JCOMMCARD::decl_state(void)
+bool FM7_JCOMMCARD::process_state(FILEIO *state_fio, bool loading)
 {
-       enter_decl_state(STATE_VERSION);
+       if(!state_fio->StateCheckUint32(STATE_VERSION)) {
+               return false;
+       }
+       if(!state_fio->StateCheckInt32(this_device_id)) {
+               return false;
+       }
  
-       DECL_STATE_ENTRY_SINGLE(n_bank);
-       DECL_STATE_ENTRY_SINGLE(rcb_address);
-       DECL_STATE_ENTRY_SINGLE(kanji_address);
-       DECL_STATE_ENTRY_SINGLE(halted);
-
-       DECL_STATE_ENTRY_1D_ARRAY(prog_rom, 0x4000);
-       DECL_STATE_ENTRY_1D_ARRAY(dict_rom, 0x60000);
-       DECL_STATE_ENTRY_1D_ARRAY(p_ram, 0x2000);
-       DECL_STATE_ENTRY_BOOL(firmware_ok);
-
-       leave_decl_state();
-}
-
-void FM7_JCOMMCARD::save_state(FILEIO *state_fio)
-{
-       //state_fio->FputUint32_BE(STATE_VERSION);
-       //state_fio->FputInt32_BE(this_device_id);
-       this->out_debug_log(_T("Save State: JCOMM CARD: id=%d ver=%d\n"), this_device_id, STATE_VERSION);
+       state_fio->StateUint8(n_bank);
+       state_fio->StateUint8(rcb_address);
+       state_fio->StateUint32(kanji_address.d);
+       state_fio->StateBool(halted);
 
-       if(state_entry != NULL) state_entry->save_state(state_fio);
-       //state_fio->FputUint8(n_bank & 0x3f);
-       //state_fio->FputUint8(rcb_address);
-       //state_fio->FputUint32_BE(kanji_address.d);
+       state_fio->StateBuffer(prog_rom, sizeof(prog_rom), 1);
+       state_fio->StateBuffer(dict_rom, sizeof(dict_rom), 1);
+       state_fio->StateBuffer(p_ram, sizeof(p_ram), 1);
+       state_fio->StateBool(firmware_ok);
 
-       //state_fio->FputBool(halted);
+       if(loading) {
+               n_bank &= 0x3f;
 
-       //state_fio->Fwrite(prog_rom, sizeof(prog_rom), 1);
-       //state_fio->Fwrite(dict_rom, sizeof(dict_rom), 1);
-       //state_fio->Fwrite(p_ram, sizeof(p_ram), 1);
-       //state_fio->FputBool(firmware_ok);
-
-}
-
-bool FM7_JCOMMCARD::load_state(FILEIO *state_fio)
-{
-       //uint32_t version;
-       //version = state_fio->FgetUint32_BE();
-       //if(this_device_id != state_fio->FgetInt32_BE()) return false;
-       this->out_debug_log(_T("Load State: JCOMM CARD: id=%d ver=%d\n"), this_device_id, STATE_VERSION);
-       if(state_entry != NULL) {
-               if(!(state_entry->load_state(state_fio))) {
-                       return false;
-               }
-       } else {
-               return false;
+               //if(version >= 1) {
+               //      n_bank = state_fio->FgetUint8() & 0x3f;
+               //      rcb_address = state_fio->FgetUint8();
+               //      kanji_address.d = state_fio->FgetUint32_BE();
+               //      halted = state_fio->FgetBool();
+               //      state_fio->Fread(prog_rom, sizeof(prog_rom), 1);
+               //      state_fio->Fread(dict_rom, sizeof(dict_rom), 1);
+               //      state_fio->Fread(p_ram, sizeof(p_ram), 1);
+               //      firmware_ok = state_fio->FgetBool();
+               //modified = true; // Abondoned
+               //}
        }
-       n_bank &= 0x3f;
-
-       //if(version >= 1) {
-       //      n_bank = state_fio->FgetUint8() & 0x3f;
-       //      rcb_address = state_fio->FgetUint8();
-       //      kanji_address.d = state_fio->FgetUint32_BE();
-       //      halted = state_fio->FgetBool();
-       //      state_fio->Fread(prog_rom, sizeof(prog_rom), 1);
-       //      state_fio->Fread(dict_rom, sizeof(dict_rom), 1);
-       //      state_fio->Fread(p_ram, sizeof(p_ram), 1);
-       //      firmware_ok = state_fio->FgetBool();
-       //modified = true; // Abondoned
-       //}
        return true;
 }
+

diff --git a/source/src/vm/fm7/jcommcard.h b/source/src/vm/fm7/jcommcard.h
index 0c38c8e..113519d 100644 (file)
--- a/source/src/vm/fm7/jcommcard.h
+++ b/source/src/vm/fm7/jcommcard.h
@@ -61,9 +61,7 @@ public:
        void set_context_cpu(MC6809 *p) {
                cpu = p;
        }
-       void decl_state();
-       void save_state(FILEIO *state_fio);
-       bool load_state(FILEIO *state_fio);
+       bool process_state(FILEIO *state_fio, bool loading);
 };
 
 #endif  /* ___CSP_FM7_JCOMM_CARD_H  */

diff --git a/source/src/vm/fm7/joystick.cpp b/source/src/vm/fm7/joystick.cpp
index ecba0d6..b1eb591 100644 (file)
--- a/source/src/vm/fm7/joystick.cpp
+++ b/source/src/vm/fm7/joystick.cpp
@@ -294,50 +294,38 @@ void JOYSTICK::update_config(void)
        }
 #endif 
 }
-#define STATE_VERSION 4
+#define STATE_VERSION 5
 
-#include "../../statesub.h"
-
-void JOYSTICK::decl_state()
+bool JOYSTICK::process_state(FILEIO *state_fio, bool loading)
 {
-       state_entry = new csp_state_utils(STATE_VERSION, this_device_id, _T("JOYSTICK"));
-
-#if !defined(_FM8)
-       DECL_STATE_ENTRY_1D_ARRAY(emulate_mouse, 2);
-#endif         
-       DECL_STATE_ENTRY_1D_ARRAY(joydata, 2);
-
+       if(!state_fio->StateCheckUint32(STATE_VERSION)) {
+               return false;
+       }
+       if(!state_fio->StateCheckInt32(this_device_id)) {
+               return false;
+       }
+       for(int ch = 0; ch < 2; ch++) {
+               state_fio->StateUint32(joydata[ch]);
+       }
 #if !defined(_FM8)
-       DECL_STATE_ENTRY_INT32(dx);
-       DECL_STATE_ENTRY_INT32(dy);
-       DECL_STATE_ENTRY_INT32(lx);
-       DECL_STATE_ENTRY_INT32(ly);
-       DECL_STATE_ENTRY_UINT32(mouse_button);
-       DECL_STATE_ENTRY_BOOL(mouse_strobe);
-       DECL_STATE_ENTRY_UINT32(mouse_phase);
-       DECL_STATE_ENTRY_INT32(mouse_data);
-       //DECL_STATE_ENTRY_INT32(mouse_timeout_event);
-#endif 
-       // Version 3
-       DECL_STATE_ENTRY_UINT8(lpmask);
-       // Version 4
-       DECL_STATE_ENTRY_UINT8(port_b_val);
-}
-void JOYSTICK::save_state(FILEIO *state_fio)
-{
-       if(state_entry != NULL) {
-               state_entry->save_state(state_fio);
+       for(int ch = 0; ch < 2; ch++) {
+               state_fio->StateBool(emulate_mouse[ch]);
        }
-}
+       state_fio->StateInt32(dx);
+       state_fio->StateInt32(dy);
+       state_fio->StateInt32(lx);
+       state_fio->StateInt32(ly);
+       state_fio->StateUint32(mouse_button);
+       state_fio->StateBool(mouse_strobe);
+       state_fio->StateInt32(mouse_phase);
+       state_fio->StateUint32(mouse_data);
+       //state_fio->StateInt32(mouse_timeout_event);
+#endif 
+       // Version 3
+       state_fio->StateUint8(lpmask);
+       // Version 4
+       state_fio->StateUint8(port_b_val);
 
-bool JOYSTICK::load_state(FILEIO *state_fio)
-{
-       bool mb;
-       if(state_entry != NULL) {
-               mb = state_entry->load_state(state_fio);
-               if(!mb) return false;
-       }
        return true;
 }
-               
        

diff --git a/source/src/vm/fm7/joystick.h b/source/src/vm/fm7/joystick.h
index dccd9cd..b6d2738 100644 (file)
--- a/source/src/vm/fm7/joystick.h
+++ b/source/src/vm/fm7/joystick.h
@@ -53,9 +53,7 @@ class JOYSTICK : public DEVICE {
        
        void reset(void);
        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);
        
        void set_context_opn(DEVICE *p) {
                opn = p;

diff --git a/source/src/vm/fm7/kanjirom.cpp b/source/src/vm/fm7/kanjirom.cpp
index 170b6c0..930f4d6 100644 (file)
--- a/source/src/vm/fm7/kanjirom.cpp
+++ b/source/src/vm/fm7/kanjirom.cpp
@@ -103,36 +103,24 @@ void KANJIROM::release()
 {
 }
 
-#define STATE_VERSION 4
+#define STATE_VERSION 5
 
-#include "../../statesub.h"
-
-void KANJIROM::decl_state()
-{
-       enter_decl_state(STATE_VERSION);
-       
-       DECL_STATE_ENTRY_BOOL(class2);
-       DECL_STATE_ENTRY_BOOL(read_ok);
-       DECL_STATE_ENTRY_1D_ARRAY(data_table, sizeof(data_table));
-       DECL_STATE_ENTRY_PAIR(kanjiaddr);
-
-       leave_decl_state();
-}
-void KANJIROM::save_state(FILEIO *state_fio)
+bool KANJIROM::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;
        }
-}
-
-bool KANJIROM::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;
+       }
+       
+       state_fio->StateBool(class2);
+       state_fio->StateBool(read_ok);
+       state_fio->StateBuffer(data_table, sizeof(data_table), 1);
+       state_fio->StateUint32(kanjiaddr.d);
+       if(loading) {
+               kanjiaddr.w.h = 0;
        }
-       if(!mb) return false;
-       kanjiaddr.w.h = 0;
        return true;
 }
 

diff --git a/source/src/vm/fm7/kanjirom.h b/source/src/vm/fm7/kanjirom.h
index 67703cc..6250efd 100644 (file)
--- a/source/src/vm/fm7/kanjirom.h
+++ b/source/src/vm/fm7/kanjirom.h
@@ -31,8 +31,6 @@ public:
        void reset(void);
        bool get_readstat(void);
 
-       void decl_state();
-       void save_state(FILEIO *state_fio);
-       bool load_state(FILEIO *state_fio);
+       bool process_state(FILEIO *state_fio, bool loading);
 };
 #endif

diff --git a/source/src/vm/fm7/keyboard.cpp b/source/src/vm/fm7/keyboard.cpp
index 6c068ee..01d9588 100644 (file)
--- a/source/src/vm/fm7/keyboard.cpp
+++ b/source/src/vm/fm7/keyboard.cpp
@@ -1224,113 +1224,108 @@ KEYBOARD::~KEYBOARD()
 {
 }
 
-#define STATE_VERSION 8
+#define STATE_VERSION 9
 //#if defined(Q_OS_WIN)
 //DLL_PREFIX_I struct cur_time_s cur_time;
 //#endif
 
-#include "../../statesub.h"
-
-void KEYBOARD::decl_state()
+bool KEYBOARD::decl_state(FILEIO *state_fio, bool loading)
 {
-#if defined(_FM77AV_VARIANTS)
-       enter_decl_state(STATE_VERSION, _T("KEYBOARD_AND_RTC"));
-#else
-       enter_decl_state(STATE_VERSION, _T("KEYBOARD"));
-#endif
+       if(!state_fio->StateCheckUint32(STATE_VERSION)) {
+               return false;
+       }
+       if(!state_fio->StateCheckInt32(this_device_id)) {
+               return false;
+       }
        
-       DECL_STATE_ENTRY_UINT32(keycode_7);
-       DECL_STATE_ENTRY_INT32(keymode);
-          
-       DECL_STATE_ENTRY_BOOL(ctrl_pressed);
-       DECL_STATE_ENTRY_BOOL(lshift_pressed);
-       DECL_STATE_ENTRY_BOOL(rshift_pressed);
-       DECL_STATE_ENTRY_BOOL(shift_pressed);
-       DECL_STATE_ENTRY_BOOL(graph_pressed);
-       DECL_STATE_ENTRY_BOOL(caps_pressed);
-       DECL_STATE_ENTRY_BOOL(kana_pressed);
-       DECL_STATE_ENTRY_BOOL(break_pressed);
-
-       DECL_STATE_ENTRY_INT32(event_keyrepeat);
+       state_fio->StateUint32(keycode_7);
+       state_fio->StateInt32(keymode);
+       state_fio->StateBool(ctrl_pressed);
+       state_fio->StateBool(lshift_pressed);
+       state_fio->StateBool(rshift_pressed);
+       state_fio->StateBool(shift_pressed);
+       state_fio->StateBool(graph_pressed);
+       state_fio->StateBool(caps_pressed);
+       state_fio->StateBool(kana_pressed);
+       state_fio->StateBool(break_pressed);
+
+       state_fio->StateInt32(event_keyrepeat);
           
-       DECL_STATE_ENTRY_UINT8(scancode); // After V.4, uint8_t
-       DECL_STATE_ENTRY_UINT8(datareg);
-       DECL_STATE_ENTRY_UINT32(older_vk);
-          
-       DECL_STATE_ENTRY_BOOL(repeat_mode);
-       DECL_STATE_ENTRY_INT32(repeat_time_short);
-       DECL_STATE_ENTRY_INT32(repeat_time_long);
-       DECL_STATE_ENTRY_UINT8(repeat_keycode);
+       state_fio->StateUint8(scancode); // After V.4, uint8_t
+       state_fio->StateUint8(datareg);
+       state_fio->StateUint32(older_vk);
           
+       state_fio->StateBool(repeat_mode);
+       state_fio->StateInt32(repeat_time_short);
+       state_fio->StateInt32(repeat_time_long);
+       state_fio->StateUint8(repeat_keycode);
+          
 #if defined(_FM77AV_VARIANTS)
-       DECL_STATE_ENTRY_INT32(event_key_rtc);
-  
-       DECL_STATE_ENTRY_UINT8(rtc_yy);
-       DECL_STATE_ENTRY_UINT8(rtc_mm);
-       DECL_STATE_ENTRY_UINT8(rtc_dd);
-       DECL_STATE_ENTRY_UINT8(rtc_dayofweek);
-       DECL_STATE_ENTRY_UINT8(rtc_hour);
-       DECL_STATE_ENTRY_UINT8(rtc_minute);
-       DECL_STATE_ENTRY_UINT8(rtc_sec);
-
-       DECL_STATE_ENTRY_BOOL(rtc_count24h);
-       DECL_STATE_ENTRY_BOOL(rtc_ispm);
-
-       DECL_STATE_ENTRY_BOOL(rtc_set);
-       DECL_STATE_ENTRY_BOOL(rtc_set_flag);
-       DECL_STATE_ENTRY_BOOL(rxrdy_status);
-       DECL_STATE_ENTRY_BOOL(key_ack_status);
+       state_fio->StateInt32(event_key_rtc);
+       state_fio->StateUint8(rtc_yy);
+       state_fio->StateUint8(rtc_mm);
+       state_fio->StateUint8(rtc_dd);
+       state_fio->StateUint8(rtc_dayofweek);
+       state_fio->StateUint8(rtc_hour);
+       state_fio->StateUint8(rtc_minute);
+       state_fio->StateUint8(rtc_sec);
+
+       state_fio->StateBool(rtc_count24h);
+       state_fio->StateBool(rtc_ispm);
+
+       state_fio->StateBool(rtc_set);
+       state_fio->StateBool(rtc_set_flag);
+       state_fio->StateBool(rxrdy_status);
+       state_fio->StateBool(key_ack_status);
                
-       DECL_STATE_ENTRY_BOOL(did_hidden_message_av_1);         
-       DECL_STATE_ENTRY_INT32(event_hidden1_av);
-
-       DECL_STATE_ENTRY_INT32(cmd_phase);
-       DECL_STATE_ENTRY_UINT16(hidden1_ptr);
-       DECL_STATE_ENTRY_INT32(beep_phase);
-       //cmd_fifo->save_state((void *)state_fio);
-       //data_fifo->save_state((void *)state_fio);
-       //cur_time.save_state((void *)state_fio);
-#endif
-#if defined(_FM77AV_VARIANTS)
-       DECL_STATE_ENTRY_FIFO(cmd_fifo);
-       DECL_STATE_ENTRY_FIFO(data_fifo);
-       DECL_STATE_ENTRY_CUR_TIME_T(cur_time);
+       state_fio->StateBool(did_hidden_message_av_1);
+       state_fio->StateInt32(event_hidden1_av);
+
+       state_fio->StateInt32(cmd_phase);
+       state_fio->StateUint16(hidden1_ptr);
+       state_fio->StateInt32(beep_phase);
+       
+       if(!cmd_fifo->process_state(state_fio, loading)) {
+               return false;
+       }
+       if(!data_fifo->process_state(state_fio, loading)) {
+               return false;
+       }
+       if(!cur_time.process_state(state_fio, loading)) {
+               return false;
+       }
 #endif
-       DECL_STATE_ENTRY_FIFO(key_fifo);
-       DECL_STATE_ENTRY_INT32(event_int);
-       //key_fifo->save_state((void *)state_fio);
-       DECL_STATE_ENTRY_UINT8(autokey_backup);
-       // Version 5
-       DECL_STATE_ENTRY_BOOL(ins_led_status);
-       DECL_STATE_ENTRY_BOOL(kana_led_status);
-       DECL_STATE_ENTRY_BOOL(caps_led_status);
-       // Version 6
-       DECL_STATE_ENTRY_BOOL(override_break_key);
-
-       leave_decl_state();
+       if(!key_fifo->process_state(state_fio, loading)) {
+               return false;
+       }
+       state_fio->StateInt32(event_int);
+       state_fio->StateUint8(autokey_backup);
+       // Version 5
+       state_fio->StateBool(ins_led_status);
+       state_fio->StateBool(kana_led_status);
+       state_fio->StateBool(caps_led_status);
+       // Version 6
+       state_fio->StateBool(override_break_key);
+
+       return true;
 }
 
 void KEYBOARD::save_state(FILEIO *state_fio)
 {
-       if(state_entry != NULL) {
-               state_entry->save_state(state_fio);
-       }
+       decl_state(state_fio, false);
        //state_fio->FputUint32_BE(STATE_VERSION);
        //state_fio->FputInt32_BE(this_device_id);
        this->out_debug_log(_T("Save State: KEYBOARD: id=%d ver=%d\n"), this_device_id, STATE_VERSION);
 }
-
+ 
 bool KEYBOARD::load_state(FILEIO *state_fio)
 {
-       uint32_t version;
-       
+       uint32_t version;
+       
        //version = state_fio->FgetUint32_BE();
        //if(this_device_id != state_fio->FgetInt32_BE()) return false;
        //this->out_debug_log(_T("Load State: KEYBOARD: id=%d ver=%d\n"), this_device_id, version);
-       bool mb = false;
-       if(state_entry != NULL) {
-               mb = state_entry->load_state(state_fio);
-       }
+       bool mb = decl_state(state_fio, true);
        if(!mb) return false;
        return true;
 }

diff --git a/source/src/vm/fm7/mb61vh010.cpp b/source/src/vm/fm7/mb61vh010.cpp
index 641ad1f..0744672 100644 (file)
--- a/source/src/vm/fm7/mb61vh010.cpp
+++ b/source/src/vm/fm7/mb61vh010.cpp
@@ -925,63 +925,60 @@ void MB61VH010::reset(void)
 }
 
 #define STATE_VERSION 2
-#include "../../statesub.h"
 
-void MB61VH010::decl_state(void)
+bool MB61VH010::decl_state(FILEIO *state_fio, bool loading)
 {
-       enter_decl_state(STATE_VERSION);
-       
-       DECL_STATE_ENTRY_INT(this_device_id);
+       if(!state_fio->StateCheckUint32(STATE_VERSION)) {
+               return false;
+       }
+       if(!state_fio->StateCheckInt32(this_device_id)) {
+               return false;
+       }
        
-       DECL_STATE_ENTRY_UINT8(command_reg);
-       DECL_STATE_ENTRY_UINT8(color_reg);
-       DECL_STATE_ENTRY_UINT8(mask_reg);
-       DECL_STATE_ENTRY_UINT8(cmp_status_reg);
-       DECL_STATE_ENTRY_UINT8(bank_disable_reg);
-       DECL_STATE_ENTRY_UINT8(multi_page);
-       DECL_STATE_ENTRY_UINT32(direct_access_offset);
+       state_fio->StateUint8(command_reg);
+       state_fio->StateUint8(color_reg);
+       state_fio->StateUint8(mask_reg);
+       state_fio->StateUint8(cmp_status_reg);
+       state_fio->StateUint8(bank_disable_reg);
+       state_fio->StateUint8(multi_page);
+       state_fio->StateUint32(direct_access_offset);
        
-       DECL_STATE_ENTRY_UINT8_ARRAY(cmp_color_data, 8);
-       DECL_STATE_ENTRY_UINT8_ARRAY(tile_reg, 4);
-               
-
-       DECL_STATE_ENTRY_PAIR(line_addr_offset);
-       DECL_STATE_ENTRY_PAIR(line_pattern);
-       DECL_STATE_ENTRY_PAIR(line_xbegin);
-       DECL_STATE_ENTRY_PAIR(line_ybegin);
-       DECL_STATE_ENTRY_PAIR(line_xend);
-       DECL_STATE_ENTRY_PAIR(line_yend);
-               
-       DECL_STATE_ENTRY_BOOL(busy_flag);
-       DECL_STATE_ENTRY_PAIR(line_style);
-
-       DECL_STATE_ENTRY_UINT32(total_bytes);
-       DECL_STATE_ENTRY_UINT32(oldaddr);
-       DECL_STATE_ENTRY_UINT32(alu_addr);
-
-       DECL_STATE_ENTRY_UINT32(planes);
-       DECL_STATE_ENTRY_BOOL(is_400line);
-       DECL_STATE_ENTRY_UINT32(screen_width);
-       DECL_STATE_ENTRY_UINT32(screen_height);
+       state_fio->StateBuffer(cmp_color_data, sizeof(cmp_color_data), 1);
+       state_fio->StateBuffer(tile_reg, sizeof(tile_reg), 1);
+
+       state_fio->StateUint32(line_addr_offset.d);
+       state_fio->StateUint32(line_pattern.d);
+       state_fio->StateUint32(line_xbegin.d);
+       state_fio->StateUint32(line_ybegin.d);
+       state_fio->StateUint32(line_xend.d);
+       state_fio->StateUint32(line_yend.d);
+               
+       state_fio->StateBool(busy_flag);
+       state_fio->StateUint32(line_style.d);
+ 
+       state_fio->StateUint32(total_bytes);
+       state_fio->StateUint32(oldaddr);
+       state_fio->StateUint32(alu_addr);
+
+       state_fio->StateUint32(planes);
+       state_fio->StateBool(is_400line);
+       state_fio->StateUint32(screen_width);
+       state_fio->StateUint32(screen_height);
+ 
+       state_fio->StateInt32(eventid_busy);
 
-       DECL_STATE_ENTRY_INT(eventid_busy);
-
-       leave_decl_state();
+       return true;
 }
+
 void MB61VH010::save_state(FILEIO *state_fio)
 {
-       if(state_entry != NULL) {
-               state_entry->save_state(state_fio);
-               out_debug_log(_T("Save State: MB61VH010 : id=%d ver=%d\n"), this_device_id, STATE_VERSION);
-       }
+       decl_state(state_fio, false);
+       out_debug_log(_T("Save State: MB61VH010 : id=%d ver=%d\n"), this_device_id, STATE_VERSION);
 }
 
 bool MB61VH010::load_state(FILEIO *state_fio)
 {
-       bool mb = false;
-       if(state_entry != NULL) {
-               mb = state_entry->load_state(state_fio);
-       }
+       bool mb = decl_state(state_fio, true);
        out_debug_log(_T("Load State: MB61VH010 : id=%d stat=%s"), this_device_id, (mb) ? _T("OK") : _T("NG"));
        if(!mb) return false;
        
@@ -992,6 +989,7 @@ bool MB61VH010::load_state(FILEIO *state_fio)
        }
        for(int i = 0; i < 4; i++) {
                multi_flags[i] = (((1 << i) & multi_page) != 0) ? true : false;
-       }
-       return true;
+       }
+
+       return true;
 }

diff --git a/source/src/vm/fm7/mb61vh010.h b/source/src/vm/fm7/mb61vh010.h
index 86789ab..b4417f3 100644 (file)
--- a/source/src/vm/fm7/mb61vh010.h
+++ b/source/src/vm/fm7/mb61vh010.h
@@ -121,7 +121,7 @@ class MB61VH010: public DEVICE {
 
        void save_state(FILEIO *state_fio);
        bool load_state(FILEIO *state_fio);
-       void decl_state(void);
+       bool decl_state(FILEIO *state_fio, bool loading);
        
        void event_callback(int event_id, int err);
        void write_data8(uint32_t id, uint32_t data);

diff --git a/source/src/vm/fm7/sound.cpp b/source/src/vm/fm7/sound.cpp
index f20f2d8..a4bdb7f 100644 (file)
--- a/source/src/vm/fm7/sound.cpp
+++ b/source/src/vm/fm7/sound.cpp
@@ -423,20 +423,19 @@ void FM7_MAINIO::event_beep_cycle(void)
        }
 }
 
-#include "../../statesub.h"
-
-void FM7_MAINIO::decl_state_opn(void)
+bool FM7_MAINIO::decl_state_opn(FILEIO *state_fio, bool loading)
 {
+       state_fio->StateBool(connect_opn);
+       state_fio->StateBool(connect_whg);
+       state_fio->StateBool(connect_thg);
 
-       DECL_STATE_ENTRY_BOOL(connect_opn);
-       DECL_STATE_ENTRY_BOOL(connect_whg);
-       DECL_STATE_ENTRY_BOOL(connect_thg);
+       state_fio->StateBool(opn_psg_77av);
+       state_fio->StateBuffer(opn_address, sizeof(opn_address), 1);
+       state_fio->StateBuffer(opn_data, sizeof(opn_data), 1);
+       state_fio->StateBuffer(opn_stat, sizeof(opn_stat), 1);
+       state_fio->StateBuffer(opn_cmdreg, sizeof(opn_cmdreg), 1);
+       state_fio->StateBuffer(opn_prescaler_type, sizeof(opn_prescaler_type), 1);
+       state_fio->StateBuffer(opn_regs, sizeof(opn_regs), 1);
 
-       DECL_STATE_ENTRY_BOOL(opn_psg_77av);
-       DECL_STATE_ENTRY_UINT8_ARRAY(opn_address, 4);
-       DECL_STATE_ENTRY_UINT8_ARRAY(opn_data, 4);
-       DECL_STATE_ENTRY_UINT8_ARRAY(opn_stat, 4);
-       DECL_STATE_ENTRY_UINT8_ARRAY(opn_cmdreg, 4);
-       DECL_STATE_ENTRY_UINT8_ARRAY(opn_prescaler_type, 4);
-       DECL_STATE_ENTRY_2D_ARRAY(opn_regs, 4, 0x100);
+       return true;
 }