Module: Badline::InstructionSet::Transfer

Included in:
Badline::InstructionSet
Defined in:
lib/badline/instruction_set/transfer.rb

Instance Method Summary collapse

Instance Method Details

#lda(_addr, value) ⇒ Object

+begin_src ruby Load accumulator with memory.

Opcodes:

$A1 - indirect_x - 6 cycles
$A5 - zeropage   - 3 cycles
$A9 - immediate  - 2 cycles
$AD - absolute   - 4 cycles
$B1 - indirect_y - 5+ cycles
$B5 - zeropage_x - 4 cycles
$B9 - absolute_y - 4+ cycles
$BD - absolute_x - 4+ cycles



18
19
20
21
 
# File 'lib/badline/instruction_set/transfer.rb', line 18

def lda(_addr, value)
  @a = resolve(value)
  update_number_flags(@a)
end

#ldx(_addr, value) ⇒ Object

Load X register with memory.

Opcodes:

$A2 - immediate  - 2 cycles
$A6 - zeropage   - 3 cycles
$AE - absolute   - 4 cycles
$B6 - zeropage_y - 4 cycles
$BE - absolute_y - 4+ cycles



31
32
33
34
 
# File 'lib/badline/instruction_set/transfer.rb', line 31

def ldx(_addr, value)
  @x = resolve(value)
  update_number_flags(@x)
end

#ldy(_addr, value) ⇒ Object

Load Y register with memory.

Opcodes:

$A0 - immediate  - 2 cycles
$A4 - zeropage   - 3 cycles
$AC - absolute   - 4 cycles
$B4 - zeropage_x - 4 cycles
$BC - absolute_x - 4+ cycles



44
45
46
47
 
# File 'lib/badline/instruction_set/transfer.rb', line 44

def ldy(_addr, value)
  @y = resolve(value)
  update_number_flags(@y)
end

#sta(addr, _value) ⇒ Object

Store accumulator in memory.

Opcodes:

$81 - indirect_x - 6 cycles
$85 - zeropage   - 3 cycles
$8D - absolute   - 4 cycles
$91 - indirect_y - 6 cycles
$95 - zeropage_x - 4 cycles
$99 - absolute_y - 5 cycles
$9D - absolute_x - 5 cycles



59
60
61
 
# File 'lib/badline/instruction_set/transfer.rb', line 59

def sta(addr, _value)
  write_byte(addr, @a)
end

#stx(addr, _value) ⇒ Object

Store X register in memory.

Opcodes:

$86 - zeropage   - 3 cycles
$8E - absolute   - 4 cycles
$96 - zeropage_y - 4 cycles



69
70
71
 
# File 'lib/badline/instruction_set/transfer.rb', line 69

def stx(addr, _value)
  write_byte(addr, @x)
end

#sty(addr, _value) ⇒ Object

Store Y register in memory.

Opcodes:

$84 - zeropage   - 3 cycles
$8C - absolute   - 4 cycles
$94 - zeropage_x - 4 cycles



79
80
81
 
# File 'lib/badline/instruction_set/transfer.rb', line 79

def sty(addr, _value)
  write_byte(addr, @y)
end

#tax(_addr, _value) ⇒ Object

Transfer accumulator to X register.

Opcodes:

$AA - implied - 2 cycles



87
88
89
90
 
# File 'lib/badline/instruction_set/transfer.rb', line 87

def tax(_addr, _value)
  cycle { @x = a }
  update_number_flags(@x)
end

#tay(_addr, _value) ⇒ Object

Transfer accumulator to Y register.

Opcodes:

$A8 - implied - 2 cycles



96
97
98
99
 
# File 'lib/badline/instruction_set/transfer.rb', line 96

def tay(_addr, _value)
  cycle { @y = a }
  update_number_flags(@y)
end

#tsx(_addr, _value) ⇒ Object

Transfer stack pointer to X register.

Opcodes:

$BA - implied - 2 cycles



105
106
107
108
 
# File 'lib/badline/instruction_set/transfer.rb', line 105

def tsx(_addr, _value)
  cycle { @x = stack_pointer }
  update_number_flags(@x)
end

#txa(_addr, _operand) ⇒ Object

Transfer X register to accumulator.

Opcodes:

$8A - implied - 2 cycles



114
115
116
117
 
# File 'lib/badline/instruction_set/transfer.rb', line 114

def txa(_addr, _operand)
  cycle { @a = x }
  update_number_flags(@a)
end

#txs(_addr, _operand) ⇒ Object

Transfer X register to stack pointer.

Opcodes:

$9A - implied - 2 cycles



123
124
125
 
# File 'lib/badline/instruction_set/transfer.rb', line 123

def txs(_addr, _operand)
  cycle { @stack_pointer = x }
end

#tya(_addr, _operand) ⇒ Object

Transfer Y register to accumulator.

Opcodes:

$98 - implied - 2 cycles



131
132
133
134
 
# File 'lib/badline/instruction_set/transfer.rb', line 131

def tya(_addr, _operand)
  cycle { @a = y }
  update_number_flags(@a)
end