MSXCPU.hh

Go to the documentation of this file.

#ifndef MSXCPU_HH
#define MSXCPU_HH

#include "CPU.hh"
#include "Observer.hh"
#include "EmuTime.hh"
#include "noncopyable.hh"
#include <memory>

namespace openmsx {

class MSXMotherBoard;
class MSXCPUInterface;
class BooleanSetting;
class Z80TYPE;
class R800TYPE;
template <typename T> class CPUCore;
class Setting;
class TimeInfoTopic;
class CPUFreqInfoTopic;
class MSXCPUDebuggable;
class TclCallback;

class MSXCPU : private Observer<Setting>, private noncopyable
{
public:
        enum CPUType { CPU_Z80, CPU_R800 };

        explicit MSXCPU(MSXMotherBoard& motherboard);
        ~MSXCPU();

        void doReset(EmuTime::param time);

        void setActiveCPU(CPUType cpu);

        void setDRAMmode(bool dram);

        void updateVisiblePage(byte page, byte primarySlot, byte secondarySlot);

        void invalidateMemCache(word start, unsigned size);

        void raiseIRQ();

        void lowerIRQ();

        void raiseNMI();

        void lowerNMI();

        bool isM1Cycle(unsigned address) const;

        void exitCPULoopSync();
        void exitCPULoopAsync();

        bool isR800Active();

        void setZ80Freq(unsigned freq);

        void setInterface(MSXCPUInterface* interf);

        void disasmCommand(const std::vector<TclObject>& tokens,
                           TclObject& result) const;

        // Pause
        void setPaused(bool paused);

        void setNextSyncPoint(EmuTime::param time);

        void wait(EmuTime::param time);
        void waitCycles(unsigned cycles);
        void waitCyclesR800(unsigned cycles);

        template<typename Archive>
        void serialize(Archive& ar, unsigned version);

private:
        // only for MSXMotherBoard
        void execute(bool fastForward);
        friend class MSXMotherBoard;

        EmuTime::param getCurrentTime() const;

        // Observer<Setting>
        void update(const Setting& setting);

        MSXMotherBoard& motherboard;
        const std::unique_ptr<BooleanSetting> traceSetting;
        const std::unique_ptr<TclCallback> diHaltCallback;
        const std::unique_ptr<CPUCore<Z80TYPE>> z80;
        const std::unique_ptr<CPUCore<R800TYPE>> r800;

        CPU* activeCPU;
        CPU* newCPU;
        EmuTime reference;

        friend class TimeInfoTopic;
        friend class MSXCPUDebuggable;
        const std::unique_ptr<TimeInfoTopic>    timeInfo;
        const std::unique_ptr<CPUFreqInfoTopic> z80FreqInfo;
        const std::unique_ptr<CPUFreqInfoTopic> r800FreqInfo;
        const std::unique_ptr<MSXCPUDebuggable> debuggable;
};

} // namespace openmsx

#endif