Sprinter/mame
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

override part 2 (nw)

Browse Source
This commit is contained in:
Miodrag Milanovic 2015-12-05 20:56:56 +01:00
parent 1c4865d66f
commit 1db2b0d6b4
149 changed files with 2521 additions and 2521 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
src/devices/cpu/8x300/8x300.h
View File

@ -45,17 +45,17 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const { return 1; }
virtual UINT32 execute_max_cycles() const { return 1; }
virtual UINT32 execute_input_lines() const { return 0; }
virtual void execute_run();
virtual UINT32 execute_min_cycles() const override { return 1; }
virtual UINT32 execute_max_cycles() const override { return 1; }
virtual UINT32 execute_input_lines() const override { return 0; }
virtual void execute_run() override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override
{
switch (spacenum)
{
@ -66,12 +66,12 @@ protected:
}
// device_state_interface overrides
void state_string_export(const device_state_entry &entry, std::string &str);
void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 2; }
virtual UINT32 disasm_max_opcode_bytes() const { return 2; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 2; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 2; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
address_space_config m_program_config;
address_space_config m_io_config;

46
src/devices/cpu/adsp2100/adsp2100.h
View File

@ -226,23 +226,23 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const;
virtual UINT32 execute_max_cycles() const;
virtual void execute_run();
virtual void execute_set_input(int inputnum, int state);
virtual UINT32 execute_min_cycles() const override;
virtual UINT32 execute_max_cycles() const override;
virtual void execute_run() override;
virtual void execute_set_input(int inputnum, int state) override;
// device_state_interface overrides
virtual void state_import(const device_state_entry &entry);
virtual void state_string_export(const device_state_entry &entry, std::string &str);
virtual void state_import(const device_state_entry &entry) override;
virtual void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const;
virtual UINT32 disasm_max_opcode_bytes() const;
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override;
virtual UINT32 disasm_max_opcode_bytes() const override;
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
// helpers
void create_tables();
@ -487,14 +487,14 @@ public:
protected:
// device_execute_interface overrides
virtual UINT32 execute_input_lines() const;
virtual UINT32 execute_input_lines() const override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const;
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override;
// interrupts
virtual bool generate_irq(int which, int indx);
virtual void check_irqs();
virtual bool generate_irq(int which, int indx) override;
virtual void check_irqs() override;
};
@ -510,14 +510,14 @@ protected:
adsp2101_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, UINT32 chiptype, const char *shortname, const char *source);
// device_execute_interface overrides
virtual UINT32 execute_input_lines() const;
virtual UINT32 execute_input_lines() const override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const;
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override;
// interrupts
virtual bool generate_irq(int which, int indx);
virtual void check_irqs();
virtual bool generate_irq(int which, int indx) override;
virtual void check_irqs() override;
};
@ -531,14 +531,14 @@ public:
protected:
// device_execute_interface overrides
virtual UINT32 execute_input_lines() const;
virtual UINT32 execute_input_lines() const override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const;
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override;
// interrupts
virtual bool generate_irq(int which, int indx);
virtual void check_irqs();
virtual bool generate_irq(int which, int indx) override;
virtual void check_irqs() override;
// address spaces
const address_space_config m_io_config;

28
src/devices/cpu/alph8201/alph8201.h
View File

@ -59,28 +59,28 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const { return 1; }
virtual UINT32 execute_max_cycles() const { return 16; }
virtual UINT32 execute_input_lines() const { return 1; }
virtual void execute_run();
virtual void execute_set_input(int inputnum, int state);
virtual UINT32 execute_min_cycles() const override { return 1; }
virtual UINT32 execute_max_cycles() const override { return 16; }
virtual UINT32 execute_input_lines() const override { return 1; }
virtual void execute_run() override;
virtual void execute_set_input(int inputnum, int state) override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == AS_PROGRAM) ? &m_program_config : ( (spacenum == AS_IO) ? &m_io_config : nullptr ); }
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override { return (spacenum == AS_PROGRAM) ? &m_program_config : ( (spacenum == AS_IO) ? &m_io_config : nullptr ); }
// device_state_interface overrides
virtual void state_import(const device_state_entry &entry);
virtual void state_export(const device_state_entry &entry);
void state_string_export(const device_state_entry &entry, std::string &str);
virtual void state_import(const device_state_entry &entry) override;
virtual void state_export(const device_state_entry &entry) override;
void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const { return 4; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 4; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
UINT8 M_RDMEM(UINT16 A) { return m_program->read_byte(A); }
void M_WRMEM(UINT16 A,UINT8 V) { m_program->write_byte(A, V); }

28
src/devices/cpu/alto2/alto2cpu.h
View File

@ -193,32 +193,32 @@ public:
protected:
//! device-level override for start
virtual void device_start();
virtual void device_start() override;
//! device-level override for reset
virtual void device_reset();
virtual void device_reset() override;
//! device-level override for post reset
void interface_post_reset();
void interface_post_reset() override;
//! device_execute_interface overrides
virtual UINT32 execute_min_cycles() const { return 1; }
virtual UINT32 execute_max_cycles() const { return 1; }
virtual UINT32 execute_input_lines() const { return 1; }
virtual void execute_run();
virtual void execute_set_input(int inputnum, int state);
virtual UINT32 execute_min_cycles() const override { return 1; }
virtual UINT32 execute_max_cycles() const override { return 1; }
virtual UINT32 execute_input_lines() const override { return 1; }
virtual void execute_run() override;
virtual void execute_set_input(int inputnum, int state) override;
//! device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const;
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override;
//! device (P)ROMs
virtual const rom_entry *device_rom_region() const;
virtual const rom_entry *device_rom_region() const override;
//! device_state_interface overrides
void state_string_export(const device_state_entry &entry, std::string &str);
void state_string_export(const device_state_entry &entry, std::string &str) override;
//! device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 4; }
virtual UINT32 disasm_max_opcode_bytes() const { return 4; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 4; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 4; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
private:

24
src/devices/cpu/am29000/am29000.h
View File

@ -439,18 +439,18 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const { return 1; }
virtual UINT32 execute_max_cycles() const { return 2; }
virtual UINT32 execute_input_lines() const { return 1; }
virtual void execute_run();
virtual void execute_set_input(int inputnum, int state);
virtual UINT32 execute_min_cycles() const override { return 1; }
virtual UINT32 execute_max_cycles() const override { return 2; }
virtual UINT32 execute_input_lines() const override { return 1; }
virtual void execute_run() override;
virtual void execute_set_input(int inputnum, int state) override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override
{
switch (spacenum)
{
@ -462,12 +462,12 @@ protected:
}
// device_state_interface overrides
void state_string_export(const device_state_entry &entry, std::string &str);
void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 4; }
virtual UINT32 disasm_max_opcode_bytes() const { return 4; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 4; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 4; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
void signal_exception(UINT32 type);
void external_irq_check();

32
src/devices/cpu/amis2000/amis2000.h
View File

@ -71,25 +71,25 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT64 execute_clocks_to_cycles(UINT64 clocks) const { return (clocks + 4 - 1) / 4; } // 4 cycles per machine cycle
virtual UINT64 execute_cycles_to_clocks(UINT64 cycles) const { return (cycles * 4); } // "
virtual UINT32 execute_min_cycles() const { return 1; }
virtual UINT32 execute_max_cycles() const { return 2; }
virtual UINT32 execute_input_lines() const { return 1; }
virtual void execute_run();
virtual UINT64 execute_clocks_to_cycles(UINT64 clocks) const override { return (clocks + 4 - 1) / 4; } // 4 cycles per machine cycle
virtual UINT64 execute_cycles_to_clocks(UINT64 cycles) const override { return (cycles * 4); } // "
virtual UINT32 execute_min_cycles() const override { return 1; }
virtual UINT32 execute_max_cycles() const override { return 2; }
virtual UINT32 execute_input_lines() const override { return 1; }
virtual void execute_run() override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return(spacenum == AS_PROGRAM) ? &m_program_config : ((spacenum == AS_DATA) ? &m_data_config : nullptr); }
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override { return(spacenum == AS_PROGRAM) ? &m_program_config : ((spacenum == AS_DATA) ? &m_data_config : nullptr); }
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const { return 1; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
void state_string_export(const device_state_entry &entry, std::string &str);
virtual UINT32 disasm_min_opcode_bytes() const override { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 1; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
void state_string_export(const device_state_entry &entry, std::string &str) override;
address_space_config m_program_config;
address_space_config m_data_config;
@ -219,8 +219,8 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// digital-to-frequency converter
UINT8 m_d2f_latch;
@ -231,7 +231,7 @@ protected:
TIMER_CALLBACK_MEMBER(d2f_timer_cb);
// opcode handlers
virtual void op_szk();
virtual void op_szk() override;
};

26
src/devices/cpu/apexc/apexc.h
View File

@ -29,27 +29,27 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const { return 2; }
virtual UINT32 execute_max_cycles() const { return 75; }
virtual UINT32 execute_input_lines() const { return 0; }
virtual void execute_run();
virtual UINT32 execute_min_cycles() const override { return 2; }
virtual UINT32 execute_max_cycles() const override { return 75; }
virtual UINT32 execute_input_lines() const override { return 0; }
virtual void execute_run() override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == AS_PROGRAM) ? &m_program_config : ( (spacenum == AS_IO) ? &m_io_config : nullptr ); }
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override { return (spacenum == AS_PROGRAM) ? &m_program_config : ( (spacenum == AS_IO) ? &m_io_config : nullptr ); }
// device_state_interface overrides
virtual void state_import(const device_state_entry &entry);
virtual void state_export(const device_state_entry &entry);
void state_string_export(const device_state_entry &entry, std::string &str);
virtual void state_import(const device_state_entry &entry) override;
virtual void state_export(const device_state_entry &entry) override;
void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 4; }
virtual UINT32 disasm_max_opcode_bytes() const { return 4; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 4; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 4; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
inline UINT32 apexc_readmem(UINT32 address) { return m_program->read_dword((address)<<2); }
inline void apexc_writemem(UINT32 address, UINT32 data) { m_program->write_dword((address)<<2, (data)); }

26
src/devices/cpu/arc/arc.h
View File

@ -20,27 +20,27 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const { return 5; }
virtual UINT32 execute_max_cycles() const { return 5; }
virtual UINT32 execute_input_lines() const { return 0; }
virtual void execute_run();
virtual void execute_set_input(int inputnum, int state);
virtual UINT32 execute_min_cycles() const override { return 5; }
virtual UINT32 execute_max_cycles() const override { return 5; }
virtual UINT32 execute_input_lines() const override { return 0; }
virtual void execute_run() override;
virtual void execute_set_input(int inputnum, int state) override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
// device_state_interface overrides
virtual void state_import(const device_state_entry &entry);
virtual void state_export(const device_state_entry &entry);
virtual void state_import(const device_state_entry &entry) override;
virtual void state_export(const device_state_entry &entry) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 4; }
virtual UINT32 disasm_max_opcode_bytes() const { return 4; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 4; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 4; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
private:
address_space_config m_program_config;

26
src/devices/cpu/arcompact/arcompact.h
View File

@ -75,27 +75,27 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const { return 5; }
virtual UINT32 execute_max_cycles() const { return 5; }
virtual UINT32 execute_input_lines() const { return 0; }
virtual void execute_run();
virtual void execute_set_input(int inputnum, int state);
virtual UINT32 execute_min_cycles() const override { return 5; }
virtual UINT32 execute_max_cycles() const override { return 5; }
virtual UINT32 execute_input_lines() const override { return 0; }
virtual void execute_run() override;
virtual void execute_set_input(int inputnum, int state) override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == AS_PROGRAM) ? &m_program_config : ( (spacenum == AS_IO) ? &m_io_config : nullptr ); }
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override { return (spacenum == AS_PROGRAM) ? &m_program_config : ( (spacenum == AS_IO) ? &m_io_config : nullptr ); }
// device_state_interface overrides
virtual void state_import(const device_state_entry &entry);
virtual void state_export(const device_state_entry &entry);
virtual void state_import(const device_state_entry &entry) override;
virtual void state_export(const device_state_entry &entry) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 2; }
virtual UINT32 disasm_max_opcode_bytes() const { return 8; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 2; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 8; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;

26
src/devices/cpu/arm/arm.h
View File

@ -47,26 +47,26 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const { return 3; }
virtual UINT32 execute_max_cycles() const { return 4; }
virtual UINT32 execute_input_lines() const { return 2; }
virtual void execute_run();
virtual void execute_set_input(int inputnum, int state);
virtual UINT32 execute_min_cycles() const override { return 3; }
virtual UINT32 execute_max_cycles() const override { return 4; }
virtual UINT32 execute_input_lines() const override { return 2; }
virtual void execute_run() override;
virtual void execute_set_input(int inputnum, int state) override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
// device_state_interface overrides
void state_string_export(const device_state_entry &entry, std::string &str);
void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 4; }
virtual UINT32 disasm_max_opcode_bytes() const { return 4; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 4; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 4; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
address_space_config m_program_config;
@ -113,7 +113,7 @@ public:
arm_be_cpu_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
protected:
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
};

28
src/devices/cpu/asap/asap.h
View File

@ -32,28 +32,28 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const;
virtual UINT32 execute_max_cycles() const;
virtual UINT32 execute_input_lines() const;
virtual void execute_run();
virtual void execute_set_input(int inputnum, int state);
virtual UINT32 execute_min_cycles() const override;
virtual UINT32 execute_max_cycles() const override;
virtual UINT32 execute_input_lines() const override;
virtual void execute_run() override;
virtual void execute_set_input(int inputnum, int state) override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const;
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override;
// device_state_interface overrides
virtual void state_import(const device_state_entry &entry);
virtual void state_export(const device_state_entry &entry);
virtual void state_string_export(const device_state_entry &entry, std::string &str);
virtual void state_import(const device_state_entry &entry) override;
virtual void state_export(const device_state_entry &entry) override;
virtual void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const;
virtual UINT32 disasm_max_opcode_bytes() const;
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override;
virtual UINT32 disasm_max_opcode_bytes() const override;
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
// helpers
inline UINT32 readop(offs_t pc);

30
src/devices/cpu/avr8/avr8.h
View File

