cpu/saturn: clean up a little (nw)

scripts/src/cpu.lua

@@ -2031,8 +2031,8 @@ if (CPUS["SATURN"]~=null) then
 	files {
 		MAME_DIR .. "src/devices/cpu/saturn/saturn.cpp",
 		MAME_DIR .. "src/devices/cpu/saturn/saturn.h",
-		MAME_DIR .. "src/devices/cpu/saturn/satops.hxx",
+		MAME_DIR .. "src/devices/cpu/saturn/satops.ipp",
-		MAME_DIR .. "src/devices/cpu/saturn/sattable.hxx",
+		MAME_DIR .. "src/devices/cpu/saturn/sattable.ipp",
 	}
 end
 

src/devices/cpu/saturn/sattable.ipp

@@ -1,34 +1,46 @@
 // license:BSD-3-Clause
 // copyright-holders:Peter Trauner,Antoine Mine
+#define IRQ_ADDRESS 0xf
+
+#define BEGIN_B 0
+#define COUNT_B 2
+#define BEGIN_X 0
+#define COUNT_X 3
+#define BEGIN_XS 2
+#define COUNT_XS 1
+#define BEGIN_A 0
+#define COUNT_A 5
+#define BEGIN_M 3
+#define COUNT_M 12
+#define BEGIN_S 15
+#define COUNT_S 1
+#define BEGIN_W 0
+#define COUNT_W 16
+
+
 static const int adr_a_begin[]={
 		-1, -1, BEGIN_XS, BEGIN_X, BEGIN_S, BEGIN_M, BEGIN_B, BEGIN_W,
--1, -1, -1, -1,  -1, -1, -1, -1,
+		-1, -1, -1, -1,  -1, -1, -1, -1, };
-};
 
 static const int adr_a_count[]={
 		-1, -1, COUNT_XS, COUNT_X, COUNT_S, COUNT_M, COUNT_B, COUNT_W,
--1, -1, -1, -1,  -1, -1, -1, -1,
+		-1, -1, -1, -1,  -1, -1, -1, -1, };
-};
 
 static const int adr_b_begin[]={
 		-1, -1, -1, -1,  -1, -1, -1, -1,
--1, -1, BEGIN_XS, BEGIN_X, BEGIN_S, BEGIN_M, BEGIN_B, BEGIN_W,
+		-1, -1, BEGIN_XS, BEGIN_X, BEGIN_S, BEGIN_M, BEGIN_B, BEGIN_W, };
-};
 
 static const int adr_b_count[]={
 		-1, -1, -1, -1,  -1, -1, -1, -1,
--1, -1, COUNT_XS, COUNT_X, COUNT_S, COUNT_M, COUNT_B, COUNT_W,
+		-1, -1, COUNT_XS, COUNT_X, COUNT_S, COUNT_M, COUNT_B, COUNT_W, };
-};
 
 static const int adr_af_begin[]={
 		-1, -1, BEGIN_XS, BEGIN_X, BEGIN_S, BEGIN_M, BEGIN_B, BEGIN_W,
--1, -1, -1, -1, -1, -1, -1, BEGIN_A
+		-1, -1, -1, -1, -1, -1, -1, BEGIN_A };
-};
 
 static const int adr_af_count[]={
 		-1, -1, COUNT_XS, COUNT_X, COUNT_S, COUNT_M, COUNT_B, COUNT_W,
--1, -1, -1, -1, -1, -1, -1, COUNT_A
+		-1, -1, -1, -1, -1, -1, -1, COUNT_A };
-};
 
 static const int reg_left[] ={A,B,C,D, B,C,A,C, I,I,I,I, I,I,I,I};
 static const int reg_right[]={B,C,A,C, A,B,C,D, I,I,I,I, I,I,I,I};
