[VM][BUBCOM80] Apply new VM APIs.

diff --git a/source/src/vm/bubcom80/bubcom80.cpp b/source/src/vm/bubcom80/bubcom80.cpp
index 2cc94fa..63665bf 100644 (file)
--- a/source/src/vm/bubcom80/bubcom80.cpp
+++ b/source/src/vm/bubcom80/bubcom80.cpp
@@ -50,7 +50,7 @@ using BUBCOM80::RTC;
 VM::VM(EMU_TEMPLATE* parent_emu) : VM_TEMPLATE(parent_emu)
 {
        // create devices
-       first_device = last_device = NULL;
+       //first_device = last_device = NULL;
        dummy = new DEVICE(this, emu);  // must be 1st device
        event = new EVENT(this, emu);   // must be 2nd device
        
@@ -148,11 +148,9 @@ VM::VM(EMU_TEMPLATE* parent_emu) : VM_TEMPLATE(parent_emu)
        
        // initialize all devices
 #if defined(__GIT_REPO_VERSION)
-       strncpy(_git_revision, __GIT_REPO_VERSION, sizeof(_git_revision) - 1);
+       set_git_repo_version(__GIT_REPO_VERSION);
 #endif
-       for(DEVICE* device = first_device; device; device = device->next_device) {
-               device->initialize();
-       }
+       initialize_devices();
        
        for(int i = 0; i < MAX_DRIVE; i++) {
                fdc->set_drive_type(i, DRIVE_TYPE_2HD); // 8inch 2D
@@ -163,23 +161,9 @@ VM::VM(EMU_TEMPLATE* parent_emu) : VM_TEMPLATE(parent_emu)
 VM::~VM()
 {
        // delete all devices
-       for(DEVICE* device = first_device; device;) {
-               DEVICE *next_device = device->next_device;
-               device->release();
-               delete device;
-               device = next_device;
-       }
+       release_devices();
 }
 
-DEVICE* VM::get_device(int id)
-{
-       for(DEVICE* device = first_device; device; device = device->next_device) {
-               if(device->this_device_id == id) {
-                       return device;
-               }
-       }
-       return NULL;
-}
 
 // ----------------------------------------------------------------------------
 // drive virtual machine
@@ -188,9 +172,8 @@ DEVICE* VM::get_device(int id)
 void VM::reset()
 {
        // reset all devices
-       for(DEVICE* device = first_device; device; device = device->next_device) {
-               device->reset();
-       }
+       VM_TEMPLATE::reset();
+       
        ctc->write_io8(0, 0x07); // default frequency for beep
        ctc->write_io8(0, 0xef);
        pcm->write_signal(SIG_PCM1BIT_ON, 0, 0); // beep off
@@ -198,12 +181,17 @@ void VM::reset()
 
 void VM::run()
 {
-       event->drive();
+       if(event != nullptr) {
+               event->drive();
+       }
 }
 
 double VM::get_frame_rate()
 {
-       return event->get_frame_rate();
+       if(event != nullptr) {
+               return event->get_frame_rate();
+       }
+       return VM_TEMPLATE::get_frame_rate();
 }
 
 // ----------------------------------------------------------------------------
@@ -226,7 +214,9 @@ DEVICE *VM::get_cpu(int index)
 
 void VM::draw_screen()
 {
-       display->draw_screen();
+       if(display != nullptr) {
+               display->draw_screen();
+       }
 }
 
 // ----------------------------------------------------------------------------
@@ -236,31 +226,45 @@ void VM::draw_screen()
 void VM::initialize_sound(int rate, int samples)
 {
        // init sound manager
-       event->initialize_sound(rate, samples);
+       if(event != nullptr) {
+               event->initialize_sound(rate, samples);
+       }
        
        // init sound gen
-       pcm->initialize_sound(rate, 8000);
+       if(pcm != nullptr) {
+               pcm->initialize_sound(rate, 8000);
+       }
 }
 
 uint16_t* VM::create_sound(int* extra_frames)
 {
-       return event->create_sound(extra_frames);
+       if(event != nullptr) {
+               return event->create_sound(extra_frames);
+       }
+       return VM_TEMPLATE::create_sound(extra_frames);
 }
 
 int VM::get_sound_buffer_ptr()
 {
-       return event->get_sound_buffer_ptr();
+       if(event != nullptr) {
+               return event->get_sound_buffer_ptr();
+       }
+       return VM_TEMPLATE::get_sound_buffer_ptr();
 }
 
 #ifdef USE_SOUND_VOLUME
 void VM::set_sound_device_volume(int ch, int decibel_l, int decibel_r)
 {
        if(ch == 0) {
-               pcm->set_volume(0, decibel_l, decibel_r);
+               if(pcm != nullptr) {
+                       pcm->set_volume(0, decibel_l, decibel_r);
+               }
        } else if(ch == 1) {
-               fdc->get_context_noise_seek()->set_volume(0, decibel_l, decibel_r);
-               fdc->get_context_noise_head_down()->set_volume(0, decibel_l, decibel_r);
-               fdc->get_context_noise_head_up()->set_volume(0, decibel_l, decibel_r);
+               if(fdc != nullptr) {
+                       fdc->get_context_noise_seek()->set_volume(0, decibel_l, decibel_r);
+                       fdc->get_context_noise_head_down()->set_volume(0, decibel_l, decibel_r);
+                       fdc->get_context_noise_head_up()->set_volume(0, decibel_l, decibel_r);
+               }
        }
 }
 #endif
@@ -271,52 +275,73 @@ void VM::set_sound_device_volume(int ch, int decibel_l, int decibel_r)
 
 void VM::open_floppy_disk(int drv, const _TCHAR* file_path, int bank)
 {
-       fdc->open_disk(drv, file_path, bank);
+       if(fdc != nullptr) {
+               fdc->open_disk(drv, file_path, bank);
+       }
 }
 
 void VM::close_floppy_disk(int drv)
 {
-       fdc->close_disk(drv);
+       if(fdc != nullptr) {
+               fdc->close_disk(drv);
+       }
 }
 
 bool VM::is_floppy_disk_inserted(int drv)
 {
-       return fdc->is_disk_inserted(drv);
+       if(fdc != nullptr) {
+               return fdc->is_disk_inserted(drv);
+       }
+       return false;
 }
 
 void VM::is_floppy_disk_protected(int drv, bool value)
 {
-       fdc->is_disk_protected(drv, value);
+       if(fdc != nullptr) {
+               fdc->is_disk_protected(drv, value);
+       }
 }
 
 bool VM::is_floppy_disk_protected(int drv)
 {
-       return fdc->is_disk_protected(drv);
+       if(fdc != nullptr) {
+               return fdc->is_disk_protected(drv);
+       }
+       return false;
 }
 
 uint32_t VM::is_floppy_disk_accessed()
 {
-       return fdc->read_signal(0);
+       if(fdc != nullptr) {
+               return fdc->read_signal(0);
+       }
+       return 0;
 }
 
 void VM::play_tape(int drv, const _TCHAR* file_path)
 {
+       if(cmt == nullptr) return;
        cmt->play_tape(file_path);
 }
 
 void VM::rec_tape(int drv, const _TCHAR* file_path)
 {
+       if(cmt == nullptr) return;
        cmt->rec_tape(file_path);
 }
 
 void VM::close_tape(int drv)
 {
+       if(cmt == nullptr) return;
        cmt->close_tape();
 }
 
 bool VM::is_tape_inserted(int drv)
 {
-       return cmt->is_tape_inserted();
+       if(cmt != nullptr) {
+               return cmt->is_tape_inserted();
+       }
+       return false;
 }
 
 void VM::open_bubble_casette(int drv, const _TCHAR *path, int bank)
@@ -358,58 +383,36 @@ void VM::is_bubble_casette_protected(int drv, bool flag)
 
 bool VM::is_frame_skippable()
 {
-       return event->is_frame_skippable();
-}
-
-void VM::update_config()
-{
-       for(DEVICE* device = first_device; device; device = device->next_device) {
-               device->update_config();
+       if(event != nullptr) {
+               return event->is_frame_skippable();
        }
+       return false;
 }
 
+
 double VM::get_current_usec()
 {
-       if(event == NULL) return 0.0;
-       return event->get_current_usec();
+       if(event != nullptr) {
+               return event->get_current_usec();
+       }
+       return VM_TEMPLATE::get_current_usec();
 }
 
 uint64_t VM::get_current_clock_uint64()
 {
-               if(event == NULL) return (uint64_t)0;
+       if(event != nullptr) {
                return event->get_current_clock_uint64();
+       }
+       return VM_TEMPLATE::get_current_clock_uint64();
 }
 
 #define STATE_VERSION  1
 
 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 _TCHAR *name = char_to_tchar(typeid(*device).name() + 6); // skip "class "
-               int len = (int)_tcslen(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)) {
-                       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)) {
-                       if(loading) {
-                               printf("Data loading Error: DEVID=%d\n", device->this_device_id);
-                       }
-                       return false;
-               }
-       }
+       if(!(VM_TEMPLATE::process_state_core(state_fio, loading, STATE_VERSION))) {
+               return false;
+       }
        // Machine specified.
        if(loading) {
                update_config();

diff --git a/source/src/vm/bubcom80/bubcom80.h b/source/src/vm/bubcom80/bubcom80.h
index cf691ab..f01752e 100644 (file)
--- a/source/src/vm/bubcom80/bubcom80.h
+++ b/source/src/vm/bubcom80/bubcom80.h
@@ -116,48 +116,47 @@ public:
        // ----------------------------------------
        
        // drive virtual machine
-       void reset();
-       void run();
-       double get_frame_rate();
+       void reset() override;
+       void run() override;
+       double get_frame_rate() override;
        
 #ifdef USE_DEBUGGER
        // debugger
-       DEVICE *get_cpu(int index);
+       DEVICE *get_cpu(int index) override;
 #endif
        
        // draw screen
-       void draw_screen();
+       void draw_screen() override;
        
        // sound generation
-       void initialize_sound(int rate, int samples);
-       uint16_t* create_sound(int* extra_frames);
-       int get_sound_buffer_ptr();
+       void initialize_sound(int rate, int samples) override;
+       uint16_t* create_sound(int* extra_frames) override;
+       int get_sound_buffer_ptr() override;
 #ifdef USE_SOUND_VOLUME
-       void set_sound_device_volume(int ch, int decibel_l, int decibel_r);
+       void set_sound_device_volume(int ch, int decibel_l, int decibel_r) override;
 #endif
        
        // user interface
-       void open_floppy_disk(int drv, const _TCHAR* file_path, int bank);
-       void close_floppy_disk(int drv);
-       bool is_floppy_disk_inserted(int drv);
-       void is_floppy_disk_protected(int drv, bool value);
-       bool is_floppy_disk_protected(int drv);
-       uint32_t is_floppy_disk_accessed();
-       void play_tape(int drv, const _TCHAR* file_path);
-       void rec_tape(int drv, const _TCHAR* file_path);
-       void close_tape(int drv);
-       bool is_tape_inserted(int drv);
-       void open_bubble_casette(int drv, const _TCHAR *path, int bank);
-       void close_bubble_casette(int drv);
-       bool is_bubble_casette_inserted(int drv);
-       bool is_bubble_casette_protected(int drv);
-       void is_bubble_casette_protected(int drv, bool flag);
-       bool is_frame_skippable();
+       void open_floppy_disk(int drv, const _TCHAR* file_path, int bank) override;
+       void close_floppy_disk(int drv) override;
+       bool is_floppy_disk_inserted(int drv) override;
+       void is_floppy_disk_protected(int drv, bool value) override;
+       bool is_floppy_disk_protected(int drv) override;
+       uint32_t is_floppy_disk_accessed() override;
+       void play_tape(int drv, const _TCHAR* file_path) override;
+       void rec_tape(int drv, const _TCHAR* file_path) override;
+       void close_tape(int drv) override;
+       bool is_tape_inserted(int drv) override;
+       void open_bubble_casette(int drv, const _TCHAR *path, int bank) override;
+       void close_bubble_casette(int drv) override;
+       bool is_bubble_casette_inserted(int drv) override;
+       bool is_bubble_casette_protected(int drv) override;
+       void is_bubble_casette_protected(int drv, bool flag) override;
+       bool is_frame_skippable() override;
        
-       double get_current_usec();
-       uint64_t get_current_clock_uint64();
+       double get_current_usec() override;
+       uint64_t get_current_clock_uint64() override;
        
-       void update_config();
        bool process_state(FILEIO* state_fio, bool loading);
        
        // ----------------------------------------
@@ -165,7 +164,7 @@ public:
        // ----------------------------------------
        
        // devices
-       DEVICE* get_device(int id);
+       //DEVICE* get_device(int id) override;
        //DEVICE* dummy;
        //DEVICE* first_device;
        //DEVICE* last_device;