@ -115,26 +115,26 @@ protected:
avr8_device(const machine_config &mconfig, const char *name, const char *tag, device_t *owner, UINT32 clock, const device_type type, UINT32 address_mask, address_map_constructor internal_map, UINT8 cpu_type, const char *shortname, const char *source);
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const;
virtual UINT32 execute_max_cycles() const;
virtual UINT32 execute_input_lines() const;
virtual void execute_run();
virtual void execute_set_input(int inputnum, int state);
virtual UINT32 execute_min_cycles() const override;
virtual UINT32 execute_max_cycles() const override;
virtual UINT32 execute_input_lines() const override;
virtual void execute_run() override;
virtual void execute_set_input(int inputnum, int state) override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const;
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const;
virtual UINT32 disasm_max_opcode_bytes() const;
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override;
virtual UINT32 disasm_max_opcode_bytes() const override;
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
// device_state_interface overrides
virtual void state_string_export(const device_state_entry &entry, std::string &str);
virtual void state_string_export(const device_state_entry &entry, std::string &str) override;
// address spaces
const address_space_config m_program_config;
@ -285,7 +285,7 @@ public:
// construction/destruction
atmega644_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
virtual void update_interrupt(int source);
virtual void update_interrupt(int source) override;
};
// ======================> atmega1280_device
@ -296,7 +296,7 @@ public:
// construction/destruction
atmega1280_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
virtual void update_interrupt(int source);
virtual void update_interrupt(int source) override;
};
// ======================> atmega2560_device
@ -307,7 +307,7 @@ public:
// construction/destruction
atmega2560_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
virtual void update_interrupt(int source);
virtual void update_interrupt(int source) override;
};
/***************************************************************************

22
src/devices/cpu/ccpu/ccpu.h
View File

@ -60,17 +60,17 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const { return 1; }
virtual UINT32 execute_max_cycles() const { return 1; }
virtual UINT32 execute_input_lines() const { return 0; }
virtual void execute_run();
virtual UINT32 execute_min_cycles() const override { return 1; }
virtual UINT32 execute_max_cycles() const override { return 1; }
virtual UINT32 execute_input_lines() const override { return 0; }
virtual void execute_run() override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override
{
switch (spacenum)
{
@ -82,12 +82,12 @@ protected:
}
// device_state_interface overrides
void state_string_export(const device_state_entry &entry, std::string &str);
void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const { return 3; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 3; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
address_space_config m_program_config;
address_space_config m_data_config;

32
src/devices/cpu/cop400/cop400.h
View File

@ -130,7 +130,7 @@ public:
// construction/destruction
cop400_cpu_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source, UINT8 program_addr_bits, UINT8 data_addr_bits, UINT8 featuremask, UINT8 g_mask, UINT8 d_mask, UINT8 in_mask, bool has_counter, bool has_inil, address_map_constructor internal_map_program, address_map_constructor internal_map_data);
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr) override;
// static configuration helpers
template<class _Object> static devcb_base &set_read_l_callback(device_t &device, _Object object) { return downcast<cop400_cpu_device &>(device).m_read_l.set_callback(object); }
@ -150,32 +150,32 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT64 execute_clocks_to_cycles(UINT64 clocks) const { return (clocks + m_cki - 1) / m_cki; }
virtual UINT64 execute_cycles_to_clocks(UINT64 cycles) const { return (cycles * m_cki); }
virtual UINT32 execute_min_cycles() const { return 1; }
virtual UINT32 execute_max_cycles() const { return 2; }
virtual UINT32 execute_input_lines() const { return 0; }
virtual void execute_run();
virtual UINT64 execute_clocks_to_cycles(UINT64 clocks) const override { return (clocks + m_cki - 1) / m_cki; }
virtual UINT64 execute_cycles_to_clocks(UINT64 cycles) const override { return (cycles * m_cki); }
virtual UINT32 execute_min_cycles() const override { return 1; }
virtual UINT32 execute_max_cycles() const override { return 2; }
virtual UINT32 execute_input_lines() const override { return 0; }
virtual void execute_run() override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override
{
return (spacenum == AS_PROGRAM) ? &m_program_config : ( (spacenum == AS_DATA) ? &m_data_config : nullptr );
}
// device_state_interface overrides
virtual void state_import(const device_state_entry &entry);
virtual void state_export(const device_state_entry &entry);
void state_string_export(const device_state_entry &entry, std::string &str);
virtual void state_import(const device_state_entry &entry) override;
virtual void state_export(const device_state_entry &entry) override;
void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const { return 2; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 2; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
address_space_config m_program_config;
address_space_config m_data_config;

34
src/devices/cpu/cosmac/cosmac.h
View File

@ -216,27 +216,27 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const;
virtual UINT32 execute_max_cycles() const;
virtual UINT32 execute_input_lines() const;
virtual void execute_run();
virtual void execute_set_input(int inputnum, int state);
virtual UINT32 execute_min_cycles() const override;
virtual UINT32 execute_max_cycles() const override;
virtual UINT32 execute_input_lines() const override;
virtual void execute_run() override;
virtual void execute_set_input(int inputnum, int state) override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const;
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override;
// device_state_interface overrides
virtual void state_import(const device_state_entry &entry);
virtual void state_export(const device_state_entry &entry);
virtual void state_string_export(const device_state_entry &entry, std::string &str);
virtual void state_import(const device_state_entry &entry) override;
virtual void state_export(const device_state_entry &entry) override;
virtual void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const;
virtual UINT32 disasm_max_opcode_bytes() const;
virtual UINT32 disasm_min_opcode_bytes() const override;
virtual UINT32 disasm_max_opcode_bytes() const override;
// helpers
inline UINT8 read_opcode(offs_t pc);
@ -452,9 +452,9 @@ public:
protected:
// device_disasm_interface overrides
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
virtual cosmac_device::ophandler get_ophandler(UINT8 opcode);
virtual cosmac_device::ophandler get_ophandler(UINT8 opcode) override;
static const ophandler s_opcodetable[256];
};
@ -470,9 +470,9 @@ public:
protected:
// device_disasm_interface overrides
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
virtual cosmac_device::ophandler get_ophandler(UINT8 opcode);
virtual cosmac_device::ophandler get_ophandler(UINT8 opcode) override;
static const ophandler s_opcodetable[256];
};

24
src/devices/cpu/cp1610/cp1610.h
View File

@ -42,26 +42,26 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const { return 1; }
virtual UINT32 execute_max_cycles() const { return 7; }
virtual UINT32 execute_input_lines() const { return 2; }
virtual void execute_run();
virtual void execute_set_input(int inputnum, int state);
virtual UINT32 execute_min_cycles() const override { return 1; }
virtual UINT32 execute_max_cycles() const override { return 7; }
virtual UINT32 execute_input_lines() const override { return 2; }
virtual void execute_run() override;
virtual void execute_set_input(int inputnum, int state) override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
// device_state_interface overrides
void state_string_export(const device_state_entry &entry, std::string &str);
void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 2; }
virtual UINT32 disasm_max_opcode_bytes() const { return 8; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 2; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 8; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
private:
address_space_config m_program_config;

64
src/devices/cpu/cubeqcpu/cubeqcpu.h
View File

@ -151,22 +151,22 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const { return 1; }
virtual UINT32 execute_max_cycles() const { return 1; }
virtual UINT32 execute_input_lines() const { return 0; }
virtual void execute_run();
virtual UINT32 execute_min_cycles() const override { return 1; }
virtual UINT32 execute_max_cycles() const override { return 1; }
virtual UINT32 execute_input_lines() const override { return 0; }
virtual void execute_run() override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 8; }
virtual UINT32 disasm_max_opcode_bytes() const { return 8; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 8; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 8; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
private:
address_space_config m_program_config;
@ -219,25 +219,25 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const { return 1; }
virtual UINT32 execute_max_cycles() const { return 1; }
virtual UINT32 execute_input_lines() const { return 0; }
virtual void execute_run();
virtual UINT32 execute_min_cycles() const override { return 1; }
virtual UINT32 execute_max_cycles() const override { return 1; }
virtual UINT32 execute_input_lines() const override { return 0; }
virtual void execute_run() override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
// device_state_interface overrides
void state_string_export(const device_state_entry &entry, std::string &str);
void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 8; }
virtual UINT32 disasm_max_opcode_bytes() const { return 8; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 8; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 8; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
private:
address_space_config m_program_config;
@ -303,25 +303,25 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const { return 1; }
virtual UINT32 execute_max_cycles() const { return 1; }
virtual UINT32 execute_input_lines() const { return 0; }
virtual void execute_run();
virtual UINT32 execute_min_cycles() const override { return 1; }
virtual UINT32 execute_max_cycles() const override { return 1; }
virtual UINT32 execute_input_lines() const override { return 0; }
virtual void execute_run() override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
// device_state_interface overrides
void state_string_export(const device_state_entry &entry, std::string &str);
void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 8; }
virtual UINT32 disasm_max_opcode_bytes() const { return 8; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 8; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 8; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
private:
address_space_config m_program_config;

10
src/devices/cpu/drcbec.h
View File

@ -32,11 +32,11 @@ public:
virtual ~drcbe_c();
// required overrides
virtual void reset();
virtual int execute(uml::code_handle &entry);
virtual void generate(drcuml_block &block, const uml::instruction *instlist, UINT32 numinst);
virtual bool hash_exists(UINT32 mode, UINT32 pc);
virtual void get_info(drcbe_info &info);
virtual void reset() override;
virtual int execute(uml::code_handle &entry) override;
virtual void generate(drcuml_block &block, const uml::instruction *instlist, UINT32 numinst) override;
virtual bool hash_exists(UINT32 mode, UINT32 pc) override;
virtual void get_info(drcbe_info &info) override;
private:
// helpers

12
src/devices/cpu/drcbex64.h
View File

@ -36,12 +36,12 @@ public:
virtual ~drcbe_x64();
// required overrides
virtual void reset();
virtual int execute(uml::code_handle &entry);
virtual void generate(drcuml_block &block, const uml::instruction *instlist, UINT32 numinst);
virtual bool hash_exists(UINT32 mode, UINT32 pc);
virtual void get_info(drcbe_info &info);
virtual bool logging() const { return m_log != nullptr; }
virtual void reset() override;
virtual int execute(uml::code_handle &entry) override;
virtual void generate(drcuml_block &block, const uml::instruction *instlist, UINT32 numinst) override;
virtual bool hash_exists(UINT32 mode, UINT32 pc) override;
virtual void get_info(drcbe_info &info) override;
virtual bool logging() const override { return m_log != nullptr; }
private:
// a be_parameter is similar to a uml::parameter but maps to native registers/memory

12
src/devices/cpu/drcbex86.h
View File

@ -36,12 +36,12 @@ public:
virtual ~drcbe_x86();
// required overrides
virtual void reset();
virtual int execute(uml::code_handle &entry);
virtual void generate(drcuml_block &block, const uml::instruction *instlist, UINT32 numinst);
virtual bool hash_exists(UINT32 mode, UINT32 pc);
virtual void get_info(drcbe_info &info);
virtual bool logging() const { return m_log != nullptr; }
virtual void reset() override;
virtual int execute(uml::code_handle &entry) override;
virtual void generate(drcuml_block &block, const uml::instruction *instlist, UINT32 numinst) override;
virtual bool hash_exists(UINT32 mode, UINT32 pc) override;
virtual void get_info(drcbe_info &info) override;
virtual bool logging() const override { return m_log != nullptr; }
private:
// a be_parameter is similar to a uml::parameter but maps to native registers/memory

28
src/devices/cpu/dsp16/dsp16.h
View File

@ -30,28 +30,28 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT64 execute_clocks_to_cycles(UINT64 clocks) const { return (clocks + 2 - 1) / 2; } // internal /2 divider
virtual UINT64 execute_cycles_to_clocks(UINT64 cycles) const { return (cycles * 2); } // internal /2 divider
virtual UINT32 execute_min_cycles() const;
virtual UINT32 execute_max_cycles() const;
virtual UINT32 execute_input_lines() const;
virtual void execute_run();
virtual void execute_set_input(int inputnum, int state);
virtual UINT64 execute_clocks_to_cycles(UINT64 clocks) const override { return (clocks + 2 - 1) / 2; } // internal /2 divider
virtual UINT64 execute_cycles_to_clocks(UINT64 cycles) const override { return (cycles * 2); } // internal /2 divider
virtual UINT32 execute_min_cycles() const override;
virtual UINT32 execute_max_cycles() const override;
virtual UINT32 execute_input_lines() const override;
virtual void execute_run() override;
virtual void execute_set_input(int inputnum, int state) override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const;
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override;
// device_state_interface overrides
virtual void state_string_export(const device_state_entry &entry, std::string &str);
virtual void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const;
virtual UINT32 disasm_max_opcode_bytes() const;
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override;
virtual UINT32 disasm_max_opcode_bytes() const override;
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
// address spaces
const address_space_config m_program_config;

28
src/devices/cpu/dsp32/dsp32.h
View File

@ -107,28 +107,28 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const;
virtual UINT32 execute_max_cycles() const;
virtual UINT32 execute_input_lines() const;
virtual void execute_run();
virtual void execute_set_input(int inputnum, int state);
virtual UINT32 execute_min_cycles() const override;
virtual UINT32 execute_max_cycles() const override;
virtual UINT32 execute_input_lines() const override;
virtual void execute_run() override;
virtual void execute_set_input(int inputnum, int state) override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const;
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override;
// device_state_interface overrides
virtual void state_import(const device_state_entry &entry);
virtual void state_export(const device_state_entry &entry);
virtual void state_string_export(const device_state_entry &entry, std::string &str);
virtual void state_import(const device_state_entry &entry) override;
virtual void state_export(const device_state_entry &entry) override;
virtual void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const;
virtual UINT32 disasm_max_opcode_bytes() const;
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override;
virtual UINT32 disasm_max_opcode_bytes() const override;
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
// memory accessors
UINT32 ROPCODE(offs_t pc);

30
src/devices/cpu/dsp56k/dsp56k.h
View File

@ -216,29 +216,29 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT64 execute_clocks_to_cycles(UINT64 clocks) const { return (clocks + 2 - 1) / 2; }
virtual UINT64 execute_cycles_to_clocks(UINT64 cycles) const { return (cycles * 2); }
virtual UINT32 execute_min_cycles() const { return 1; }
virtual UINT32 execute_max_cycles() const { return 8; }
virtual UINT32 execute_input_lines() const { return 4; }
virtual UINT32 execute_default_irq_vector() const { return 0; }
virtual void execute_run();
virtual void execute_set_input(int inputnum, int state);
virtual UINT64 execute_clocks_to_cycles(UINT64 clocks) const override { return (clocks + 2 - 1) / 2; }
virtual UINT64 execute_cycles_to_clocks(UINT64 cycles) const override { return (cycles * 2); }
virtual UINT32 execute_min_cycles() const override { return 1; }
virtual UINT32 execute_max_cycles() const override { return 8; }
virtual UINT32 execute_input_lines() const override { return 4; }
virtual UINT32 execute_default_irq_vector() const override { return 0; }
virtual void execute_run() override;
virtual void execute_set_input(int inputnum, int state) override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == AS_PROGRAM) ? &m_program_config : ((spacenum == AS_DATA) ? &m_data_config : nullptr ); }
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override { return (spacenum == AS_PROGRAM) ? &m_program_config : ((spacenum == AS_DATA) ? &m_data_config : nullptr ); }
// device_state_interface overrides
void state_string_export(const device_state_entry &entry, std::string &str);
void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 2; }
virtual UINT32 disasm_max_opcode_bytes() const { return 4; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 2; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 4; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
private:
address_space_config m_program_config;

1266
src/devices/cpu/dsp56k/inst.h
View File

File diff suppressed because it is too large Load Diff

42
src/devices/cpu/dsp56k/pmove.h
View File

@ -51,7 +51,7 @@ public:
{
m_valid = decode(word0, word1);
}
bool decode(const UINT16 word0, const UINT16 word1)
bool decode(const UINT16 word0, const UINT16 word1) override
{
reg_id r;
decode_RR_table(BITSn(word0,0x3000), r);
@ -71,11 +71,11 @@ public:
return true;
}
void disassemble(std::string& retString) const
void disassemble(std::string& retString) const override
{
retString = m_source + "," + m_destination;
}
void evaluate() {}
void evaluate() override {}
private:
std::string m_source;
@ -91,7 +91,7 @@ public:
{
m_valid = decode(word0, word1);
}
bool decode(const UINT16 word0, const UINT16 word1)
bool decode(const UINT16 word0, const UINT16 word1) override
{
std::string ea;
if (opDestination() == iB)
@ -113,11 +113,11 @@ public:
return true;
}
void disassemble(std::string& retString) const
void disassemble(std::string& retString) const override
{
retString = m_source + "," + m_destination;
}
void evaluate() {}
void evaluate() override {}
private:
std::string m_source;
@ -133,7 +133,7 @@ public:
{
m_valid = decode(word0, word1);
}
bool decode(const UINT16 word0, const UINT16 word1)
bool decode(const UINT16 word0, const UINT16 word1) override
{
reg_id r;
reg_id D1;
@ -167,11 +167,11 @@ public:
return true;
}
void disassemble(std::string& retString) const
void disassemble(std::string& retString) const override
{
retString = parallelMove + " " + parallelMove2;
}
void evaluate() {}
void evaluate() override {}
private:
std::string parallelMove;
@ -187,7 +187,7 @@ public:
{
m_valid = decode(word0, word1);
}
bool decode(const UINT16 word0, const UINT16 word1)
bool decode(const UINT16 word0, const UINT16 word1) override
{
decode_IIIIx_table(BITSn(word0,0x0f00), BITSn(word0,0x0008),
m_source, m_destination);
@ -214,7 +214,7 @@ public:
return true;
}
void disassemble(std::string& retString) const
void disassemble(std::string& retString) const override
{
// (?,?) is a parallel nop
if (m_source == iWEIRD && m_destination == iWEIRD)
@ -222,7 +222,7 @@ public:
else
retString = regIdAsString(m_source) + "," + regIdAsString(m_destination);
}
void evaluate() {}
void evaluate() override {}
private:
reg_id m_source;
@ -240,7 +240,7 @@ public:
pms2 = "";
m_valid = decode(word0, word1);
}
bool decode(const UINT16 word0, const UINT16 word1)
bool decode(const UINT16 word0, const UINT16 word1) override
{
reg_id r;
reg_id S;
@ -261,11 +261,11 @@ public:
pms2 = parallel_move_str2;
return true;
}
void disassemble(std::string& retString) const
void disassemble(std::string& retString) const override
{
retString = pms + " " + pms2;
}
void evaluate() {}
void evaluate() override {}
private:
std::string pms; // TODO
@ -282,7 +282,7 @@ public:
m_ea = "";
m_valid = decode(word0, word1);
}
bool decode(const UINT16 word0, const UINT16 word1)
bool decode(const UINT16 word0, const UINT16 word1) override
{
reg_id r;
decode_RR_table(BITSn(word0,0x0300), r);
@ -290,11 +290,11 @@ public:
return true;
}
void disassemble(std::string& retString) const
void disassemble(std::string& retString) const override
{
retString = m_ea;
}
void evaluate() {}
void evaluate() override {}
private:
std::string m_ea;
@ -311,7 +311,7 @@ public:
m_destination = "";
m_valid = decode(word0, word1);
}
bool decode(const UINT16 word0, const UINT16 word1)
bool decode(const UINT16 word0, const UINT16 word1) override
{
INT8 b;
reg_id SD;
@ -321,11 +321,11 @@ public:
return true;
}
void disassemble(std::string& retString) const
void disassemble(std::string& retString) const override
{
retString = m_source + "," + m_destination;
}
void evaluate() {}
void evaluate() override {}
private:
std::string m_source;

22
src/devices/cpu/e0c6200/e0c6200.h
View File

@ -25,26 +25,26 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const { return 5; }
virtual UINT32 execute_max_cycles() const { return 14; } // longest opcode is 12 cycles, but interrupt service takes up to 14
virtual UINT32 execute_input_lines() const { return 1; }
virtual void execute_run();
virtual UINT32 execute_min_cycles() const override { return 5; }
virtual UINT32 execute_max_cycles() const override { return 14; } // longest opcode is 12 cycles, but interrupt service takes up to 14
virtual UINT32 execute_input_lines() const override { return 1; }
virtual void execute_run() override;
virtual void execute_one();
virtual bool check_interrupt() { return false; } // nothing to do by default
virtual void do_interrupt();
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return(spacenum == AS_PROGRAM) ? &m_program_config : ((spacenum == AS_DATA) ? &m_data_config : nullptr); }
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override { return(spacenum == AS_PROGRAM) ? &m_program_config : ((spacenum == AS_DATA) ? &m_data_config : nullptr); }
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 2; }
virtual UINT32 disasm_max_opcode_bytes() const { return 2; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual void state_string_export(const device_state_entry &entry, std::string &str);
virtual UINT32 disasm_min_opcode_bytes() const override { return 2; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 2; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
virtual void state_string_export(const device_state_entry &entry, std::string &str) override;
address_space_config m_program_config;
address_space_config m_data_config;

12
src/devices/cpu/e0c6200/e0c6s46.h
View File

@ -93,14 +93,14 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_input_lines() const { return 8; }
virtual void execute_set_input(int line, int state);
virtual void execute_one();
virtual bool check_interrupt();
virtual UINT32 execute_input_lines() const override { return 8; }
virtual void execute_set_input(int line, int state) override;
virtual void execute_one() override;
virtual bool check_interrupt() override;
private:
required_shared_ptr<UINT8> m_vram1;

54
src/devices/cpu/e132xs/e132xs.h
View File

@ -221,29 +221,29 @@ protected:
void init(int scale_mask);
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_stop();
virtual void device_start() override;
virtual void device_reset() override;
virtual void device_stop() override;
void make_ops();
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const;
virtual UINT32 execute_max_cycles() const;
virtual UINT32 execute_input_lines() const;
virtual void execute_run();
virtual void execute_set_input(int inputnum, int state);
virtual UINT32 execute_min_cycles() const override;
virtual UINT32 execute_max_cycles() const override;
virtual UINT32 execute_input_lines() const override;
virtual void execute_run() override;
virtual void execute_set_input(int inputnum, int state) override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const;
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const;
virtual UINT32 disasm_max_opcode_bytes() const;
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override;
virtual UINT32 disasm_max_opcode_bytes() const override;
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
// device_state_interface overrides
virtual void state_string_export(const device_state_entry &entry, std::string &str);
virtual void state_string_export(const device_state_entry &entry, std::string &str) override;
// address spaces
const address_space_config m_program_config;
@ -524,7 +524,7 @@ public:
e116t_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
protected:
virtual void device_start();
virtual void device_start() override;
};
@ -537,7 +537,7 @@ public:
e116xt_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
protected:
virtual void device_start();
virtual void device_start() override;
};
@ -550,7 +550,7 @@ public:
e116xs_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
protected:
virtual void device_start();
virtual void device_start() override;
};
@ -563,7 +563,7 @@ public:
e116xsr_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
protected:
virtual void device_start();
virtual void device_start() override;
};
@ -576,7 +576,7 @@ public:
e132n_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
protected:
virtual void device_start();
virtual void device_start() override;
};
@ -589,7 +589,7 @@ public:
e132t_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
protected:
virtual void device_start();
virtual void device_start() override;
};
@ -602,7 +602,7 @@ public:
e132xn_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
protected:
virtual void device_start();
virtual void device_start() override;
};
@ -615,7 +615,7 @@ public:
e132xt_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
protected:
virtual void device_start();
virtual void device_start() override;
};
@ -628,7 +628,7 @@ public:
e132xs_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
protected:
virtual void device_start();
virtual void device_start() override;
};
@ -641,7 +641,7 @@ public:
e132xsr_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
protected:
virtual void device_start();
virtual void device_start() override;
};
@ -654,7 +654,7 @@ public:
gms30c2116_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
protected:
virtual void device_start();
virtual void device_start() override;
};
@ -667,7 +667,7 @@ public:
gms30c2132_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
protected:
virtual void device_start();
virtual void device_start() override;
};
@ -680,7 +680,7 @@ public:
gms30c2216_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
protected:
virtual void device_start();
virtual void device_start() override;
};
@ -693,7 +693,7 @@ public:
gms30c2232_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
protected:
virtual void device_start();
virtual void device_start() override;
};
#endif /* __E132XS_H__ */