@@ -39,26 +51,22 @@ static const int sub_right[]={B,C,A,C, I,I,I,I, A,B,C,D, B,C,A,C};
 
 void saturn_device::saturn_invalid3(int op1, int op2, int op3)
 {
-	logerror( "SATURN '%s' invalid opcode %x%x%x at %05x\n",
+	logerror("SATURN invalid opcode %x%x%x at %05x\n", op1, op2, op3, m_pc-3);
-			tag(), op1, op2, op3, m_pc-3 );
 }
 
 void saturn_device::saturn_invalid4(int op1, int op2, int op3, int op4)
 {
-	logerror( "SATURN '%s' invalid opcode %x%x%x%x at %05x\n",
+	logerror("SATURN invalid opcode %x%x%x%x at %05x\n", op1, op2, op3, op4, m_pc-4);
-			tag(), op1, op2, op3, op4, m_pc-4 );
 }
 
 void saturn_device::saturn_invalid5(int op1, int op2, int op3, int op4, int op5)
 {
-	logerror( "SATURN '%s' invalid opcode %x%x%x%x%x at %05x\n",
+	logerror("SATURN invalid opcode %x%x%x%x%x at %05x\n", op1, op2, op3, op4, op5, m_pc-5);
-			tag(), op1, op2, op3, op4, op5, m_pc-5 );
 }
 
 void saturn_device::saturn_invalid6(int op1, int op2, int op3, int op4, int op5, int op6)
 {
-	logerror( "SATURN '%s' invalid opcode %x%x%x%x%x%x at %05x\n",
+	logerror("SATURN invalid opcode %x%x%x%x%x%x at %05x\n", op1, op2, op3, op4, op5, op6, m_pc-6);
-			tag(), op1, op2, op3, op4, op5, op6, m_pc-6 );
 }
 
 
