wrapper.hpp

浏览该文件的文档.

#pragma once
 
#include "sEMU/core.hpp"
#include <cstdint>
#include <string>

class CoreCommitState {
private:
    const Core* core_;
 
public:
    explicit CoreCommitState(const Core* core) noexcept : core_(core) {}
 
    [[nodiscard]] inline bool is_commit_valid() const noexcept { 
        return core_->is_commit_valid(); 
    }
    
    [[nodiscard]] inline uint32_t get_commit_pc() const noexcept { 
        return core_->get_commit_pc(); 
    }
    
    [[nodiscard]] inline uint32_t get_commit_wdata() const noexcept { 
        return core_->get_commit_wdata(); 
    }
    
    [[nodiscard]] inline uint8_t get_commit_rd() const noexcept { 
        return core_->get_commit_rd(); 
    }
    
    [[nodiscard]] inline bool is_commit_wen() const noexcept { 
        return core_->is_commit_wen(); 
    }
 
    [[nodiscard]] inline uint32_t get_reg_by_name(const std::string& name) const noexcept {
        return core_->get_reg_by_name(name);
    }
    
    [[nodiscard]] inline const Core* get_core() const noexcept { 
        return core_; 
    }
};

class CoreIterator {
private:
    Core* core_;
    bool is_end_;
 
    inline void advance() noexcept {
        if (core_ && core_->state == CoreState::RUNNING) {
            core_->step();
            if (core_->state != CoreState::RUNNING) {
                is_end_ = true;
            }
        } else {
            is_end_ = true;
        }
    }
 
public:
    explicit CoreIterator(Core* core, bool is_end = false) noexcept 
        : core_(core), is_end_(is_end || (core && core_->state != CoreState::RUNNING)) {}
 
    inline CoreIterator& operator++() noexcept {
        advance();
        return *this;
    }
 
    [[nodiscard]] inline CoreCommitState operator*() const noexcept {
        return CoreCommitState{core_};
    }
 
    [[nodiscard]] inline bool operator!=(const CoreIterator& other) const noexcept {
        return this->is_end_ != other.is_end_;
    }
 
    [[nodiscard]] inline bool operator==(const CoreIterator& other) const noexcept {
        return this->is_end_ == other.is_end_;
    }
};

class CoreSimRange {
private:
    Core* core_;
 
public:
    explicit CoreSimRange(Core* core) noexcept : core_(core) {}
 
    [[nodiscard]] inline CoreIterator begin() noexcept {
        return CoreIterator{core_, false};
    }
 
    [[nodiscard]] inline CoreIterator end() const noexcept {
        return CoreIterator{core_, true};
    }
};

template <typename Range, typename Action>
inline void run_simulation(Range&& range, Action&& action) noexcept {
    for (auto state : range) {
        action(state);
    }
}