26
src/devices/cpu/es5510/es5510.h
View File

@ -123,19 +123,19 @@ public:
void write_to_dol(INT32 value);
protected:
virtual void device_start();
virtual void device_reset();
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const;
virtual UINT64 execute_clocks_to_cycles(UINT64 clocks) const;
virtual UINT64 execute_cycles_to_clocks(UINT64 cycles) const;
virtual UINT32 execute_min_cycles() const;
virtual UINT32 execute_max_cycles() const;
virtual UINT32 execute_input_lines() const;
virtual void execute_run();
virtual UINT32 disasm_min_opcode_bytes() const;
virtual UINT32 disasm_max_opcode_bytes() const;
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual void execute_set_input(int linenum, int state);
virtual void device_start() override;
virtual void device_reset() override;
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override;
virtual UINT64 execute_clocks_to_cycles(UINT64 clocks) const override;
virtual UINT64 execute_cycles_to_clocks(UINT64 cycles) const override;
virtual UINT32 execute_min_cycles() const override;
virtual UINT32 execute_max_cycles() const override;
virtual UINT32 execute_input_lines() const override;
virtual void execute_run() override;
virtual UINT32 disasm_min_opcode_bytes() const override;
virtual UINT32 disasm_max_opcode_bytes() const override;
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
virtual void execute_set_input(int linenum, int state) override;
INT32 alu_operation(UINT8 op, INT32 aValue, INT32 bValue, UINT8 &flags);
void alu_operation_end();

26
src/devices/cpu/esrip/esrip.h
View File

@ -130,29 +130,29 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_stop();
virtual void device_start() override;
virtual void device_reset() override;
virtual void device_stop() override;
void make_ops();
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const;
virtual UINT32 execute_max_cycles() const;
virtual UINT32 execute_input_lines() const;
virtual void execute_run();
virtual void execute_set_input(int inputnum, int state);
virtual UINT32 execute_min_cycles() const override;
virtual UINT32 execute_max_cycles() const override;
virtual UINT32 execute_input_lines() const override;
virtual void execute_run() override;
virtual void execute_set_input(int inputnum, int state) override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const;
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const;
virtual UINT32 disasm_max_opcode_bytes() const;
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override;
virtual UINT32 disasm_max_opcode_bytes() const override;
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
// device_state_interface overrides
virtual void state_string_export(const device_state_entry &entry, std::string &str);
virtual void state_string_export(const device_state_entry &entry, std::string &str) override;
// address spaces
const address_space_config m_program_config;

24
src/devices/cpu/f8/f8.h
View File

@ -37,26 +37,26 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const { return 1; }
virtual UINT32 execute_max_cycles() const { return 7; }
virtual UINT32 execute_input_lines() const { return 1; }
virtual void execute_run();
virtual void execute_set_input(int inputnum, int state);
virtual UINT32 execute_min_cycles() const override { return 1; }
virtual UINT32 execute_max_cycles() const override { return 7; }
virtual UINT32 execute_input_lines() const override { return 1; }
virtual void execute_run() override;
virtual void execute_set_input(int inputnum, int state) override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == AS_PROGRAM) ? &m_program_config : ( (spacenum == AS_IO) ? &m_io_config : nullptr ); }
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override { return (spacenum == AS_PROGRAM) ? &m_program_config : ( (spacenum == AS_IO) ? &m_io_config : nullptr ); }
// device_state_interface overrides
void state_string_export(const device_state_entry &entry, std::string &str);
void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const { return 3; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 3; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
private:
address_space_config m_program_config;

28
src/devices/cpu/h6280/h6280.h
View File

@ -77,28 +77,28 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_stop();
virtual void device_start() override;
virtual void device_reset() override;
virtual void device_stop() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const;
virtual UINT32 execute_max_cycles() const;
virtual UINT32 execute_input_lines() const;
virtual void execute_run();
virtual void execute_set_input(int inputnum, int state);
virtual UINT32 execute_min_cycles() const override;
virtual UINT32 execute_max_cycles() const override;
virtual UINT32 execute_input_lines() const override;
virtual void execute_run() override;
virtual void execute_set_input(int inputnum, int state) override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == AS_PROGRAM) ? &m_program_config : ( (spacenum == AS_IO) ? &m_io_config : nullptr ); }
virtual bool memory_translate(address_spacenum spacenum, int intention, offs_t &address);
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override { return (spacenum == AS_PROGRAM) ? &m_program_config : ( (spacenum == AS_IO) ? &m_io_config : nullptr ); }
virtual bool memory_translate(address_spacenum spacenum, int intention, offs_t &address) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const;
virtual UINT32 disasm_max_opcode_bytes() const;
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override;
virtual UINT32 disasm_max_opcode_bytes() const override;
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
// device_state_interface overrides
virtual void state_string_export(const device_state_entry &entry, std::string &str);
virtual void state_string_export(const device_state_entry &entry, std::string &str) override;
// opcode accessors
UINT8 program_read8(offs_t addr);

