diff options
Diffstat (limited to 'src/devices/cpu/saturn/satops.hxx')
-rw-r--r-- | src/devices/cpu/saturn/satops.hxx | 1151 |
1 files changed, 0 insertions, 1151 deletions
diff --git a/src/devices/cpu/saturn/satops.hxx b/src/devices/cpu/saturn/satops.hxx deleted file mode 100644 index 8a1ecfe1c1d..00000000000 --- a/src/devices/cpu/saturn/satops.hxx +++ /dev/null @@ -1,1151 +0,0 @@ -// license:BSD-3-Clause -// copyright-holders:Peter Trauner,Antoine Mine -#define IRQ_ADDRESS 0xf - -#define saturn_assert(x) \ - do { if (!(x)) logerror("SATURN assertion failed: %s at %s:%i, pc=%05x\n", #x, __FILE__, __LINE__, m_pc); } while (0) - -int saturn_device::READ_OP() -{ - uint8_t data; - m_icount-=3; - data=m_cache->read_byte(m_pc); - saturn_assert(data<0x10); - m_pc=(m_pc+1)&0xfffff; - return data; -} - -int saturn_device::READ_OP_ARG() -{ - uint8_t data; - m_icount-=3; - data=m_cache->read_byte(m_pc); - saturn_assert(data<0x10); - m_pc=(m_pc+1)&0xfffff; - return data; -} - -int saturn_device::READ_OP_ARG8() -{ - int n0=READ_OP_ARG(); - int n1=READ_OP_ARG(); - return n0|(n1<<4); -} - -int8_t saturn_device::READ_OP_DIS8() -{ - return (int8_t)READ_OP_ARG8(); -} - -int saturn_device::READ_OP_ARG12() -{ - int n0=READ_OP_ARG(); - int n1=READ_OP_ARG(); - int n2=READ_OP_ARG(); - return n0|(n1<<4)|(n2<<8); -} - -int saturn_device::READ_OP_DIS12() -{ - int temp=READ_OP_ARG12(); - if (temp&0x800) temp-=0x1000; - return temp; -} - -int saturn_device::READ_OP_ARG16() -{ - int n0=READ_OP_ARG(); - int n1=READ_OP_ARG(); - int n2=READ_OP_ARG(); - int n3=READ_OP_ARG(); - return n0|(n1<<4)|(n2<<8)|(n3<<12); -} - -int16_t saturn_device::READ_OP_DIS16() -{ - return (int16_t)READ_OP_ARG16(); -} - -int saturn_device::READ_OP_ARG20() -{ - int n0=READ_OP_ARG(); - int n1=READ_OP_ARG(); - int n2=READ_OP_ARG(); - int n3=READ_OP_ARG(); - int n4=READ_OP_ARG(); - return n0|(n1<<4)|(n2<<8)|(n3<<12)|(n4<<16); -} - -int saturn_device::READ_NIBBLE(uint32_t adr) -{ - uint8_t data; - m_icount-=3; - data=m_program->read_byte(adr&0xfffff); - saturn_assert(data<0x10); - m_crc_func(adr&0xfffff, data, 0xffffffff); - return data; -} - -int saturn_device::READ_8(uint32_t adr) -{ - int n0=READ_NIBBLE(adr); - int n1=READ_NIBBLE(adr+1); - return n0|(n1<<4); -} - -int saturn_device::READ_12(uint32_t adr) -{ - int n0=READ_NIBBLE(adr); - int n1=READ_NIBBLE(adr+1); - int n2=READ_NIBBLE(adr+2); - return n0|(n1<<4)|(n2<<8); -} - -int saturn_device::READ_16(uint32_t adr) -{ - int n0=READ_NIBBLE(adr); - int n1=READ_NIBBLE(adr+1); - int n2=READ_NIBBLE(adr+2); - int n3=READ_NIBBLE(adr+3); - return n0|(n1<<4)|(n2<<8)|(n3<<12); -} - -int saturn_device::READ_20(uint32_t adr) -{ - int n0=READ_NIBBLE(adr); - int n1=READ_NIBBLE(adr+1); - int n2=READ_NIBBLE(adr+2); - int n3=READ_NIBBLE(adr+3); - int n4=READ_NIBBLE(adr+4); - return n0|(n1<<4)|(n2<<8)|(n3<<12)|(n4<<16); -} - -void saturn_device::WRITE_NIBBLE(uint32_t adr, uint8_t nib) -{ - m_icount-=3; - saturn_assert(nib<0x10); - m_program->write_byte(adr&0xfffff,nib); -} - -#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 - - -int saturn_device::S64_READ_X(int r) -{ - return m_reg[r][0]|(m_reg[r][1]<<4)|(m_reg[r][2]<<8); -} - -int saturn_device::S64_READ_WORD(int r) -{ - return m_reg[r][0]|(m_reg[r][1]<<4)|(m_reg[r][2]<<8)|(m_reg[r][3]<<12); -} - -int saturn_device::S64_READ_A(int r) -{ - return m_reg[r][0]|(m_reg[r][1]<<4)|(m_reg[r][2]<<8)|(m_reg[r][3]<<12)|(m_reg[r][4]<<16); -} - -void saturn_device::S64_WRITE_X(int r, int v) -{ - m_reg[r][0]=v&0xf; - m_reg[r][1]=(v>>4)&0xf; - m_reg[r][2]=(v>>8)&0xf; -} - -void saturn_device::S64_WRITE_WORD(int r, int v) -{ - m_reg[r][0]=v&0xf; - m_reg[r][1]=(v>>4)&0xf; - m_reg[r][2]=(v>>8)&0xf; - m_reg[r][3]=(v>>12)&0xf; -} - -void saturn_device::S64_WRITE_A(int r, int v) -{ - m_reg[r][0]=v&0xf; - m_reg[r][1]=(v>>4)&0xf; - m_reg[r][2]=(v>>8)&0xf; - m_reg[r][3]=(v>>12)&0xf; - m_reg[r][4]=(v>>16)&0xf; -} - - - - - -uint32_t saturn_device::saturn_pop() -{ - uint32_t temp=m_rstk[0]; - memmove(m_rstk, m_rstk+1, sizeof(m_rstk)-sizeof(m_rstk[0])); - m_rstk[7]=0; - return temp; -} - -void saturn_device::saturn_push(uint32_t adr) -{ - memmove(m_rstk+1, m_rstk, sizeof(m_rstk)-sizeof(m_rstk[0])); - m_rstk[0]=adr; -} - -void saturn_device::saturn_interrupt_on() -{ - LOG("SATURN at %05x: INTON\n", m_pc-4); - m_irq_enable=1; - if (m_irq_state) - { - LOG("SATURN set_irq_line(ASSERT)\n"); - m_pending_irq=1; - } -} - -void saturn_device::saturn_interrupt_off() -{ - LOG("SATURN at %05x: INTOFF\n", m_pc-4); - m_irq_enable=0; -} - -void saturn_device::saturn_reset_interrupt() -{ - LOG("SATURN at %05x: RSI\n", m_pc-5); - m_rsi_func(ASSERT_LINE); -} - -void saturn_device::saturn_mem_reset() -{ - m_reset_func(ASSERT_LINE); -} - -void saturn_device::saturn_mem_config() -{ - m_config_func(S64_READ_A(C)); -} - -void saturn_device::saturn_mem_unconfig() -{ - m_unconfig_func(S64_READ_A(C)); -} - -void saturn_device::saturn_mem_id() -{ - int id=0; - id = m_id_func(); - S64_WRITE_A(C,id); - m_monitor_id = id; -} - -void saturn_device::saturn_shutdown() -{ - m_sleeping=1; - m_irq_enable=1; - LOG("SATURN at %05x: SHUTDN\n", m_pc-3); -} - -void saturn_device::saturn_bus_command_b() -{ - logerror( "SATURN '%s' at %05x: BUSCB opcode not handled\n", tag(), m_pc-4 ); -} - -void saturn_device::saturn_bus_command_c() -{ - logerror( "SATURN '%s' at %05x: BUSCC opcode not handled\n", tag(), m_pc-3 ); -} - -void saturn_device::saturn_bus_command_d() -{ - logerror( "SATURN '%s' at %05x: BUSCD opcode not handled\n", tag(), m_pc-4 ); -} - -void saturn_device::saturn_serial_request() -{ - logerror( "SATURN '%s' at %05x: SREQ? opcode not handled\n", tag(), m_pc-3 ); -} - -void saturn_device::saturn_out_c() -{ - m_out=S64_READ_X(C); - m_out_func(m_out); -} - -void saturn_device::saturn_out_cs() -{ - m_out=(m_out&0xff0)|m_reg[C][0]; - m_out_func(m_out); -} - -void saturn_device::saturn_in(int reg) -{ - int in = 0; - saturn_assert(reg>=0 && reg<9); - if (!(m_pc&1)) - logerror( "SATURN '%s' at %05x: reg=IN opcode at odd addresse\n", - tag(), m_pc-3 ); - in = m_in_func(); - S64_WRITE_WORD(reg,in); - m_monitor_in = in; -} - - -/* st related */ -void saturn_device::saturn_clear_st() -{ - m_st&=0xf000; -} - -void saturn_device::saturn_st_to_c() -{ - S64_WRITE_X(C,m_st); -} - -void saturn_device::saturn_c_to_st() -{ - m_st=(m_st&0xf000)|(S64_READ_X(C)); -} - -void saturn_device::saturn_exchange_c_st() -{ - int t=m_st; - m_st=(t&0xf000)|(S64_READ_X(C)); - S64_WRITE_X(C,t); -} - -void saturn_device::saturn_jump_after_test() -{ - int adr=READ_OP_DIS8(); - if (m_carry) { - if (adr==0) { - m_pc=saturn_pop(); - } else { - m_pc=(m_pc+adr-2)&0xfffff; - } - } -} -void saturn_device::saturn_st_clear_bit() -{ - m_st &= ~(1<<(READ_OP_ARG())); -} - -void saturn_device::saturn_st_set_bit() -{ - m_st |= (1<<(READ_OP_ARG())); -} - -void saturn_device::saturn_st_jump_bit_clear() -{ - m_carry=!((m_st>>(READ_OP_ARG()))&1); - saturn_jump_after_test(); -} - -void saturn_device::saturn_st_jump_bit_set() -{ - m_carry=(m_st>>(READ_OP_ARG()))&1; - saturn_jump_after_test(); -} - -void saturn_device::saturn_hst_clear_bits() -{ - m_hst&=~(READ_OP_ARG()); -} - -void saturn_device::saturn_hst_bits_cleared() -{ - m_carry=!(m_hst&(READ_OP_ARG())); - saturn_jump_after_test(); -} - -/* p related */ -void saturn_device::saturn_exchange_p() -{ - int nr=READ_OP_ARG(); - int t=m_p; - m_p=m_reg[C][nr]; - m_reg[C][nr]=t; -} - -void saturn_device::saturn_p_to_c() -{ - int nr=READ_OP_ARG(); - m_reg[C][nr]=m_p; -} - -void saturn_device::saturn_c_to_p() -{ - int nr=READ_OP_ARG(); - m_p=m_reg[C][nr]; -} - -void saturn_device::saturn_dec_p() -{ - m_carry=m_p==0; - m_p=(m_p-1)&0xf; -} - -void saturn_device::saturn_inc_p() -{ - m_p=(m_p+1)&0xf; - m_carry=m_p==0; -} - -void saturn_device::saturn_load_p() -{ - m_p=READ_OP_ARG(); -} - -void saturn_device::saturn_p_equals() -{ - m_carry=m_p==(READ_OP_ARG()); - saturn_jump_after_test(); -} - -void saturn_device::saturn_p_not_equals() -{ - m_carry=m_p!=(READ_OP_ARG()); - saturn_jump_after_test(); -} - -void saturn_device::saturn_ca_p_1() -{ - int a=(S64_READ_A(C))+1+m_p; - m_carry=a>=0x100000; - S64_WRITE_A(C,a&0xfffff); -} - -void saturn_device::saturn_load_reg(int reg) -{ - int count=READ_OP_ARG(); - int pos=m_p; - saturn_assert(reg>=0 && reg<9); - for (; count>=0; count--, pos=(pos+1)&0xf ) { - m_reg[reg][pos]=READ_OP_ARG(); - } -} - -void saturn_device::saturn_jump(int adr, int jump) -{ - saturn_assert(adr>=0 && adr<0x100000); - if (jump) { - m_pc=adr; - m_icount-=10; - } -} - -void saturn_device::saturn_call(int adr) -{ - saturn_assert(adr>=0 && adr<0x100000); - saturn_push(m_pc); - m_pc=adr; -// m_icount-=10; -} - -void saturn_device::saturn_return(int yes) -{ - if (yes) { - m_pc=saturn_pop(); -// m_icount-=10; - } -} - -void saturn_device::saturn_return_carry_set() -{ - m_pc=saturn_pop(); -// m_icount-=10; - m_carry=1; -} - -void saturn_device::saturn_return_carry_clear() -{ - m_pc=saturn_pop(); -// m_icount-=10; - m_carry=0; -} - -void saturn_device::saturn_return_interrupt() -{ - LOG("SATURN at %05x: RTI\n", tag(), m_pc-2); - m_in_irq=0; /* set to 1 when an IRQ is taken */ - m_pc=saturn_pop(); -// m_icount-=10; -} - -void saturn_device::saturn_return_xm_set() -{ - m_pc=saturn_pop(); - m_hst|=XM; -// m_icount-=10; -} - -void saturn_device::saturn_pop_c() -{ - S64_WRITE_A(C,saturn_pop()); -} - -void saturn_device::saturn_push_c() -{ - saturn_push(S64_READ_A(C)); -} - -void saturn_device::saturn_indirect_jump(int reg) -{ - saturn_assert(reg>=0 && reg<9); - m_pc=READ_20(S64_READ_A(reg)); -} - -void saturn_device::saturn_equals_zero(int reg, int begin, int count) -{ - int i, t; - saturn_assert(reg>=0 && reg<9); - saturn_assert(begin>=0 && begin<16 && count>0 && begin+count<=16); - m_carry=1; - for (i=0; i<count; i++) { - t=m_reg[reg][begin+i]; - if (t!=0) { m_carry=0; break; } - m_icount-=2; - } - saturn_jump_after_test(); -} - -void saturn_device::saturn_equals(int reg, int begin, int count, int right) -{ - int i, t,t2; - saturn_assert(reg>=0 && reg<9); - saturn_assert(right>=0 && right<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - m_carry=1; - for (i=0; i<count; i++) { - t=m_reg[reg][begin+i]; - t2=m_reg[right][begin+i]; - if (t!=t2) { m_carry=0; break; } - m_icount-=2; - } - saturn_jump_after_test(); -} - -void saturn_device::saturn_not_equals_zero(int reg, int begin, int count) -{ - int i, t; - saturn_assert(reg>=0 && reg<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - m_carry=0; - for (i=0; i<count; i++) { - t=m_reg[reg][begin+i]; - if (t!=0) { m_carry=1; break; } - m_icount-=2; - } - saturn_jump_after_test(); -} - -void saturn_device::saturn_not_equals(int reg, int begin, int count, int right) -{ - int i, t,t2; - saturn_assert(reg>=0 && reg<9); - saturn_assert(right>=0 && right<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - m_carry=0; - for (i=0; i<count; i++) { - t=m_reg[reg][begin+i]; - t2=m_reg[right][begin+i]; - if (t!=t2) { m_carry=1; break; } - m_icount-=2; - } - saturn_jump_after_test(); -} - -void saturn_device::saturn_greater(int reg, int begin, int count, int right) -{ - int i, t,t2; - saturn_assert(reg>=0 && reg<9); - saturn_assert(right>=0 && right<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - m_carry=0; - for (i=count-1; i>=0; i--) { - t=m_reg[reg][begin+i]; - t2=m_reg[right][begin+i]; - if (t>t2) { m_carry=1; break; } - if (t<t2) break; - m_icount-=2; - } - saturn_jump_after_test(); -} - -void saturn_device::saturn_greater_equals(int reg, int begin, int count, int right) -{ - int i, t,t2; - saturn_assert(reg>=0 && reg<9); - saturn_assert(right>=0 && right<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - m_carry=1; - for (i=count-1; i>=0; i--) { - t=m_reg[reg][begin+i]; - t2=m_reg[right][begin+i]; - if (t<t2) { m_carry=0; break; } - if (t>t2) break; - m_icount-=2; - } - saturn_jump_after_test(); -} - -void saturn_device::saturn_smaller_equals(int reg, int begin, int count, int right) -{ - int i, t,t2; - saturn_assert(reg>=0 && reg<9); - saturn_assert(right>=0 && right<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - m_carry=1; - for (i=count-1; i>=0; i--) { - t=m_reg[reg][begin+i]; - t2=m_reg[right][begin+i]; - if (t>t2) { m_carry=0; break; } - if (t<t2) break; - m_icount-=2; - } - saturn_jump_after_test(); -} - -void saturn_device::saturn_smaller(int reg, int begin, int count, int right) -{ - int i, t,t2; - saturn_assert(reg>=0 && reg<9); - saturn_assert(right>=0 && right<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - m_carry=0; - for (i=count-1; i>=0; i--) { - t=m_reg[reg][begin+i]; - t2=m_reg[right][begin+i]; - if (t<t2) { m_carry=1; break; } - if (t>t2) break; - m_icount-=2; - } - saturn_jump_after_test(); -} - -void saturn_device::saturn_jump_bit_clear(int reg) -{ - int op=READ_OP_ARG(); - saturn_assert(reg>=0 && reg<9); - m_carry=!((m_reg[reg][op>>2]>>(op&3))&1); - saturn_jump_after_test(); -} - -void saturn_device::saturn_jump_bit_set(int reg) -{ - int op=READ_OP_ARG(); - saturn_assert(reg>=0 && reg<9); - m_carry=(m_reg[reg][op>>2]>>(op&3))&1; - saturn_jump_after_test(); -} - -void saturn_device::saturn_load_pc(int reg) -{ - saturn_assert(reg>=0 && reg<9); - m_pc=S64_READ_A(reg); -} - -void saturn_device::saturn_store_pc(int reg) -{ - saturn_assert(reg>=0 && reg<9); - S64_WRITE_A(reg,m_pc); -} - -void saturn_device::saturn_exchange_pc(int reg) -{ - int temp=m_pc; - saturn_assert(reg>=0 && reg<9); - m_pc=S64_READ_A(reg); - S64_WRITE_A(reg, temp); -} - -/************************************************************************************* - address register related -*************************************************************************************/ -void saturn_device::saturn_load_adr(int reg, int nibbles) -{ - saturn_assert(reg>=0 && reg<2); - saturn_assert(nibbles==2 || nibbles==4 || nibbles==5); - switch (nibbles) { - case 5: - m_d[reg]=READ_OP_ARG20(); - break; - case 4: - m_d[reg]=(m_d[reg]&0xf0000)|READ_OP_ARG16(); - break; - case 2: - m_d[reg]=(m_d[reg]&0xfff00)|READ_OP_ARG8(); - break; - } -} - -void saturn_device::saturn_add_adr(int reg) -{ - int t=m_d[reg]+READ_OP_ARG()+1; - saturn_assert(reg>=0 && reg<2); - m_d[reg]=t&0xfffff; - m_carry=t>=0x100000; -} - -void saturn_device::saturn_sub_adr(int reg) -{ - int t=m_d[reg]-READ_OP_ARG()-1; - saturn_assert(reg>=0 && reg<2); - m_d[reg]=t&0xfffff; - m_carry=t<0; -} - -void saturn_device::saturn_adr_to_reg(int adr, int reg) -{ - saturn_assert(reg>=0 && reg<9); - saturn_assert(adr>=0 && adr<2); - S64_WRITE_A(reg,m_d[adr]); -} - -void saturn_device::saturn_reg_to_adr(int reg, int adr) -{ - saturn_assert(reg>=0 && reg<9); - saturn_assert(adr>=0 && adr<2); - m_d[adr]=S64_READ_A(reg); -} - -void saturn_device::saturn_adr_to_reg_word(int adr, int reg) -{ - saturn_assert(reg>=0 && reg<9); - saturn_assert(adr>=0 && adr<2); - S64_WRITE_WORD(reg,m_d[adr]&0xffff); -} - -void saturn_device::saturn_reg_to_adr_word(int reg, int adr) -{ - saturn_assert(reg>=0 && reg<9); - saturn_assert(adr>=0 && adr<2); - m_d[adr]=(m_d[adr]&0xf0000)|S64_READ_WORD(reg); -} - -void saturn_device::saturn_exchange_adr_reg(int adr, int reg) -{ - int temp=m_d[adr]; - saturn_assert(reg>=0 && reg<9); - saturn_assert(adr>=0 && adr<2); - m_d[adr]=S64_READ_A(reg); - S64_WRITE_A(reg,temp); -} - -void saturn_device::saturn_exchange_adr_reg_word(int adr, int reg) -{ - int temp=m_d[adr]&0xffff; - saturn_assert(reg>=0 && reg<9); - saturn_assert(adr>=0 && adr<2); - m_d[adr]=(m_d[adr]&0xf0000)|S64_READ_WORD(reg); - S64_WRITE_WORD(reg,temp); -} - -void saturn_device::saturn_load_nibbles(int reg, int begin, int count, int adr) -{ - int i; - saturn_assert(reg>=0 && reg<9); - saturn_assert(adr>=0 && adr<2); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - for (i=0; i<count; i++) { - m_reg[reg][begin+i]=READ_NIBBLE(m_d[adr]+i); - m_icount-=2; - } -} - -void saturn_device::saturn_store_nibbles(int reg, int begin, int count, int adr) -{ - int i; - saturn_assert(reg>=0 && reg<9); - saturn_assert(adr>=0 && adr<2); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - for (i=0; i<count; i++) { - WRITE_NIBBLE((m_d[adr]+i)&0xfffff,m_reg[reg][begin+i]); - m_icount-=2; - } -} - -void saturn_device::saturn_clear_bit(int reg) -{ - int arg=READ_OP_ARG(); - saturn_assert(reg>=0 && reg<9); - m_reg[reg][arg>>2]&=~(1<<(arg&3)); -} - -void saturn_device::saturn_set_bit(int reg) -{ - int arg=READ_OP_ARG(); - saturn_assert(reg>=0 && reg<9); - m_reg[reg][arg>>2]|=1<<(arg&3); -} - -/**************************************************************************** - clear opers - ****************************************************************************/ -void saturn_device::saturn_clear(int reg, int begin, int count) -{ - int i; - saturn_assert(reg>=0 && reg<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - for (i=0; i<count; i++) { - m_reg[reg][begin+i]=0; - m_icount-=2; - } -} - -/**************************************************************************** - exchange opers - ****************************************************************************/ -void saturn_device::saturn_exchange(int left, int begin, int count, int right) -{ - int i; - uint8_t temp; - saturn_assert(left>=0 && left<9); - saturn_assert(right>=0 && right<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - for (i=0; i<count; i++) { - temp=m_reg[left][begin+i]; - m_reg[left][begin+i]=m_reg[right][begin+i]; - m_reg[right][begin+i]=temp; - m_icount-=2; - } -} - -/**************************************************************************** - copy opers - ****************************************************************************/ -void saturn_device::saturn_copy(int dest, int begin, int count, int src) -{ - int i; - saturn_assert(dest>=0 && dest<9); - saturn_assert(src>=0 && src<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - for (i=0; i<count; i++) { - m_reg[dest][begin+i]=m_reg[src][begin+i]; - m_icount-=2; - } -} - -/**************************************************************************** - add opers - ****************************************************************************/ -void saturn_device::saturn_add(int reg, int begin, int count, int right) -{ - int i, t; - int base=m_decimal?10:16; - saturn_assert(reg>=0 && reg<9); - saturn_assert(right>=0 && right<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - m_carry=0; - for (i=0; i<count; i++) { - t=m_reg[reg][begin+i]; - t+=m_reg[right][begin+i]; - t+=m_carry; - if (t>=base) { - m_carry=1; - t-=base; - } - else m_carry=0; - saturn_assert(t>=0); saturn_assert(t<base); - m_reg[reg][begin+i]=t&0xf; - m_icount-=2; - } -} - -void saturn_device::saturn_add_const(int reg, int begin, int count, uint8_t right) -{ - int i, t; - int base=m_decimal?10:16; - saturn_assert(reg>=0 && reg<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - saturn_assert(count>1 || !m_decimal); /* SATURN bug */ - for (i=0; i<count; i++) { - t=m_reg[reg][begin+i]; - t+=(right&0xf); - right>>=4; - if (t>=base) { - right++; - t-=base; - } - saturn_assert(t>=0); saturn_assert(t<base); - m_reg[reg][begin+i]=t&0xf; - m_icount-=2; - if (!right) break; - } - m_carry=right>0; -} - -/**************************************************************************** - sub opers - ****************************************************************************/ -void saturn_device::saturn_sub(int reg, int begin, int count, int right) -{ - int i, t; - int base=m_decimal?10:16; - saturn_assert(reg>=0 && reg<9); - saturn_assert(right>=0 && right<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - m_carry=0; - for (i=0; i<count; i++) { - t=m_reg[reg][begin+i]; - t-=m_reg[right][begin+i]; - t-=m_carry; - if (t<0) { - m_carry=1; - t+=base; - } - else m_carry=0; - saturn_assert(t>=0); saturn_assert(t<base); - m_reg[reg][begin+i]=t&0xf; - m_icount-=2; - } -} - -void saturn_device::saturn_sub_const(int reg, int begin, int count, int right) -{ - int i, t; - int base=m_decimal?10:16; - saturn_assert(reg>=0 && reg<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - saturn_assert(count>1 || !m_decimal); /* SATURN bug */ - for (i=0; i<count; i++) { - t=m_reg[reg][begin+i]; - t-=(right&0xf); - right>>=4; - if (t<0) { - right++; - t+=base; - } - saturn_assert(t>=0); saturn_assert(t<base); - m_reg[reg][begin+i]=t&0xf; - m_icount-=2; - if (!right) break; - } - m_carry=right>0; -} - -/**************************************************************************** - sub2 opers (a=b-a) - ****************************************************************************/ -void saturn_device::saturn_sub2(int reg, int begin, int count, int right) -{ - int i, t; - int base=m_decimal?10:16; - saturn_assert(reg>=0 && reg<9); - saturn_assert(right>=0 && right<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - m_carry=0; - for (i=0; i<count; i++) { - t=m_reg[right][begin+i]; - t-=m_reg[reg][begin+i]; - t-=m_carry; - if (t<0) { - m_carry=1; - t+=base; - } - else m_carry=0; - saturn_assert(t>=0); saturn_assert(t<base); - m_reg[reg][begin+i]=t&0xf; - m_icount-=2; - } -} - -/**************************************************************************** - increment opers - ****************************************************************************/ -void saturn_device::saturn_increment(int reg, int begin, int count) -{ - int i, t=0; - int base=m_decimal?10:16; - saturn_assert(reg>=0 && reg<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - for (i=0; i<count; i++) { - m_icount-=2; - t=m_reg[reg][begin+i]; - t++; - if (t>=base) m_reg[reg][begin+i]=t-base; - else { m_reg[reg][begin+i]=t; break; } - } - m_carry=t>=base; -} - -/**************************************************************************** - decrement opers - ****************************************************************************/ -void saturn_device::saturn_decrement(int reg, int begin, int count) -{ - int i, t=0; - int base=m_decimal?10:16; - saturn_assert(reg>=0 && reg<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - for (i=0; i<count; i++) { - m_icount-=2; - t=m_reg[reg][begin+i]; - t--; - if (t<0) m_reg[reg][begin+i]=t+base; - else { m_reg[reg][begin+i]=t; break; } - } - m_carry=t<0; -} - -/**************************************************************************** - invert (1 complement) opers - ****************************************************************************/ -void saturn_device::saturn_invert(int reg, int begin, int count) -{ - int i; - int max=m_decimal?9:15; - saturn_assert(reg>=0 && reg<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - m_carry=0; - for (i=0; i<count; i++) { - m_reg[reg][begin+i]=(max-m_reg[reg][begin+i])&0xf; - m_icount-=2; - } -} - -/**************************************************************************** - negate (2 complement) opers - ****************************************************************************/ -void saturn_device::saturn_negate(int reg, int begin, int count) -{ - int i, n, c; - int max=m_decimal?9:15; - saturn_assert(reg>=0 && reg<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - c=1; - m_carry=0; - for (i=0; i<count; i++) { - n=m_reg[reg][begin+i]; - if (n) m_carry=1; - n=max+c-n; - if (n>max) n-=max+1; - else c=0; - saturn_assert(n>=0); saturn_assert(n<=max); - m_reg[reg][begin+i]=n&0xf; - m_icount-=2; - } -} - -/**************************************************************************** - or opers - ****************************************************************************/ -void saturn_device::saturn_or(int dest, int begin, int count, int src) -{ - int i; - saturn_assert(dest>=0 && dest<9); - saturn_assert(src>=0 && src<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - for (i=0; i<count; i++) { - m_reg[dest][begin+i]|=m_reg[src][begin+i]; - m_icount-=2; - } -} - -/**************************************************************************** - and opers - ****************************************************************************/ -void saturn_device::saturn_and(int dest, int begin, int count, int src) -{ - int i; - saturn_assert(dest>=0 && dest<9); - saturn_assert(src>=0 && src<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - for (i=0; i<count; i++) { - m_reg[dest][begin+i]&=m_reg[src][begin+i]; - m_icount-=2; - } -} - -/**************************************************************************** - shift nibbles left opers - ****************************************************************************/ -void saturn_device::saturn_shift_nibble_left(int reg, int begin, int count) -{ - int i; - saturn_assert(reg>=0 && reg<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - if (m_reg[reg][begin+count-1]) m_hst|=SB; - for (i=count-1; i>=1; i--) { - m_reg[reg][begin+i]=m_reg[reg][begin+i-1]; - m_icount-=2; - } - m_reg[reg][begin]=0; - m_icount-=2; -} - -/**************************************************************************** - shift nibbles right opers - ****************************************************************************/ -void saturn_device::saturn_shift_nibble_right(int reg, int begin, int count) -{ - int i; - saturn_assert(reg>=0 && reg<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - if (m_reg[reg][begin]) m_hst|=SB; - for (i=1; i<count; i++) { - m_reg[reg][begin+i-1]=m_reg[reg][begin+i]; - m_icount-=2; - } - m_reg[reg][begin+count-1]=0; - m_icount-=2; -} - - -/**************************************************************************** - rotate nibbles left opers - ****************************************************************************/ -void saturn_device::saturn_rotate_nibble_left_w(int reg) -{ - int i, x=m_reg[reg][15]; - saturn_assert(reg>=0 && reg<9); - for (i=15; i>=1; i--) { - m_reg[reg][i]=m_reg[reg][i-1]; - m_icount-=2; - } - m_reg[reg][0]=x; - m_icount-=2; -} - -/**************************************************************************** - rotate nibbles right opers - ****************************************************************************/ -void saturn_device::saturn_rotate_nibble_right_w(int reg) -{ - int i, x=m_reg[reg][0]; - saturn_assert(reg>=0 && reg<9); - for (i=1; i<16; i++) { - m_reg[reg][i-1]=m_reg[reg][i]; - m_icount-=2; - } - m_reg[reg][15]=x; - if (x) m_hst|=SB; - m_icount-=2; -} - - -/**************************************************************************** - shift right opers - ****************************************************************************/ -void saturn_device::saturn_shift_right(int reg, int begin, int count) -{ - int i, t, c=0; - saturn_assert(reg>=0 && reg<9); - saturn_assert(begin>=0 && count>0 && begin+count<=16); - for (i=count-1; i>=0; i--) { - t=m_reg[reg][begin+i]; - t|=(c<<4); - c=t&1; - m_reg[reg][begin+i]=t>>1; - m_icount-=2; - } - if (c) m_hst|=SB; - m_icount-=2; -} |