@@ -914,16 +922,16 @@ void saturn_device::saturn_instruction()
 	switch (READ_OP()) {
 	case 0:
 		switch (READ_OP()) {
-		case 0: saturn_return_xm_set();break;
+		case 0x0: saturn_return_xm_set();break;
-		case 1: saturn_return(1);break;
+		case 0x1: saturn_return(1);break;
-		case 2: saturn_return_carry_set();break;
+		case 0x2: saturn_return_carry_set();break;
-		case 3: saturn_return_carry_clear();break;
+		case 0x3: saturn_return_carry_clear();break;
-		case 4: saturn_sethex();break;
+		case 0x4: saturn_sethex();break;
-		case 5: saturn_setdec();break;
+		case 0x5: saturn_setdec();break;
-		case 6: saturn_push_c();break;
+		case 0x6: saturn_push_c();break;
-		case 7: saturn_pop_c();break;
+		case 0x7: saturn_pop_c();break;
-		case 8: saturn_clear_st();break;
+		case 0x8: saturn_clear_st();break;
-		case 9: saturn_st_to_c();break;
+		case 0x9: saturn_st_to_c();break;
 		case 0xa: saturn_c_to_st();break;
 		case 0xb: saturn_exchange_c_st();break;
 		case 0xc: saturn_inc_p();break;

src/devices/cpu/saturn/saturn.cpp

@@ -15,6 +15,10 @@
 #include "debugger.h"
 
 
+//#define VERBOSE 1
+#include "logmacro.h"
+
+
 #define R0 0
 #define R1 1
 #define R2 2
@@ -27,10 +31,6 @@
 #define I 9 // invalid
 
 
-//#define VERBOSE 1
-#include "logmacro.h"
-
-
 // Hardware status bits
 #define XM 1 // external Modules missing
 #define SB 2 // Sticky bit
@@ -52,16 +52,19 @@ saturn_device::saturn_device(const machine_config &mconfig, const char *tag, dev
 	, m_unconfig_func(*this)
 	, m_id_func(*this)
 	, m_crc_func(*this)
-	, m_rsi_func(*this), m_pc(0), m_oldpc(0), m_p(0), m_out(0), m_carry(0), m_decimal(0), m_st(0), m_hst(0), m_nmi_state(0), m_irq_state(0), m_irq_enable(0), m_in_irq(0),
+	, m_rsi_func(*this)
-	m_pending_irq(0), m_sleeping(0), m_monitor_id(0), m_monitor_in(0), m_program(nullptr), m_cache(nullptr), m_icount(0), m_debugger_temp(0)
+	, m_pc(0), m_oldpc(0), m_p(0), m_out(0), m_carry(0), m_decimal(0), m_st(0), m_hst(0)
+	, m_nmi_state(0), m_irq_state(0), m_irq_enable(0), m_in_irq(0), m_pending_irq(0)
+	, m_sleeping(0), m_monitor_id(0), m_monitor_in(0)
+	, m_program(nullptr), m_cache(nullptr)
+	, m_icount(0)
+	, m_debugger_temp(0)
 {
 }
 
 device_memory_interface::space_config_vector saturn_device::memory_space_config() const
 {
-	return space_config_vector {
+	return space_config_vector{ std::make_pair(AS_PROGRAM, &m_program_config) };
-		std::make_pair(AS_PROGRAM, &m_program_config)
-	};
 }
 
 bool saturn_device::get_nonstandard_mnemonics_mode() const
@@ -81,8 +84,8 @@ std::unique_ptr<util::disasm_interface> saturn_device::create_disassembler()
  * include the opcode macros, functions and tables
  ***************************************************************/
 
-#include "satops.hxx"
+#include "satops.ipp"
-#include "sattable.hxx"
+#include "sattable.ipp"
 
 /*****************************************************************************
  *

src/devices/cpu/saturn/saturn.h

@@ -146,122 +146,122 @@ typedef uint8_t Saturn64[16];
 	void IntReg64(Saturn64 r, int64_t d);
 	int64_t Reg64Int(Saturn64 r);
 
-	inline int READ_OP();
+	int READ_OP();
-	inline int READ_OP_ARG();
+	int READ_OP_ARG();
-	inline int READ_OP_ARG8();
+	int READ_OP_ARG8();
-	inline int8_t READ_OP_DIS8();
+	int8_t READ_OP_DIS8();
-	inline int READ_OP_ARG12();
+	int READ_OP_ARG12();
-	inline int READ_OP_DIS12();
+	int READ_OP_DIS12();
-	inline int READ_OP_ARG16();
+	int READ_OP_ARG16();
-	inline int16_t READ_OP_DIS16();
+	int16_t READ_OP_DIS16();
-	inline int READ_OP_ARG20();
+	int READ_OP_ARG20();
-	inline int READ_NIBBLE(uint32_t adr);
+	int READ_NIBBLE(uint32_t adr);
-	inline int READ_8(uint32_t adr);
+	int READ_8(uint32_t adr);
-	inline int READ_12(uint32_t adr);
+	int READ_12(uint32_t adr);
-	inline int READ_16(uint32_t adr);
+	int READ_16(uint32_t adr);
-	inline int READ_20(uint32_t adr);
+	int READ_20(uint32_t adr);
-	inline void WRITE_NIBBLE(uint32_t adr, uint8_t nib);
+	void WRITE_NIBBLE(uint32_t adr, uint8_t nib);
-	inline int S64_READ_X(int r);
+	int S64_READ_X(int r);
-	inline int S64_READ_WORD(int r);
+	int S64_READ_WORD(int r);
-	inline int S64_READ_A(int r);
+	int S64_READ_A(int r);
-	inline void S64_WRITE_X(int r, int v);
+	void S64_WRITE_X(int r, int v);
-	inline void S64_WRITE_WORD(int r, int v);
+	void S64_WRITE_WORD(int r, int v);
-	inline void S64_WRITE_A(int r, int v);
+	void S64_WRITE_A(int r, int v);
-	inline uint32_t saturn_pop();
+	uint32_t saturn_pop();
-	inline void saturn_push(uint32_t adr);
+	void saturn_push(uint32_t adr);
-	inline void saturn_interrupt_on();
+	void saturn_interrupt_on();
-	inline void saturn_interrupt_off();
+	void saturn_interrupt_off();
-	inline void saturn_reset_interrupt();
+	void saturn_reset_interrupt();
-	inline void saturn_mem_reset();
+	void saturn_mem_reset();
-	inline void saturn_mem_config();
+	void saturn_mem_config();
-	inline void saturn_mem_unconfig();
+	void saturn_mem_unconfig();
-	inline void saturn_mem_id();
+	void saturn_mem_id();
-	inline void saturn_shutdown();
+	void saturn_shutdown();
-	inline void saturn_bus_command_b();
+	void saturn_bus_command_b();
-	inline void saturn_bus_command_c();
+	void saturn_bus_command_c();
-	inline void saturn_bus_command_d();
+	void saturn_bus_command_d();
-	inline void saturn_serial_request();
+	void saturn_serial_request();
-	inline void saturn_out_c();
+	void saturn_out_c();
-	inline void saturn_out_cs();
+	void saturn_out_cs();
-	inline void saturn_in(int reg);
+	void saturn_in(int reg);
-	inline void saturn_sethex() { m_decimal=0; }
+	void saturn_sethex() { m_decimal=0; }
-	inline void saturn_setdec() { m_decimal=1; }
+	void saturn_setdec() { m_decimal=1; }
-	inline void saturn_clear_st();
+	void saturn_clear_st();
-	inline void saturn_st_to_c();
+	void saturn_st_to_c();
-	inline void saturn_c_to_st();
+	void saturn_c_to_st();
-	inline void saturn_exchange_c_st();
+	void saturn_exchange_c_st();
-	inline void saturn_jump_after_test();
+	void saturn_jump_after_test();
-	inline void saturn_st_clear_bit();
+	void saturn_st_clear_bit();
-	inline void saturn_st_set_bit();
+	void saturn_st_set_bit();
-	inline void saturn_st_jump_bit_clear();
+	void saturn_st_jump_bit_clear();
-	inline void saturn_st_jump_bit_set();
+	void saturn_st_jump_bit_set();
-	inline void saturn_hst_clear_bits();
+	void saturn_hst_clear_bits();
-	inline void saturn_hst_bits_cleared();
+	void saturn_hst_bits_cleared();
-	inline void saturn_exchange_p();
+	void saturn_exchange_p();
-	inline void saturn_p_to_c();
+	void saturn_p_to_c();
-	inline void saturn_c_to_p();
+	void saturn_c_to_p();
-	inline void saturn_dec_p();
+	void saturn_dec_p();
-	inline void saturn_inc_p();
+	void saturn_inc_p();
-	inline void saturn_load_p();
+	void saturn_load_p();
-	inline void saturn_p_equals();
+	void saturn_p_equals();
-	inline void saturn_p_not_equals();
+	void saturn_p_not_equals();
-	inline void saturn_ca_p_1();
+	void saturn_ca_p_1();
-	inline void saturn_load_reg(int reg);
+	void saturn_load_reg(int reg);
-	inline void saturn_jump(int adr, int jump);
+	void saturn_jump(int adr, int jump);
-	inline void saturn_call(int adr);
+	void saturn_call(int adr);
-	inline void saturn_return(int yes);
+	void saturn_return(int yes);
-	inline void saturn_return_carry_set();
+	void saturn_return_carry_set();
-	inline void saturn_return_carry_clear();
+	void saturn_return_carry_clear();
-	inline void saturn_return_interrupt();
+	void saturn_return_interrupt();
-	inline void saturn_return_xm_set();
+	void saturn_return_xm_set();
-	inline void saturn_pop_c();
+	void saturn_pop_c();
-	inline void saturn_push_c();
+	void saturn_push_c();
-	inline void saturn_indirect_jump(int reg);
+	void saturn_indirect_jump(int reg);
-	inline void saturn_equals_zero(int reg, int begin, int count);
+	void saturn_equals_zero(int reg, int begin, int count);
-	inline void saturn_equals(int reg, int begin, int count, int right);
+	void saturn_equals(int reg, int begin, int count, int right);
-	inline void saturn_not_equals_zero(int reg, int begin, int count);
+	void saturn_not_equals_zero(int reg, int begin, int count);
-	inline void saturn_not_equals(int reg, int begin, int count, int right);
+	void saturn_not_equals(int reg, int begin, int count, int right);
-	inline void saturn_greater(int reg, int begin, int count, int right);
+	void saturn_greater(int reg, int begin, int count, int right);
-	inline void saturn_greater_equals(int reg, int begin, int count, int right);
+	void saturn_greater_equals(int reg, int begin, int count, int right);
-	inline void saturn_smaller_equals(int reg, int begin, int count, int right);
+	void saturn_smaller_equals(int reg, int begin, int count, int right);
-	inline void saturn_smaller(int reg, int begin, int count, int right);
+	void saturn_smaller(int reg, int begin, int count, int right);
-	inline void saturn_jump_bit_clear(int reg);
+	void saturn_jump_bit_clear(int reg);
-	inline void saturn_jump_bit_set(int reg);
+	void saturn_jump_bit_set(int reg);
-	inline void saturn_load_pc(int reg);
+	void saturn_load_pc(int reg);
-	inline void saturn_store_pc(int reg);
+	void saturn_store_pc(int reg);
-	inline void saturn_exchange_pc(int reg);
+	void saturn_exchange_pc(int reg);
-	inline void saturn_load_adr(int reg, int nibbles);
+	void saturn_load_adr(int reg, int nibbles);
-	inline void saturn_add_adr(int reg);
+	void saturn_add_adr(int reg);
-	inline void saturn_sub_adr(int reg);
+	void saturn_sub_adr(int reg);
-	inline void saturn_adr_to_reg(int adr, int reg);
+	void saturn_adr_to_reg(int adr, int reg);
-	inline void saturn_reg_to_adr(int reg, int adr);
+	void saturn_reg_to_adr(int reg, int adr);
-	inline void saturn_adr_to_reg_word(int adr, int reg);
+	void saturn_adr_to_reg_word(int adr, int reg);
-	inline void saturn_reg_to_adr_word(int reg, int adr);
+	void saturn_reg_to_adr_word(int reg, int adr);
-	inline void saturn_exchange_adr_reg(int adr, int reg);
+	void saturn_exchange_adr_reg(int adr, int reg);
-	inline void saturn_exchange_adr_reg_word(int adr, int reg);
+	void saturn_exchange_adr_reg_word(int adr, int reg);
-	inline void saturn_load_nibbles(int reg, int begin, int count, int adr);
+	void saturn_load_nibbles(int reg, int begin, int count, int adr);
-	inline void saturn_store_nibbles(int reg, int begin, int count, int adr);
+	void saturn_store_nibbles(int reg, int begin, int count, int adr);
-	inline void saturn_clear_bit(int reg);
+	void saturn_clear_bit(int reg);
-	inline void saturn_set_bit(int reg);
+	void saturn_set_bit(int reg);
-	inline void saturn_clear(int reg, int begin, int count);
+	void saturn_clear(int reg, int begin, int count);
-	inline void saturn_exchange(int left, int begin, int count, int right);
+	void saturn_exchange(int left, int begin, int count, int right);
-	inline void saturn_copy(int dest, int begin, int count, int src);
+	void saturn_copy(int dest, int begin, int count, int src);
-	inline void saturn_add(int reg, int begin, int count, int right);
+	void saturn_add(int reg, int begin, int count, int right);
-	inline void saturn_add_const(int reg, int begin, int count, uint8_t right);
+	void saturn_add_const(int reg, int begin, int count, uint8_t right);
-	inline void saturn_sub(int reg, int begin, int count, int right);
+	void saturn_sub(int reg, int begin, int count, int right);
-	inline void saturn_sub_const(int reg, int begin, int count, int right);
+	void saturn_sub_const(int reg, int begin, int count, int right);
-	inline void saturn_sub2(int reg, int begin, int count, int right);
+	void saturn_sub2(int reg, int begin, int count, int right);
-	inline void saturn_increment(int reg, int begin, int count);
+	void saturn_increment(int reg, int begin, int count);
-	inline void saturn_decrement(int reg, int begin, int count);
+	void saturn_decrement(int reg, int begin, int count);
-	inline void saturn_invert(int reg, int begin, int count);
+	void saturn_invert(int reg, int begin, int count);
-	inline void saturn_negate(int reg, int begin, int count);
+	void saturn_negate(int reg, int begin, int count);
-	inline void saturn_or(int dest, int begin, int count, int src);
+	void saturn_or(int dest, int begin, int count, int src);
-	inline void saturn_and(int dest, int begin, int count, int src);
+	void saturn_and(int dest, int begin, int count, int src);
-	inline void saturn_shift_nibble_left(int reg, int begin, int count);
+	void saturn_shift_nibble_left(int reg, int begin, int count);
-	inline void saturn_shift_nibble_right(int reg, int begin, int count);
+	void saturn_shift_nibble_right(int reg, int begin, int count);
-	inline void saturn_rotate_nibble_left_w(int reg);
+	void saturn_rotate_nibble_left_w(int reg);
-	inline void saturn_rotate_nibble_right_w(int reg);
+	void saturn_rotate_nibble_right_w(int reg);
-	inline void saturn_shift_right(int reg, int begin, int count);
+	void saturn_shift_right(int reg, int begin, int count);
 	void saturn_invalid3(int op1, int op2, int op3);
 	void saturn_invalid4(int op1, int op2, int op3, int op4);
 	void saturn_invalid5(int op1, int op2, int op3, int op4, int op5);