26
src/devices/cpu/h8/h8.h
View File

@ -142,27 +142,27 @@ protected:
};
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const;
virtual UINT32 execute_max_cycles() const;
virtual UINT32 execute_input_lines() const;
virtual void execute_run();
virtual UINT32 execute_min_cycles() const override;
virtual UINT32 execute_max_cycles() const override;
virtual UINT32 execute_input_lines() const override;
virtual void execute_run() override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const;
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override;
// device_state_interface overrides
virtual void state_import(const device_state_entry &entry);
virtual void state_export(const device_state_entry &entry);
virtual void state_string_export(const device_state_entry &entry, std::string &str);
virtual void state_import(const device_state_entry &entry) override;
virtual void state_export(const device_state_entry &entry) override;
virtual void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const;
virtual UINT32 disasm_max_opcode_bytes() const;
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override;
virtual UINT32 disasm_max_opcode_bytes() const override;
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
address_space_config program_config, io_config;
address_space *program, *io;

18
src/devices/cpu/h8/h83002.h
View File

@ -49,17 +49,17 @@ protected:
UINT8 syscr;
virtual void update_irq_filter();
virtual void interrupt_taken();
virtual int trapa_setup();
virtual void irq_setup();
virtual void internal_update(UINT64 current_time);
virtual machine_config_constructor device_mconfig_additions() const;
virtual void update_irq_filter() override;
virtual void interrupt_taken() override;
virtual int trapa_setup() override;
virtual void irq_setup() override;
virtual void internal_update(UINT64 current_time) override;
virtual machine_config_constructor device_mconfig_additions() const override;
DECLARE_ADDRESS_MAP(map, 16);
virtual void device_start();
virtual void device_reset();
virtual void execute_set_input(int inputnum, int state);
virtual void device_start() override;
virtual void device_reset() override;
virtual void execute_set_input(int inputnum, int state) override;
};
extern const device_type H83002;

18
src/devices/cpu/h8/h83006.h
View File

@ -55,17 +55,17 @@ protected:
UINT8 syscr;
UINT32 ram_start;
virtual void update_irq_filter();
virtual void interrupt_taken();
virtual int trapa_setup();
virtual void irq_setup();
virtual void internal_update(UINT64 current_time);
virtual machine_config_constructor device_mconfig_additions() const;
virtual void update_irq_filter() override;
virtual void interrupt_taken() override;
virtual int trapa_setup() override;
virtual void irq_setup() override;
virtual void internal_update(UINT64 current_time) override;
virtual machine_config_constructor device_mconfig_additions() const override;
DECLARE_ADDRESS_MAP(map, 16);
virtual void device_start();
virtual void device_reset();
virtual void execute_set_input(int inputnum, int state);
virtual void device_start() override;
virtual void device_reset() override;
virtual void execute_set_input(int inputnum, int state) override;
};

18
src/devices/cpu/h8/h83008.h
View File

@ -53,17 +53,17 @@ protected:
UINT8 syscr;
virtual void update_irq_filter();
virtual void interrupt_taken();
virtual int trapa_setup();
virtual void irq_setup();
virtual void internal_update(UINT64 current_time);
virtual machine_config_constructor device_mconfig_additions() const;
virtual void update_irq_filter() override;
virtual void interrupt_taken() override;
virtual int trapa_setup() override;
virtual void irq_setup() override;
virtual void internal_update(UINT64 current_time) override;
virtual machine_config_constructor device_mconfig_additions() const override;
DECLARE_ADDRESS_MAP(map, 16);
virtual void device_start();
virtual void device_reset();
virtual void execute_set_input(int inputnum, int state);
virtual void device_start() override;
virtual void device_reset() override;
virtual void execute_set_input(int inputnum, int state) override;
};
extern const device_type H83008;

18
src/devices/cpu/h8/h83048.h
View File

@ -63,17 +63,17 @@ protected:
UINT32 ram_start;
UINT8 syscr;
virtual void update_irq_filter();
virtual void interrupt_taken();
virtual int trapa_setup();
virtual void irq_setup();
virtual void internal_update(UINT64 current_time);
virtual machine_config_constructor device_mconfig_additions() const;
virtual void update_irq_filter() override;
virtual void interrupt_taken() override;
virtual int trapa_setup() override;
virtual void irq_setup() override;
virtual void internal_update(UINT64 current_time) override;
virtual machine_config_constructor device_mconfig_additions() const override;
DECLARE_ADDRESS_MAP(map, 16);
virtual void device_start();
virtual void device_reset();
virtual void execute_set_input(int inputnum, int state);
virtual void device_start() override;
virtual void device_reset() override;
virtual void execute_set_input(int inputnum, int state) override;
};
class h83044_device : public h83048_device {

16
src/devices/cpu/h8/h83337.h
View File

@ -65,16 +65,16 @@ protected:
UINT8 syscr;
UINT32 ram_start;
virtual void update_irq_filter();
virtual void interrupt_taken();
virtual void irq_setup();
virtual void internal_update(UINT64 current_time);
virtual machine_config_constructor device_mconfig_additions() const;
virtual void update_irq_filter() override;
virtual void interrupt_taken() override;
virtual void irq_setup() override;
virtual void internal_update(UINT64 current_time) override;
virtual machine_config_constructor device_mconfig_additions() const override;
DECLARE_ADDRESS_MAP(map, 16);
virtual void device_start();
virtual void device_reset();
virtual void execute_set_input(int inputnum, int state);
virtual void device_start() override;
virtual void device_reset() override;
virtual void execute_set_input(int inputnum, int state) override;
};
class h83334_device : public h83337_device {

32
src/devices/cpu/h8/h8_adc.h
View File

@ -94,8 +94,8 @@ protected:
bool analog_powered, adtrg;
UINT64 next_event;
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
void sampling();
void start_conversion();
@ -116,8 +116,8 @@ public:
h8_adc_3337_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
protected:
virtual int conversion_time(bool first, bool poweron);
virtual void mode_update();
virtual int conversion_time(bool first, bool poweron) override;
virtual void mode_update() override;
};
class h8_adc_3006_device : public h8_adc_device {
@ -125,8 +125,8 @@ public:
h8_adc_3006_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
protected:
virtual int conversion_time(bool first, bool poweron);
virtual void mode_update();
virtual int conversion_time(bool first, bool poweron) override;
virtual void mode_update() override;
};
class h8_adc_2245_device : public h8_adc_device {
@ -134,8 +134,8 @@ public:
h8_adc_2245_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
protected:
virtual int conversion_time(bool first, bool poweron);
virtual void mode_update();
virtual int conversion_time(bool first, bool poweron) override;
virtual void mode_update() override;
};
class h8_adc_2320_device : public h8_adc_device {
@ -143,8 +143,8 @@ public:
h8_adc_2320_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
protected:
virtual int conversion_time(bool first, bool poweron);
virtual void mode_update();
virtual int conversion_time(bool first, bool poweron) override;
virtual void mode_update() override;
};
class h8_adc_2357_device : public h8_adc_device {
@ -152,8 +152,8 @@ public:
h8_adc_2357_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
protected:
virtual int conversion_time(bool first, bool poweron);
virtual void mode_update();
virtual int conversion_time(bool first, bool poweron) override;
virtual void mode_update() override;
};
class h8_adc_2655_device : public h8_adc_device {
@ -161,10 +161,10 @@ public:
h8_adc_2655_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
protected:
virtual int conversion_time(bool first, bool poweron);
virtual void mode_update();
virtual void do_buffering(int buffer);
virtual int get_channel_index(int count);
virtual int conversion_time(bool first, bool poweron) override;
virtual void mode_update() override;
virtual void do_buffering(int buffer) override;
virtual int get_channel_index(int count) override;
};
extern const device_type H8_ADC_3337;

14
src/devices/cpu/h8/h8_intc.h
View File

@ -57,8 +57,8 @@ protected:
UINT16 iscr;
int icr_filter, ipr_filter;
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
virtual void get_priority(int vect, int &icr_pri, int &ipr_pri) const;
void update_irq_state();
@ -87,10 +87,10 @@ protected:
UINT32 icr;
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
virtual void get_priority(int vect, int &icr_pri, int &ipr_pri) const;
virtual void get_priority(int vect, int &icr_pri, int &ipr_pri) const override;
void update_irq_types();
};
@ -109,8 +109,8 @@ private:
static const int vector_to_slot[];
UINT8 ipr[11];
virtual void get_priority(int vect, int &icr_pri, int &ipr_pri) const;
virtual void device_reset();
virtual void get_priority(int vect, int &icr_pri, int &ipr_pri) const override;
virtual void device_reset() override;
};
extern const device_type H8_INTC;

4
src/devices/cpu/h8/h8_port.h
View File

@ -43,8 +43,8 @@ protected:
UINT8 dr;
UINT8 last_output;
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
void update_output();
};

6
src/devices/cpu/h8/h8_sci.h
View File

@ -125,9 +125,9 @@ protected:
UINT64 clock_base, divider;
virtual void device_start();
virtual void device_reset();
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
virtual void device_start() override;
virtual void device_reset() override;
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr) override;
void clock_start(int mode);
void clock_stop(int mode);

24
src/devices/cpu/h8/h8_timer16.h
View File

@ -121,8 +121,8 @@ protected:
bool counter_incrementing;
bool channel_active;
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
void update_counter(UINT64 cur_time = 0);
void recalc_event(UINT64 cur_time = 0);
@ -140,10 +140,10 @@ public:
void set_info(int tgr_count, int tbr_count, const char *intc, int irq_base);
protected:
virtual void tcr_update();
virtual void tier_update();
virtual void isr_update(UINT8 value);
virtual UINT8 isr_to_sr() const;
virtual void tcr_update() override;
virtual void tier_update() override;
virtual void isr_update(UINT8 value) override;
virtual UINT8 isr_to_sr() const override;
};
class h8s_timer16_channel_device : public h8_timer16_channel_device {
@ -158,10 +158,10 @@ public:
protected:
int count_types[8];
virtual void tcr_update();
virtual void tier_update();
virtual void isr_update(UINT8 value);
virtual UINT8 isr_to_sr() const;
virtual void tcr_update() override;
virtual void tier_update() override;
virtual void isr_update(UINT8 value) override;
virtual UINT8 isr_to_sr() const override;
};
class h8_timer16_device : public device_t {
@ -195,8 +195,8 @@ protected:
UINT8 default_tstr;
UINT8 tstr;
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
};
extern const device_type H8_TIMER16;

4
src/devices/cpu/h8/h8_timer8.h
View File

@ -89,8 +89,8 @@ protected:
int clock_type, clock_divider, clear_type, counter_cycle;
UINT64 last_clock_update, event_time;
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
void update_counter(UINT64 cur_time = 0);
void recalc_event(UINT64 cur_time = 0);

6
src/devices/cpu/h8/h8h.h
View File

@ -23,10 +23,10 @@ public:
protected:
static const disasm_entry disasm_entries[];
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
virtual void do_exec_full();
virtual void do_exec_partial();
virtual void do_exec_full() override;
virtual void do_exec_partial() override;
inline void r32_w(int reg, UINT32 val) { R[reg & 7] = val; R[(reg & 7) | 8] = val >> 16; }
inline UINT32 r32_r(int reg) const { return R[reg & 7] | (R[(reg & 7) | 8] << 16); }

6
src/devices/cpu/h8/h8s2000.h
View File

@ -24,10 +24,10 @@ public:
protected:
static const disasm_entry disasm_entries[];
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
virtual void do_exec_full();
virtual void do_exec_partial();
virtual void do_exec_full() override;
virtual void do_exec_partial() override;
#define O(o) void o ## _full(); void o ## _partial()
O(ldc_imm8_exr); O(ldc_r8l_exr); O(ldc_w_abs16_exr); O(ldc_w_abs32_exr); O(ldc_w_r32d16h_exr); O(ldc_w_r32d32hh_exr); O(ldc_w_r32ih_exr); O(ldc_w_r32ph_exr);

20
src/devices/cpu/h8/h8s2245.h
View File

@ -65,18 +65,18 @@ protected:
UINT32 ram_start;
UINT8 syscr;
virtual bool exr_in_stack() const;
virtual void update_irq_filter();
virtual void interrupt_taken();
virtual int trapa_setup();
virtual void irq_setup();
virtual void internal_update(UINT64 current_time);
virtual machine_config_constructor device_mconfig_additions() const;
virtual bool exr_in_stack() const override;
virtual void update_irq_filter() override;
virtual void interrupt_taken() override;
virtual int trapa_setup() override;
virtual void irq_setup() override;
virtual void internal_update(UINT64 current_time) override;
virtual machine_config_constructor device_mconfig_additions() const override;
DECLARE_ADDRESS_MAP(map, 16);
virtual void device_start();
virtual void device_reset();
virtual void execute_set_input(int inputnum, int state);
virtual void device_start() override;
virtual void device_reset() override;
virtual void execute_set_input(int inputnum, int state) override;
};
class h8s2241_device : public h8s2245_device {

22
src/devices/cpu/h8/h8s2320.h
View File

@ -74,19 +74,19 @@ protected:
UINT32 ram_start;
UINT8 syscr;
virtual bool exr_in_stack() const;
virtual void update_irq_filter();
virtual void interrupt_taken();
virtual int trace_setup();
virtual int trapa_setup();
virtual void irq_setup();
virtual void internal_update(UINT64 current_time);
virtual machine_config_constructor device_mconfig_additions() const;
virtual bool exr_in_stack() const override;
virtual void update_irq_filter() override;
virtual void interrupt_taken() override;
virtual int trace_setup() override;
virtual int trapa_setup() override;
virtual void irq_setup() override;
virtual void internal_update(UINT64 current_time) override;
virtual machine_config_constructor device_mconfig_additions() const override;
DECLARE_ADDRESS_MAP(map, 16);
virtual void device_start();
virtual void device_reset();
virtual void execute_set_input(int inputnum, int state);
virtual void device_start() override;
virtual void device_reset() override;
virtual void execute_set_input(int inputnum, int state) override;
};
class h8s2321_device : public h8s2320_device {

22
src/devices/cpu/h8/h8s2357.h
View File

@ -71,19 +71,19 @@ protected:
UINT32 ram_start;
unsigned char syscr;
virtual bool exr_in_stack() const;
virtual void update_irq_filter();
virtual void interrupt_taken();
virtual int trace_setup();
virtual int trapa_setup();
virtual void irq_setup();
virtual void internal_update(UINT64 current_time);
virtual machine_config_constructor device_mconfig_additions() const;
virtual bool exr_in_stack() const override;
virtual void update_irq_filter() override;
virtual void interrupt_taken() override;
virtual int trace_setup() override;
virtual int trapa_setup() override;
virtual void irq_setup() override;
virtual void internal_update(UINT64 current_time) override;
virtual machine_config_constructor device_mconfig_additions() const override;
DECLARE_ADDRESS_MAP(map, 16);
virtual void device_start();
virtual void device_reset();
virtual void execute_set_input(int inputnum, int state);
virtual void device_start() override;
virtual void device_reset() override;
virtual void execute_set_input(int inputnum, int state) override;
};
class h8s2352_device : public h8s2357_device {

6
src/devices/cpu/h8/h8s2600.h
View File

@ -23,10 +23,10 @@ public:
protected:
static const disasm_entry disasm_entries[];
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
virtual void do_exec_full();
virtual void do_exec_partial();
virtual void do_exec_full() override;
virtual void do_exec_partial() override;
#define O(o) void o ## _full(); void o ## _partial()
O(clrmac);

22
src/devices/cpu/h8/h8s2655.h
View File

@ -62,19 +62,19 @@ protected:
UINT8 syscr;
virtual bool exr_in_stack() const;
virtual void update_irq_filter();
virtual void interrupt_taken();
virtual int trace_setup();
virtual int trapa_setup();
virtual void irq_setup();
virtual void internal_update(UINT64 current_time);
virtual machine_config_constructor device_mconfig_additions() const;
virtual bool exr_in_stack() const override;
virtual void update_irq_filter() override;
virtual void interrupt_taken() override;
virtual int trace_setup() override;
virtual int trapa_setup() override;
virtual void irq_setup() override;
virtual void internal_update(UINT64 current_time) override;
virtual machine_config_constructor device_mconfig_additions() const override;
DECLARE_ADDRESS_MAP(map, 16);
virtual void device_start();
virtual void device_reset();
virtual void execute_set_input(int inputnum, int state);
virtual void device_start() override;
virtual void device_reset() override;
virtual void execute_set_input(int inputnum, int state) override;
};
class h8s2653_device : public h8s2655_device {

22
src/devices/cpu/hcd62121/hcd62121.h
View File

@ -41,25 +41,25 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const { return 4; }
virtual UINT32 execute_max_cycles() const { return 48; }
virtual UINT32 execute_input_lines() const { return 2; }
virtual void execute_run();
virtual UINT32 execute_min_cycles() const override { return 4; }
virtual UINT32 execute_max_cycles() const override { return 48; }
virtual UINT32 execute_input_lines() const override { return 2; }
virtual void execute_run() override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == AS_PROGRAM) ? &m_program_config : ( (spacenum == AS_IO) ? &m_io_config : nullptr ); }
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override { return (spacenum == AS_PROGRAM) ? &m_program_config : ( (spacenum == AS_IO) ? &m_io_config : nullptr ); }
// device_state_interface overrides
void state_string_export(const device_state_entry &entry, std::string &str);
void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const { return 18; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 18; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
UINT8 read_op();
UINT8 datasize( UINT8 op );

28
src/devices/cpu/hd61700/hd61700.h
View File

@ -79,28 +79,28 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
virtual void device_start() override;
virtual void device_reset() override;
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr) override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const { return 1; }
virtual UINT32 execute_max_cycles() const { return 52; }
virtual UINT32 execute_input_lines() const { return 6; }
virtual void execute_run();
virtual void execute_set_input(int inputnum, int state);
virtual UINT32 execute_min_cycles() const override { return 1; }
virtual UINT32 execute_max_cycles() const override { return 52; }
virtual UINT32 execute_input_lines() const override { return 6; }
virtual void execute_run() override;
virtual void execute_set_input(int inputnum, int state) override;
// device_state_interface overrides
virtual void state_import(const device_state_entry &entry);
void state_string_export(const device_state_entry &entry, std::string &str);
virtual void state_import(const device_state_entry &entry) override;
void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const { return 16; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 16; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
// interrupts
bool check_irqs(void);

42
src/devices/cpu/hmcs40/hmcs40.h
View File

@ -156,26 +156,26 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT64 execute_clocks_to_cycles(UINT64 clocks) const { return (clocks + 4 - 1) / 4; } // 4 cycles per machine cycle
virtual UINT64 execute_cycles_to_clocks(UINT64 cycles) const { return (cycles * 4); } // "
virtual UINT32 execute_min_cycles() const { return 1; }
virtual UINT32 execute_max_cycles() const { return 2; }
virtual UINT32 execute_input_lines() const { return 2+1; } // 3rd one is internal
virtual void execute_set_input(int line, int state);
virtual void execute_run();
virtual UINT64 execute_clocks_to_cycles(UINT64 clocks) const override { return (clocks + 4 - 1) / 4; } // 4 cycles per machine cycle
virtual UINT64 execute_cycles_to_clocks(UINT64 cycles) const override { return (cycles * 4); } // "
virtual UINT32 execute_min_cycles() const override { return 1; }
virtual UINT32 execute_max_cycles() const override { return 2; }
virtual UINT32 execute_input_lines() const override { return 2+1; } // 3rd one is internal
virtual void execute_set_input(int line, int state) override;
virtual void execute_run() override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return(spacenum == AS_PROGRAM) ? &m_program_config : ((spacenum == AS_DATA) ? &m_data_config : nullptr); }
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override { return(spacenum == AS_PROGRAM) ? &m_program_config : ((spacenum == AS_DATA) ? &m_data_config : nullptr); }
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 2; }
virtual UINT32 disasm_max_opcode_bytes() const { return 2; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
void state_string_export(const device_state_entry &entry, std::string &str);
virtual UINT32 disasm_min_opcode_bytes() const override { return 2; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 2; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
void state_string_export(const device_state_entry &entry, std::string &str) override;
address_space_config m_program_config;
address_space_config m_data_config;
@ -353,9 +353,9 @@ public:
protected:
// overrides
virtual UINT8 read_r(int index);
virtual void write_r(int index, UINT8 data);
virtual int read_d(int index);
virtual UINT8 read_r(int index) override;
virtual void write_r(int index, UINT8 data) override;
virtual int read_d(int index) override;
};
class hd38750_device : public hmcs43_cpu_device
@ -390,8 +390,8 @@ public:
protected:
// overrides
virtual UINT8 read_r(int index);
virtual void write_r(int index, UINT8 data);
virtual UINT8 read_r(int index) override;
virtual void write_r(int index, UINT8 data) override;
};
class hd38800_device : public hmcs44_cpu_device
@ -426,8 +426,8 @@ public:
protected:
// overrides
virtual UINT8 read_r(int index);
virtual void write_r(int index, UINT8 data);
virtual UINT8 read_r(int index) override;
virtual void write_r(int index, UINT8 data) override;
};
class hd38820_device : public hmcs45_cpu_device

26
src/devices/cpu/hphybrid/hphybrid.h
View File

@ -71,30 +71,30 @@ protected:
hp_hybrid_cpu_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname);
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const { return 6; }
virtual UINT32 execute_max_cycles() const { return 25; }
virtual UINT32 execute_input_lines() const { return 2; }
virtual UINT32 execute_default_irq_vector() const { return 0xffff; }
virtual void execute_run();
virtual void execute_set_input(int inputnum, int state);
virtual UINT32 execute_min_cycles() const override { return 6; }
virtual UINT32 execute_max_cycles() const override { return 25; }
virtual UINT32 execute_input_lines() const override { return 2; }
virtual UINT32 execute_default_irq_vector() const override { return 0xffff; }
virtual void execute_run() override;
virtual void execute_set_input(int inputnum, int state) override;
UINT16 execute_one(UINT16 opcode);
UINT16 execute_one_sub(UINT16 opcode);
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == AS_PROGRAM) ? &m_program_config : ( (spacenum == AS_IO) ? &m_io_config : nullptr ); }
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override { return (spacenum == AS_PROGRAM) ? &m_program_config : ( (spacenum == AS_IO) ? &m_io_config : nullptr ); }
// device_state_interface overrides
void state_string_export(const device_state_entry &entry, std::string &str);
void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 2; }
virtual UINT32 disasm_max_opcode_bytes() const { return 2; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 2; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 2; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
private:
address_space_config m_program_config;

24
src/devices/cpu/i4004/i4004.h
View File

@ -34,16 +34,16 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const { return 8; }
virtual UINT32 execute_max_cycles() const { return 16; }
virtual void execute_run();
virtual UINT32 execute_min_cycles() const override { return 8; }
virtual UINT32 execute_max_cycles() const override { return 16; }
virtual void execute_run() override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override
{
switch (spacenum)
{
@ -55,14 +55,14 @@ protected:
}
// device_state_interface overrides
virtual void state_import(const device_state_entry &entry);
virtual void state_export(const device_state_entry &entry);
virtual void state_string_export(const device_state_entry &entry, std::string &str);
virtual void state_import(const device_state_entry &entry) override;
virtual void state_export(const device_state_entry &entry) override;
virtual void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const { return 2; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 2; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
UINT8 ROP();
UINT8 READ_ROM();

26
src/devices/cpu/i8008/i8008.h
View File

@ -33,28 +33,28 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const;
virtual UINT32 execute_max_cycles() const;
virtual void execute_run();
virtual void execute_set_input(int inputnum, int state);
virtual UINT32 execute_min_cycles() const override;
virtual UINT32 execute_max_cycles() const override;
virtual void execute_run() override;
virtual void execute_set_input(int inputnum, int state) override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const;
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override;
// device_state_interface overrides
virtual void state_import(const device_state_entry &entry);
virtual void state_export(const device_state_entry &entry);
virtual void state_string_export(const device_state_entry &entry, std::string &str);
virtual void state_import(const device_state_entry &entry) override;
virtual void state_export(const device_state_entry &entry) override;
virtual void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const;
virtual UINT32 disasm_max_opcode_bytes() const;
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override;
virtual UINT32 disasm_max_opcode_bytes() const override;
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
virtual void execute_one(int opcode);

20
src/devices/cpu/i8089/i8089.h
View File

@ -67,31 +67,31 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_config_complete();
virtual void device_reset();
virtual void device_start() override;
virtual void device_config_complete() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual void execute_run();
virtual void execute_run() override;
int m_icount;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const;
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override;
address_space_config m_program_config;
address_space_config m_io_config;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const { return 7; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 7; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
// device_state_interface overrides
virtual void state_string_export(const device_state_entry &entry, std::string &str);
virtual void state_string_export(const device_state_entry &entry, std::string &str) override;
// optional information overrides
virtual machine_config_constructor device_mconfig_additions() const;
virtual machine_config_constructor device_mconfig_additions() const override;
private:
bool sysbus_width() { return BIT(m_sysbus, 0); }

4
src/devices/cpu/i8089/i8089_channel.h
View File

@ -90,8 +90,8 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
private:

32
src/devices/cpu/i86/i286.h
View File

@ -67,31 +67,31 @@ public:
i80286_cpu_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == AS_PROGRAM) ? &m_program_config : ( (spacenum == AS_IO) ? &m_io_config : nullptr ); }
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override { return (spacenum == AS_PROGRAM) ? &m_program_config : ( (spacenum == AS_IO) ? &m_io_config : nullptr ); }
typedef delegate<UINT32 (bool)> a20_cb;
static void static_set_a20_callback(device_t &device, a20_cb object) { downcast<i80286_cpu_device &>(device).m_a20_callback = object; }
template<class _Object> static devcb_base &static_set_shutdown_callback(device_t &device, _Object object) { return downcast<i80286_cpu_device &>(device).m_out_shutdown_func.set_callback(object); }
protected:
virtual void execute_run();
virtual void device_reset();
virtual void device_start();
virtual void state_string_export(const device_state_entry &entry, std::string &str);
virtual UINT32 execute_input_lines() const { return 1; }
virtual void execute_set_input(int inputnum, int state);
bool memory_translate(address_spacenum spacenum, int intention, offs_t &address);
virtual void execute_run() override;
virtual void device_reset() override;
virtual void device_start() override;
virtual void state_string_export(const device_state_entry &entry, std::string &str) override;
virtual UINT32 execute_input_lines() const override { return 1; }
virtual void execute_set_input(int inputnum, int state) override;
bool memory_translate(address_spacenum spacenum, int intention, offs_t &address) override;
virtual void interrupt(int int_num, int trap = 1) { if(trap) throw TRAP(int_num, (UINT16)-1); else interrupt_descriptor(int_num, 0, 0); }
virtual UINT8 read_port_byte(UINT16 port);
virtual UINT16 read_port_word(UINT16 port);
virtual void write_port_byte(UINT16 port, UINT8 data);
virtual void write_port_word(UINT16 port, UINT16 data);
virtual void interrupt(int int_num, int trap = 1) override { if(trap) throw TRAP(int_num, (UINT16)-1); else interrupt_descriptor(int_num, 0, 0); }
virtual UINT8 read_port_byte(UINT16 port) override;
virtual UINT16 read_port_word(UINT16 port) override;
virtual void write_port_byte(UINT16 port, UINT8 data) override;
virtual void write_port_word(UINT16 port, UINT16 data) override;
// Executing instructions
virtual UINT8 fetch_op();
virtual UINT8 fetch();
virtual UINT32 calc_addr(int seg, UINT16 offset, int size, int op, bool override = true);
virtual UINT8 fetch_op() override;
virtual UINT8 fetch() override;
virtual UINT32 calc_addr(int seg, UINT16 offset, int size, int op, bool override = true) override;
private:
void check_permission(UINT8 check_seg, UINT32 offset, UINT16 size, int operation);

24
src/devices/cpu/i860/i860.h
View File

@ -63,26 +63,26 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const { return 1; }
virtual UINT32 execute_max_cycles() const { return 8; }
virtual UINT32 execute_input_lines() const { return 0; }
virtual void execute_run();
virtual UINT32 execute_min_cycles() const override { return 1; }
virtual UINT32 execute_max_cycles() const override { return 8; }
virtual UINT32 execute_input_lines() const override { return 0; }
virtual void execute_run() override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
// device_state_interface overrides
void state_export(const device_state_entry &entry);
void state_import(const device_state_entry &entry);
void state_export(const device_state_entry &entry) override;
void state_import(const device_state_entry &entry) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 4; }
virtual UINT32 disasm_max_opcode_bytes() const { return 4; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 4; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 4; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
private:
address_space_config m_program_config;

26
src/devices/cpu/i960/i960.h
View File

@ -80,27 +80,27 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const { return 1; } /* ???? TODO: Exact timing unknown */
virtual UINT32 execute_max_cycles() const { return 1; } /* ???? TODO: Exact timing unknown */
virtual UINT32 execute_input_lines() const { return 4; }
virtual UINT32 execute_default_irq_vector() const { return 0xffffffff; }
virtual void execute_run();
virtual void execute_set_input(int inputnum, int state);
virtual UINT32 execute_min_cycles() const override { return 1; } /* ???? TODO: Exact timing unknown */
virtual UINT32 execute_max_cycles() const override { return 1; } /* ???? TODO: Exact timing unknown */
virtual UINT32 execute_input_lines() const override { return 4; }
virtual UINT32 execute_default_irq_vector() const override { return 0xffffffff; }
virtual void execute_run() override;
virtual void execute_set_input(int inputnum, int state) override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
// device_state_interface overrides
void state_string_export(const device_state_entry &entry, std::string &str);
void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 4; }
virtual UINT32 disasm_max_opcode_bytes() const { return 8; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 4; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 8; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
private:
address_space_config m_program_config;

24
src/devices/cpu/ie15/ie15.h
View File

@ -34,26 +34,26 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const;
virtual UINT32 execute_max_cycles() const;
virtual void execute_run();
virtual UINT32 execute_min_cycles() const override;
virtual UINT32 execute_max_cycles() const override;
virtual void execute_run() override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const;
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override;
// device_state_interface overrides
virtual void state_import(const device_state_entry &entry);
virtual void state_export(const device_state_entry &entry);
virtual void state_string_export(const device_state_entry &entry, std::string &str);
virtual void state_import(const device_state_entry &entry) override;
virtual void state_export(const device_state_entry &entry) override;
virtual void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const;
virtual UINT32 disasm_max_opcode_bytes() const;
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override;
virtual UINT32 disasm_max_opcode_bytes() const override;
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
virtual void execute_one(int opcode);

30
src/devices/cpu/jaguar/jaguar.h
View File

@ -114,24 +114,24 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const { return 1; }
virtual UINT32 execute_max_cycles() const { return 1; }
virtual UINT32 execute_input_lines() const { return 5; }
virtual void execute_set_input(int inputnum, int state);
virtual UINT32 execute_min_cycles() const override { return 1; }
virtual UINT32 execute_max_cycles() const override { return 1; }
virtual UINT32 execute_input_lines() const override { return 5; }
virtual void execute_set_input(int inputnum, int state) override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
// device_state_interface overrides
void state_string_export(const device_state_entry &entry, std::string &str);
void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 2; }
virtual UINT32 disasm_max_opcode_bytes() const { return 6; }
virtual UINT32 disasm_min_opcode_bytes() const override { return 2; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 6; }
address_space_config m_program_config;
@ -253,8 +253,8 @@ public:
DECLARE_READ32_MEMBER(ctrl_r);
protected:
virtual void execute_run();
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual void execute_run() override;
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
};
@ -268,10 +268,10 @@ public:
DECLARE_READ32_MEMBER(ctrl_r);
protected:
virtual UINT32 execute_input_lines() const { return 6; }
virtual void execute_run();
virtual UINT32 execute_input_lines() const override { return 6; }
virtual void execute_run() override;
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
};

28
src/devices/cpu/lc8670/lc8670.h
View File

@ -97,28 +97,28 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
virtual void device_start() override;
virtual void device_reset() override;
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr) override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const { return 1; }
virtual UINT32 execute_max_cycles() const { return 7; }
virtual UINT32 execute_input_lines() const { return 4; }
virtual void execute_run();
virtual void execute_set_input(int inputnum, int state);
virtual UINT32 execute_min_cycles() const override { return 1; }
virtual UINT32 execute_max_cycles() const override { return 7; }
virtual UINT32 execute_input_lines() const override { return 4; }
virtual void execute_run() override;
virtual void execute_set_input(int inputnum, int state) override;
// device_state_interface overrides
virtual void state_import(const device_state_entry &entry);
void state_string_export(const device_state_entry &entry, std::string &str);
virtual void state_import(const device_state_entry &entry) override;
void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const;
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const { return 4; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 4; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
private:
// helpers

26
src/devices/cpu/lh5801/lh5801.h
View File

@ -75,27 +75,27 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const { return 2; }
virtual UINT32 execute_max_cycles() const { return 19; }
virtual UINT32 execute_input_lines() const { return 2; }
virtual UINT32 execute_default_irq_vector() const { return 0; }
virtual void execute_run();
virtual void execute_set_input(int inputnum, int state);
virtual UINT32 execute_min_cycles() const override { return 2; }
virtual UINT32 execute_max_cycles() const override { return 19; }
virtual UINT32 execute_input_lines() const override { return 2; }
virtual UINT32 execute_default_irq_vector() const override { return 0; }
virtual void execute_run() override;
virtual void execute_set_input(int inputnum, int state) override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == AS_PROGRAM) ? &m_program_config : ( (spacenum == AS_IO) ? &m_io_config : nullptr ); }
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override { return (spacenum == AS_PROGRAM) ? &m_program_config : ( (spacenum == AS_IO) ? &m_io_config : nullptr ); }
// device_state_interface overrides
void state_string_export(const device_state_entry &entry, std::string &str);
void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const { return 5; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 5; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
private:
address_space_config m_program_config;

28
src/devices/cpu/m37710/m37710.h
View File

@ -101,28 +101,28 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const { return 1; }
virtual UINT32 execute_max_cycles() const { return 20; /* rough guess */ }
virtual UINT32 execute_input_lines() const { return M37710_LINE_MAX; }
virtual void execute_run();
virtual void execute_set_input(int inputnum, int state);
virtual UINT32 execute_min_cycles() const override { return 1; }
virtual UINT32 execute_max_cycles() const override { return 20; /* rough guess */ }
virtual UINT32 execute_input_lines() const override { return M37710_LINE_MAX; }
virtual void execute_run() override;
virtual void execute_set_input(int inputnum, int state) override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == AS_PROGRAM) ? &m_program_config : ( (spacenum == AS_IO) ? &m_io_config : nullptr ); }
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override { return (spacenum == AS_PROGRAM) ? &m_program_config : ( (spacenum == AS_IO) ? &m_io_config : nullptr ); }
// device_state_interface overrides
virtual void state_import(const device_state_entry &entry);
virtual void state_export(const device_state_entry &entry);
void state_string_export(const device_state_entry &entry, std::string &str);
virtual void state_import(const device_state_entry &entry) override;
virtual void state_export(const device_state_entry &entry) override;
void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const { return 6; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 6; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
private:
address_space_config m_program_config;

10
src/devices/cpu/m6502/deco16.h
View File

@ -19,16 +19,16 @@ public:
static const disasm_entry disasm_entries[0x100];
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual void do_exec_full();
virtual void do_exec_partial();
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
virtual void do_exec_full() override;
virtual void do_exec_partial() override;
protected:
address_space *io;
address_space_config io_config;
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const;
virtual void device_start();
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override;
virtual void device_start() override;
#define O(o) void o ## _full(); void o ## _partial()

10
src/devices/cpu/m6502/m3745x.h
View File

@ -121,11 +121,11 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
virtual void execute_set_input(int inputnum, int state);
virtual const address_space_config *memory_space_config(address_spacenum spacenum) const { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
virtual void device_start() override;
virtual void device_reset() override;
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr) override;
virtual void execute_set_input(int inputnum, int state) override;
virtual const address_space_config *memory_space_config(address_spacenum spacenum) const override { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
void send_port(address_space &space, UINT8 offset, UINT8 data);
UINT8 read_port(UINT8 offset);

24
src/devices/cpu/m6502/m4510.h
View File

@ -19,9 +19,9 @@ public:
static const disasm_entry disasm_entries[0x100];
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual void do_exec_full();
virtual void do_exec_partial();
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
virtual void do_exec_full() override;
virtual void do_exec_partial() override;
bool get_nomap() const { return nomap; }
@ -36,23 +36,23 @@ protected:
mi_4510_normal(m4510_device *base);
virtual ~mi_4510_normal() {}
virtual UINT8 read(UINT16 adr);
virtual UINT8 read_sync(UINT16 adr);
virtual UINT8 read_arg(UINT16 adr);
virtual void write(UINT16 adr, UINT8 val);
virtual UINT8 read(UINT16 adr) override;
virtual UINT8 read_sync(UINT16 adr) override;
virtual UINT8 read_arg(UINT16 adr) override;
virtual void write(UINT16 adr, UINT8 val) override;
};
class mi_4510_nd : public mi_4510_normal {
public:
mi_4510_nd(m4510_device *base);
virtual ~mi_4510_nd() {}
virtual UINT8 read_sync(UINT16 adr);
virtual UINT8 read_arg(UINT16 adr);
virtual UINT8 read_sync(UINT16 adr) override;
virtual UINT8 read_arg(UINT16 adr) override;
};
virtual void device_start();
virtual void device_reset();
virtual bool memory_translate(address_spacenum spacenum, int intention, offs_t &address);
virtual void device_start() override;
virtual void device_reset() override;
virtual bool memory_translate(address_spacenum spacenum, int intention, offs_t &address) override;
inline UINT32 map(UINT16 adr) {
if(map_enable & (1 << (adr >> 13))) {

10
src/devices/cpu/m6502/m5074x.h
View File

@ -97,11 +97,11 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
virtual void execute_set_input(int inputnum, int state);
virtual const address_space_config *memory_space_config(address_spacenum spacenum) const { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
virtual void device_start() override;
virtual void device_reset() override;
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr) override;
virtual void execute_set_input(int inputnum, int state) override;
virtual const address_space_config *memory_space_config(address_spacenum spacenum) const override { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
void send_port(address_space &space, UINT8 offset, UINT8 data);
UINT8 read_port(UINT8 offset);

14
src/devices/cpu/m6502/m6507.h
View File

@ -21,20 +21,20 @@ protected:
class mi_6507_normal : public memory_interface {
public:
virtual ~mi_6507_normal() {}
virtual UINT8 read(UINT16 adr);
virtual UINT8 read_sync(UINT16 adr);
virtual UINT8 read_arg(UINT16 adr);
virtual void write(UINT16 adr, UINT8 val);
virtual UINT8 read(UINT16 adr) override;
virtual UINT8 read_sync(UINT16 adr) override;
virtual UINT8 read_arg(UINT16 adr) override;
virtual void write(UINT16 adr, UINT8 val) override;
};
class mi_6507_nd : public mi_6507_normal {
public:
virtual ~mi_6507_nd() {}
virtual UINT8 read_sync(UINT16 adr);
virtual UINT8 read_arg(UINT16 adr);
virtual UINT8 read_sync(UINT16 adr) override;
virtual UINT8 read_arg(UINT16 adr) override;
};
virtual void device_start();
virtual void device_start() override;
};

28
src/devices/cpu/m6502/m6509.h
View File

@ -19,9 +19,9 @@ public:
static const disasm_entry disasm_entries[0x100];
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual void do_exec_full();
virtual void do_exec_partial();
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
virtual void do_exec_full() override;
virtual void do_exec_partial() override;
protected:
class mi_6509_normal : public memory_interface {
@ -30,25 +30,25 @@ protected:
mi_6509_normal(m6509_device *base);
virtual ~mi_6509_normal() {}
virtual UINT8 read(UINT16 adr);
virtual UINT8 read_9(UINT16 adr);
virtual UINT8 read_sync(UINT16 adr);
virtual UINT8 read_arg(UINT16 adr);
virtual void write(UINT16 adr, UINT8 val);
virtual void write_9(UINT16 adr, UINT8 val);
virtual UINT8 read(UINT16 adr) override;
virtual UINT8 read_9(UINT16 adr) override;
virtual UINT8 read_sync(UINT16 adr) override;
virtual UINT8 read_arg(UINT16 adr) override;
virtual void write(UINT16 adr, UINT8 val) override;
virtual void write_9(UINT16 adr, UINT8 val) override;
};
class mi_6509_nd : public mi_6509_normal {
public:
mi_6509_nd(m6509_device *base);
virtual ~mi_6509_nd() {}
virtual UINT8 read_sync(UINT16 adr);
virtual UINT8 read_arg(UINT16 adr);
virtual UINT8 read_sync(UINT16 adr) override;
virtual UINT8 read_arg(UINT16 adr) override;
};
virtual void device_start();
virtual void device_reset();
virtual void state_export(const device_state_entry &entry);
virtual void device_start() override;
virtual void device_reset() override;
virtual void state_export(const device_state_entry &entry) override;
UINT32 XPC;

14
src/devices/cpu/m6502/m740.h
View File

@ -39,17 +39,17 @@ public:
m740_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
m740_device(const machine_config &mconfig, device_type type, const char *name, const char *tag, device_t *owner, UINT32 clock, const char *shortname, const char *source);
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
static const disasm_entry disasm_entries[0x200];
virtual void state_string_export(const device_state_entry &entry, std::string &str);
virtual void state_string_export(const device_state_entry &entry, std::string &str) override;
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual void do_exec_full();
virtual void do_exec_partial();
virtual void execute_set_input(int inputnum, int state);
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
virtual void do_exec_full() override;
virtual void do_exec_partial() override;
virtual void execute_set_input(int inputnum, int state) override;
protected:
#define O(o) void o ## _full(); void o ## _partial()

28
src/devices/cpu/m6502/n2a03.h
View File

@ -22,9 +22,9 @@ public:
static const disasm_entry disasm_entries[0x100];
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual void do_exec_full();
virtual void do_exec_partial();
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
virtual void do_exec_full() override;
virtual void do_exec_partial() override;
READ8_MEMBER(psg1_4014_r);
READ8_MEMBER(psg1_4015_r);
@ -35,22 +35,22 @@ protected:
class mi_2a03_normal : public memory_interface {
public:
virtual ~mi_2a03_normal() {}
virtual UINT8 read(UINT16 adr);
virtual UINT8 read_sync(UINT16 adr);
virtual UINT8 read_arg(UINT16 adr);
virtual void write(UINT16 adr, UINT8 val);
virtual UINT8 read(UINT16 adr) override;
virtual UINT8 read_sync(UINT16 adr) override;
virtual UINT8 read_arg(UINT16 adr) override;
virtual void write(UINT16 adr, UINT8 val) override;
};
class mi_2a03_nd : public memory_interface {
public:
virtual ~mi_2a03_nd() {}
virtual UINT8 read(UINT16 adr);
virtual UINT8 read_sync(UINT16 adr);
virtual UINT8 read_arg(UINT16 adr);
virtual void write(UINT16 adr, UINT8 val);
virtual UINT8 read(UINT16 adr) override;
virtual UINT8 read_sync(UINT16 adr) override;
virtual UINT8 read_arg(UINT16 adr) override;
virtual void write(UINT16 adr, UINT8 val) override;
};
virtual void device_start();
virtual void device_start() override;
#define O(o) void o ## _full(); void o ## _partial()
@ -63,8 +63,8 @@ protected:
#undef O
virtual machine_config_constructor device_mconfig_additions() const;
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const;
virtual machine_config_constructor device_mconfig_additions() const override;
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override;
private:
address_space_config m_program_config;

16
src/devices/cpu/m6809/hd6309.h
View File

@ -33,18 +33,18 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_pre_save();
virtual void device_post_load();
virtual void device_start() override;
virtual void device_reset() override;
virtual void device_pre_save() override;
virtual void device_post_load() override;
// device_execute_interface overrides
virtual void execute_run();
virtual void execute_run() override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const;
virtual UINT32 disasm_max_opcode_bytes() const;
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override;
virtual UINT32 disasm_max_opcode_bytes() const override;
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
private:
typedef m6809_base_device super;

6
src/devices/cpu/m6809/konami.h
View File

@ -40,13 +40,13 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_start() override;
// device_execute_interface overrides
virtual void execute_run();
virtual void execute_run() override;
// device_disasm_interface overrides
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
private:
typedef m6809_base_device super;

22
src/devices/cpu/mb86233/mb86233.h
View File

@ -61,25 +61,25 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const { return 1; }
virtual UINT32 execute_max_cycles() const { return 2; }
virtual UINT32 execute_input_lines() const { return 0; }
virtual void execute_run();
virtual UINT32 execute_min_cycles() const override { return 1; }
virtual UINT32 execute_max_cycles() const override { return 2; }
virtual UINT32 execute_input_lines() const override { return 0; }
virtual void execute_run() override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == AS_PROGRAM) ? &m_program_config : ( (spacenum == AS_DATA) ? &m_data_config : nullptr ); }
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override { return (spacenum == AS_PROGRAM) ? &m_program_config : ( (spacenum == AS_DATA) ? &m_data_config : nullptr ); }
// device_state_interface overrides
void state_string_export(const device_state_entry &entry, std::string &str);
void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 4; }
virtual UINT32 disasm_max_opcode_bytes() const { return 4; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 4; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 4; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
private:
address_space_config m_program_config;

22
src/devices/cpu/mb86235/mb86235.h
View File

@ -28,26 +28,26 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const { return 1; }
virtual UINT32 execute_max_cycles() const { return 7; }
virtual UINT32 execute_input_lines() const { return 0; }
virtual void execute_run();
virtual UINT32 execute_min_cycles() const override { return 1; }
virtual UINT32 execute_max_cycles() const override { return 7; }
virtual UINT32 execute_input_lines() const override { return 0; }
virtual void execute_run() override;
//virtual void execute_set_input(int inputnum, int state);
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
// device_state_interface overrides
void state_string_export(const device_state_entry &entry, std::string &str);
void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 8; }
virtual UINT32 disasm_max_opcode_bytes() const { return 8; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 8; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 8; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
private:
address_space_config m_program_config;

32
src/devices/cpu/mb88xx/mb88xx.h
View File

@ -74,30 +74,30 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const { return 1; }
virtual UINT32 execute_max_cycles() const { return 3; }
virtual UINT32 execute_input_lines() const { return 1; }
virtual void execute_run();
virtual void execute_set_input(int inputnum, int state);
virtual UINT64 execute_clocks_to_cycles(UINT64 clocks) const { return (clocks + 6 - 1) / 6; }
virtual UINT64 execute_cycles_to_clocks(UINT64 cycles) const { return (cycles * 6); }
virtual UINT32 execute_min_cycles() const override { return 1; }
virtual UINT32 execute_max_cycles() const override { return 3; }
virtual UINT32 execute_input_lines() const override { return 1; }
virtual void execute_run() override;
virtual void execute_set_input(int inputnum, int state) override;
virtual UINT64 execute_clocks_to_cycles(UINT64 clocks) const override { return (clocks + 6 - 1) / 6; }
virtual UINT64 execute_cycles_to_clocks(UINT64 cycles) const override { return (cycles * 6); }
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == AS_PROGRAM) ? &m_program_config : ( (spacenum == AS_DATA) ? &m_data_config : ( (spacenum == AS_IO) ? &m_io_config : nullptr ) ); }
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override { return (spacenum == AS_PROGRAM) ? &m_program_config : ( (spacenum == AS_DATA) ? &m_data_config : ( (spacenum == AS_IO) ? &m_io_config : nullptr ) ); }
// device_state_interface overrides
void state_string_export(const device_state_entry &entry, std::string &str);
void state_import(const device_state_entry &entry);
void state_export(const device_state_entry &entry);
void state_string_export(const device_state_entry &entry, std::string &str) override;
void state_import(const device_state_entry &entry) override;
void state_export(const device_state_entry &entry) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const { return 2; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 2; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
private:
address_space_config m_program_config;

26
src/devices/cpu/mc68hc11/mc68hc11.h
View File

@ -52,30 +52,30 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const { return 1; }
virtual UINT32 execute_max_cycles() const { return 41; }
virtual UINT32 execute_input_lines() const { return 2; }
virtual UINT32 execute_default_irq_vector() const { return 0; }
virtual void execute_run();
virtual void execute_set_input(int inputnum, int state);
virtual UINT32 execute_min_cycles() const override { return 1; }
virtual UINT32 execute_max_cycles() const override { return 41; }
virtual UINT32 execute_input_lines() const override { return 2; }
virtual UINT32 execute_default_irq_vector() const override { return 0; }
virtual void execute_run() override;
virtual void execute_set_input(int inputnum, int state) override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override
{
return (spacenum == AS_PROGRAM) ? &m_program_config : ( (spacenum == AS_IO) ? &m_io_config : nullptr );
}
// device_state_interface overrides
void state_string_export(const device_state_entry &entry, std::string &str);
void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const { return 5; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 5; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
private:
address_space_config m_program_config;

22
src/devices/cpu/mcs96/i8x9x.h
View File

@ -26,20 +26,20 @@ public:
void serial_w(UINT8 val);
protected:
virtual void device_start();
virtual void device_reset();
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const;
virtual void device_start() override;
virtual void device_reset() override;
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override;
static const disasm_entry disasm_entries[0x100];
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual void do_exec_full();
virtual void do_exec_partial();
virtual void internal_update(UINT64 current_time);
virtual void io_w8(UINT8 adr, UINT8 data);
virtual void io_w16(UINT8 adr, UINT16 data);
virtual UINT8 io_r8(UINT8 adr);
virtual UINT16 io_r16(UINT8 adr);
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
virtual void do_exec_full() override;
virtual void do_exec_partial() override;
virtual void internal_update(UINT64 current_time) override;
virtual void io_w8(UINT8 adr, UINT8 data) override;
virtual void io_w16(UINT8 adr, UINT16 data) override;
virtual UINT8 io_r8(UINT8 adr) override;
virtual UINT16 io_r16(UINT8 adr) override;
private:
enum {

14
src/devices/cpu/mcs96/i8xc196.h
View File

@ -19,14 +19,14 @@ public:
static const disasm_entry disasm_entries[0x100];
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual void do_exec_full();
virtual void do_exec_partial();
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
virtual void do_exec_full() override;
virtual void do_exec_partial() override;
virtual void io_w8(UINT8 adr, UINT8 data);
virtual void io_w16(UINT8 adr, UINT16 data);
virtual UINT8 io_r8(UINT8 adr);
virtual UINT16 io_r16(UINT8 adr);
virtual void io_w8(UINT8 adr, UINT8 data) override;
virtual void io_w16(UINT8 adr, UINT16 data) override;
virtual UINT8 io_r8(UINT8 adr) override;
virtual UINT16 io_r16(UINT8 adr) override;
#define O(o) void o ## _196_full(); void o ## _196_partial()

26
src/devices/cpu/mcs96/mcs96.h
View File

@ -69,27 +69,27 @@ protected:
};
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const;
virtual UINT32 execute_max_cycles() const;
virtual UINT32 execute_input_lines() const;
virtual void execute_run();
virtual void execute_set_input(int inputnum, int state);
virtual UINT32 execute_min_cycles() const override;
virtual UINT32 execute_max_cycles() const override;
virtual UINT32 execute_input_lines() const override;
virtual void execute_run() override;
virtual void execute_set_input(int inputnum, int state) override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const;
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override;
// device_state_interface overrides
virtual void state_import(const device_state_entry &entry);
virtual void state_export(const device_state_entry &entry);
virtual void state_string_export(const device_state_entry &entry, std::string &str);
virtual void state_import(const device_state_entry &entry) override;
virtual void state_export(const device_state_entry &entry) override;
virtual void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const;
virtual UINT32 disasm_max_opcode_bytes() const;
virtual UINT32 disasm_min_opcode_bytes() const override;
virtual UINT32 disasm_max_opcode_bytes() const override;
virtual offs_t disasm_generic(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options, const disasm_entry *entries);
address_space_config program_config;

12
src/devices/cpu/melps4/m58846.h
View File

@ -21,18 +21,18 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual void execute_one();
virtual void execute_one() override;
// device_disasm_interface overrides
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
// timers
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
virtual void write_v(UINT8 data);
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr) override;
virtual void write_v(UINT8 data) override;
emu_timer *m_timer;
void reset_timer();

26
src/devices/cpu/melps4/melps4.h
View File

@ -141,26 +141,26 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT64 execute_clocks_to_cycles(UINT64 clocks) const { return (clocks + 6 - 1) / 6; } // 6 t-states per machine cycle
virtual UINT64 execute_cycles_to_clocks(UINT64 cycles) const { return (cycles * 6); } // "
virtual UINT32 execute_min_cycles() const { return 1; }
virtual UINT32 execute_max_cycles() const { return 1+1; } // max opcode cycles + interrupt duration
virtual UINT32 execute_input_lines() const { return 3; } // up to 3 (some internal)
virtual void execute_set_input(int line, int state);
virtual void execute_run();
virtual UINT64 execute_clocks_to_cycles(UINT64 clocks) const override { return (clocks + 6 - 1) / 6; } // 6 t-states per machine cycle
virtual UINT64 execute_cycles_to_clocks(UINT64 cycles) const override { return (cycles * 6); } // "
virtual UINT32 execute_min_cycles() const override { return 1; }
virtual UINT32 execute_max_cycles() const override { return 1+1; } // max opcode cycles + interrupt duration
virtual UINT32 execute_input_lines() const override { return 3; } // up to 3 (some internal)
virtual void execute_set_input(int line, int state) override;
virtual void execute_run() override;
virtual void execute_one();
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return(spacenum == AS_PROGRAM) ? &m_program_config : ((spacenum == AS_DATA) ? &m_data_config : nullptr); }
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override { return(spacenum == AS_PROGRAM) ? &m_program_config : ((spacenum == AS_DATA) ? &m_data_config : nullptr); }
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 2; }
virtual UINT32 disasm_max_opcode_bytes() const { return 2; }
virtual void state_string_export(const device_state_entry &entry, std::string &str);
virtual UINT32 disasm_min_opcode_bytes() const override { return 2; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 2; }
virtual void state_string_export(const device_state_entry &entry, std::string &str) override;
address_space_config m_program_config;
address_space_config m_data_config;

24
src/devices/cpu/minx/minx.h
View File

@ -22,26 +22,26 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const { return 1; }
virtual UINT32 execute_max_cycles() const { return 4; }
virtual UINT32 execute_input_lines() const { return 1; }
virtual void execute_run();
virtual void execute_set_input(int inputnum, int state);
virtual UINT32 execute_min_cycles() const override { return 1; }
virtual UINT32 execute_max_cycles() const override { return 4; }
virtual UINT32 execute_input_lines() const override { return 1; }
virtual void execute_run() override;
virtual void execute_set_input(int inputnum, int state) override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
// device_state_interface overrides
void state_string_export(const device_state_entry &entry, std::string &str);
void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const { return 5; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 5; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
private:
address_space_config m_program_config;

34
src/devices/cpu/mips/mips3.h
View File

@ -285,30 +285,30 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_stop();
virtual void device_start() override;
virtual void device_reset() override;
virtual void device_stop() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const { return 1; }
virtual UINT32 execute_max_cycles() const { return 40; }
virtual UINT32 execute_input_lines() const { return 6; }
virtual void execute_run();
virtual void execute_set_input(int inputnum, int state);
virtual void execute_burn(INT32 cycles) { m_totalcycles += cycles; }
virtual UINT32 execute_min_cycles() const override { return 1; }
virtual UINT32 execute_max_cycles() const override { return 40; }
virtual UINT32 execute_input_lines() const override { return 6; }
virtual void execute_run() override;
virtual void execute_set_input(int inputnum, int state) override;
virtual void execute_burn(INT32 cycles) override { m_totalcycles += cycles; }
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
virtual bool memory_translate(address_spacenum spacenum, int intention, offs_t &address);
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
virtual bool memory_translate(address_spacenum spacenum, int intention, offs_t &address) override;
// device_state_interface overrides
virtual void state_export(const device_state_entry &entry);
void state_string_export(const device_state_entry &entry, std::string &str);
virtual void state_export(const device_state_entry &entry) override;
void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 4; }
virtual UINT32 disasm_max_opcode_bytes() const { return 4; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 4; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 4; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
private:
@ -728,7 +728,7 @@ public:
protected:
// required overrides
virtual bool describe(opcode_desc &desc, const opcode_desc *prev);
virtual bool describe(opcode_desc &desc, const opcode_desc *prev) override;
private:
// internal helpers

30
src/devices/cpu/mips/r3000.h
View File

@ -109,29 +109,29 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_post_load();
virtual void device_start() override;
virtual void device_reset() override;
virtual void device_post_load() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const;
virtual UINT32 execute_max_cycles() const;
virtual UINT32 execute_input_lines() const;
virtual void execute_run();
virtual void execute_set_input(int inputnum, int state);
virtual UINT32 execute_min_cycles() const override;
virtual UINT32 execute_max_cycles() const override;
virtual UINT32 execute_input_lines() const override;
virtual void execute_run() override;
virtual void execute_set_input(int inputnum, int state) override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const;
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override;
// device_state_interface overrides
virtual void state_import(const device_state_entry &entry);
virtual void state_export(const device_state_entry &entry);
virtual void state_string_export(const device_state_entry &entry, std::string &str);
virtual void state_import(const device_state_entry &entry) override;
virtual void state_export(const device_state_entry &entry) override;
virtual void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const;
virtual UINT32 disasm_max_opcode_bytes() const;
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override;
virtual UINT32 disasm_max_opcode_bytes() const override;
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
// memory accessors
struct r3000_data_accessors

28
src/devices/cpu/mn10200/mn10200.h
View File

@ -72,28 +72,28 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT64 execute_clocks_to_cycles(UINT64 clocks) const { return (clocks + 2 - 1) / 2; } // internal /2 divider
virtual UINT64 execute_cycles_to_clocks(UINT64 cycles) const { return (cycles * 2); } // internal /2 divider
virtual UINT32 execute_min_cycles() const { return 1; }
virtual UINT32 execute_max_cycles() const { return 13+7; } // max opcode cycles + interrupt duration
virtual UINT32 execute_input_lines() const { return 4; }
virtual void execute_run();
virtual void execute_set_input(int inputnum, int state);
virtual UINT64 execute_clocks_to_cycles(UINT64 clocks) const override { return (clocks + 2 - 1) / 2; } // internal /2 divider
virtual UINT64 execute_cycles_to_clocks(UINT64 cycles) const override { return (cycles * 2); } // internal /2 divider
virtual UINT32 execute_min_cycles() const override { return 1; }
virtual UINT32 execute_max_cycles() const override { return 13+7; } // max opcode cycles + interrupt duration
virtual UINT32 execute_input_lines() const override { return 4; }
virtual void execute_run() override;
virtual void execute_set_input(int inputnum, int state) override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
// device_state_interface overrides
void state_string_export(const device_state_entry &entry, std::string &str);
void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const { return 7; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 7; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
private:
address_space_config m_program_config;

36
src/devices/cpu/nec/v25.h
View File

@ -41,32 +41,32 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_post_load() { notify_clock_changed(); }
virtual void device_start() override;
virtual void device_reset() override;
virtual void device_post_load() override { notify_clock_changed(); }
// device_execute_interface overrides
virtual UINT64 execute_clocks_to_cycles(UINT64 clocks) const { return clocks / m_PCK; }
virtual UINT64 execute_cycles_to_clocks(UINT64 cycles) const { return cycles * m_PCK; }
virtual UINT32 execute_min_cycles() const { return 1; }
virtual UINT32 execute_max_cycles() const { return 80; }
virtual UINT32 execute_input_lines() const { return 1; }
virtual UINT32 execute_default_irq_vector() const { return 0xff; }
virtual void execute_run();
virtual void execute_set_input(int inputnum, int state);
virtual UINT64 execute_clocks_to_cycles(UINT64 clocks) const override { return clocks / m_PCK; }
virtual UINT64 execute_cycles_to_clocks(UINT64 cycles) const override { return cycles * m_PCK; }
virtual UINT32 execute_min_cycles() const override { return 1; }
virtual UINT32 execute_max_cycles() const override { return 80; }
virtual UINT32 execute_input_lines() const override { return 1; }
virtual UINT32 execute_default_irq_vector() const override { return 0xff; }
virtual void execute_run() override;
virtual void execute_set_input(int inputnum, int state) override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == AS_PROGRAM) ? &m_program_config : ( (spacenum == AS_IO) ? &m_io_config : nullptr); }
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override { return (spacenum == AS_PROGRAM) ? &m_program_config : ( (spacenum == AS_IO) ? &m_io_config : nullptr); }
// device_state_interface overrides
void state_string_export(const device_state_entry &entry, std::string &str);
virtual void state_import(const device_state_entry &entry);
virtual void state_export(const device_state_entry &entry);
void state_string_export(const device_state_entry &entry, std::string &str) override;
virtual void state_import(const device_state_entry &entry) override;
virtual void state_export(const device_state_entry &entry) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const { return 8; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 8; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
private:
address_space_config m_program_config;

10
src/devices/cpu/nec/v53.h
View File

@ -224,7 +224,7 @@ public:
const address_space_config m_io_space_config;
const address_space_config *memory_space_config(address_spacenum spacenum) const
const address_space_config *memory_space_config(address_spacenum spacenum) const override
{
switch (spacenum)
{
@ -242,10 +242,10 @@ public:
protected:
// device-level overrides
virtual machine_config_constructor device_mconfig_additions() const;
virtual void device_start();
virtual void device_reset();
virtual void execute_set_input(int inputnum, int state);
virtual machine_config_constructor device_mconfig_additions() const override;
virtual void device_start() override;
virtual void device_reset() override;
virtual void execute_set_input(int inputnum, int state) override;
required_device<pit8253_device> m_v53tcu;
required_device<upd71071_v53_device> m_v53dmau;

30
src/devices/cpu/pdp1/pdp1.h
View File

@ -90,29 +90,29 @@ public:
protected:
// device-level overrides
virtual void device_config_complete();
virtual void device_start();
virtual void device_reset();
virtual void device_config_complete() override;
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const { return 5; }
virtual UINT32 execute_max_cycles() const { return 31; }
virtual UINT32 execute_input_lines() const { return 16; }
virtual void execute_run();
virtual void execute_set_input(int inputnum, int state);
virtual UINT32 execute_min_cycles() const override { return 5; }
virtual UINT32 execute_max_cycles() const override { return 31; }
virtual UINT32 execute_input_lines() const override { return 16; }
virtual void execute_run() override;
virtual void execute_set_input(int inputnum, int state) override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
// device_state_interface overrides
virtual void state_import(const device_state_entry &entry);
virtual void state_export(const device_state_entry &entry);
void state_string_export(const device_state_entry &entry, std::string &str);
virtual void state_import(const device_state_entry &entry) override;
virtual void state_export(const device_state_entry &entry) override;
void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 4; }
virtual UINT32 disasm_max_opcode_bytes() const { return 4; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 4; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 4; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
private:
address_space_config m_program_config;

22
src/devices/cpu/pdp1/tx0.h
View File

@ -57,19 +57,19 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const { return 1; }
virtual UINT32 execute_max_cycles() const { return 3; }
virtual UINT32 execute_min_cycles() const override { return 1; }
virtual UINT32 execute_max_cycles() const override { return 3; }
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override { return (spacenum == AS_PROGRAM) ? &m_program_config : nullptr; }
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 4; }
virtual UINT32 disasm_max_opcode_bytes() const { return 4; }
virtual UINT32 disasm_min_opcode_bytes() const override { return 4; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 4; }
protected:
address_space_config m_program_config;
@ -150,8 +150,8 @@ public:
tx0_8kw_device(const machine_config &mconfig, const char *_tag, device_t *_owner, UINT32 _clock);
protected:
virtual void execute_run();
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual void execute_run() override;
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
private:
void execute_instruction_8kw();
@ -165,8 +165,8 @@ public:
tx0_64kw_device(const machine_config &mconfig, const char *_tag, device_t *_owner, UINT32 _clock);
protected:
virtual void execute_run();
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual void execute_run() override;
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
private:
void execute_instruction_64kw();

30
src/devices/cpu/pdp8/pdp8.h
View File

@ -25,27 +25,27 @@ public:
pdp8_device(const machine_config &mconfig, const char *tag, device_t *owner, UINT32 clock);
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_stop();
virtual void device_start() override;
virtual void device_reset() override;
virtual void device_stop() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const;
virtual UINT32 execute_max_cycles() const;
virtual UINT32 execute_input_lines() const;
virtual void execute_run();
virtual void execute_set_input(int inputnum, int state);
virtual UINT32 execute_min_cycles() const override;
virtual UINT32 execute_max_cycles() const override;
virtual UINT32 execute_input_lines() const override;
virtual void execute_run() override;
virtual void execute_set_input(int inputnum, int state) override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const;
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const;
virtual UINT32 disasm_max_opcode_bytes() const;
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override;
virtual UINT32 disasm_max_opcode_bytes() const override;
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
// device_state_interface overrides
virtual void state_string_export(const device_state_entry &entry, std::string &str);
virtual void state_string_export(const device_state_entry &entry, std::string &str) override;
// address spaces
const address_space_config m_program_config;
@ -58,7 +58,7 @@ public:
WORD_COUNT,
CURRENT_ADDR,
BREAK
}
};
enum opcode
{
@ -70,7 +70,7 @@ public:
JMP,
IOT,
OPR
}
};
private:
// CPU registers
UINT16 m_pc;

32
src/devices/cpu/pic16c5x/pic16c5x.h
View File

@ -89,8 +89,8 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
/**************************************************************************
@ -100,29 +100,29 @@ protected:
* times. (Each instruction cycle passes through 4 machine states). This
* is handled by the cpu execution engine.
*/
virtual UINT64 execute_clocks_to_cycles(UINT64 clocks) const { return (clocks + 4 - 1) / 4; }
virtual UINT64 execute_cycles_to_clocks(UINT64 cycles) const { return (cycles * 4); }
virtual UINT32 execute_min_cycles() const { return 1; }
virtual UINT32 execute_max_cycles() const { return 2; }
virtual UINT32 execute_input_lines() const { return 1; }
virtual UINT32 execute_default_irq_vector() const { return 0; }
virtual void execute_run();
virtual UINT64 execute_clocks_to_cycles(UINT64 clocks) const override { return (clocks + 4 - 1) / 4; }
virtual UINT64 execute_cycles_to_clocks(UINT64 cycles) const override { return (cycles * 4); }
virtual UINT32 execute_min_cycles() const override { return 1; }
virtual UINT32 execute_max_cycles() const override { return 2; }
virtual UINT32 execute_input_lines() const override { return 1; }
virtual UINT32 execute_default_irq_vector() const override { return 0; }
virtual void execute_run() override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override
{
return (spacenum == AS_PROGRAM) ? &m_program_config : ( (spacenum == AS_DATA) ? &m_data_config : nullptr );
}
// device_state_interface overrides
virtual void state_import(const device_state_entry &entry);
virtual void state_export(const device_state_entry &entry);
void state_string_export(const device_state_entry &entry, std::string &str);
virtual void state_import(const device_state_entry &entry) override;
virtual void state_export(const device_state_entry &entry) override;
void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 2; }
virtual UINT32 disasm_max_opcode_bytes() const { return 2; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 2; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 2; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
private:
address_space_config m_program_config;

32
src/devices/cpu/pic16c62x/pic16c62x.h
View File

@ -67,33 +67,33 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT64 execute_clocks_to_cycles(UINT64 clocks) const { return (clocks + 4 - 1) / 4; }
virtual UINT64 execute_cycles_to_clocks(UINT64 cycles) const { return (cycles * 4); }
virtual UINT32 execute_min_cycles() const { return 1; }
virtual UINT32 execute_max_cycles() const { return 2; }
virtual UINT32 execute_input_lines() const { return 1; }
virtual UINT32 execute_default_irq_vector() const { return 0; }
virtual void execute_run();
virtual UINT64 execute_clocks_to_cycles(UINT64 clocks) const override { return (clocks + 4 - 1) / 4; }
virtual UINT64 execute_cycles_to_clocks(UINT64 cycles) const override { return (cycles * 4); }
virtual UINT32 execute_min_cycles() const override { return 1; }
virtual UINT32 execute_max_cycles() const override { return 2; }
virtual UINT32 execute_input_lines() const override { return 1; }
virtual UINT32 execute_default_irq_vector() const override { return 0; }
virtual void execute_run() override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override
{
return (spacenum == AS_PROGRAM) ? &m_program_config : ( (spacenum == AS_IO) ? &m_io_config : ( (spacenum == AS_DATA) ? &m_data_config : nullptr ) );
}
// device_state_interface overrides
virtual void state_import(const device_state_entry &entry);
virtual void state_export(const device_state_entry &entry);
void state_string_export(const device_state_entry &entry, std::string &str);
virtual void state_import(const device_state_entry &entry) override;
virtual void state_export(const device_state_entry &entry) override;
void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 2; }
virtual UINT32 disasm_max_opcode_bytes() const { return 2; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 2; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 2; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
private:
address_space_config m_program_config;

2
src/devices/cpu/powerpc/ppcfe.h
View File

@ -53,7 +53,7 @@ public:
protected:
// required overrides
virtual bool describe(opcode_desc &desc, const opcode_desc *prev);
virtual bool describe(opcode_desc &desc, const opcode_desc *prev) override;
private:
// inlines

24
src/devices/cpu/pps4/pps4.h
View File

@ -45,29 +45,29 @@ public:
protected:
// device-level overrides
virtual void device_start();
virtual void device_reset();
virtual void device_start() override;
virtual void device_reset() override;
// device_execute_interface overrides
virtual UINT32 execute_min_cycles() const { return 1; }
virtual UINT32 execute_max_cycles() const { return 3; }
virtual UINT32 execute_input_lines() const { return 0; }
virtual UINT32 execute_default_irq_vector() const { return 0; }
virtual void execute_run();
virtual UINT32 execute_min_cycles() const override { return 1; }
virtual UINT32 execute_max_cycles() const override { return 3; }
virtual UINT32 execute_input_lines() const override { return 0; }
virtual UINT32 execute_default_irq_vector() const override { return 0; }
virtual void execute_run() override;
// device_memory_interface overrides
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const
virtual const address_space_config *memory_space_config(address_spacenum spacenum = AS_0) const override
{
return (spacenum == AS_PROGRAM) ? &m_program_config : ( (spacenum == AS_IO) ? &m_io_config : ( (spacenum == AS_DATA) ? &m_data_config : nullptr ) );
}
// device_state_interface overrides
void state_string_export(const device_state_entry &entry, std::string &str);
void state_string_export(const device_state_entry &entry, std::string &str) override;
// device_disasm_interface overrides
virtual UINT32 disasm_min_opcode_bytes() const { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const { return 2; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options);
virtual UINT32 disasm_min_opcode_bytes() const override { return 1; }
virtual UINT32 disasm_max_opcode_bytes() const override { return 2; }
virtual offs_t disasm_disassemble(char *buffer, offs_t pc, const UINT8 *oprom, const UINT8 *opram, UINT32 options) override;
private:
address_space_config m_program_config;

8
src/devices/cpu/psx/dma.h
View File

@ -52,10 +52,10 @@ public:
size_t m_ramsize;
protected:
virtual void device_start();
virtual void device_reset();
virtual void device_post_load();
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr);
virtual void device_start() override;
virtual void device_reset() override;
virtual void device_post_load() override;
virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr) override;
private:
void dma_start_timer( int n_channel, UINT32 n_ticks );

Some files were not shown because too many files have changed in this diff Show More