GBRb 0.1.0 → 0.2.0

data/lib/gbrb/instruction_set.rb

@@ -0,0 +1,16 @@
+require_relative 'instruction_set/instruction'
+require_relative 'instruction_set/ld'
+require_relative 'instruction_set/bitwise'
+require_relative 'instruction_set/rotate'
+require_relative 'instruction_set/stack'
+require_relative 'instruction_set/boolean'
+require_relative 'instruction_set/arithmetic'
+require_relative 'instruction_set/special'
+require_relative 'instruction_set/carry'
+require_relative 'instruction_set/call'
+require_relative 'instruction_set/return'
+require_relative 'instruction_set/jump'
+require_relative 'instruction_set/swap'
+require_relative 'instruction_set/cpl'
+require_relative 'instruction_set/rst'
+require_relative 'instruction_set/daa'

data/lib/gbrb/instruction_set/arithmetic.rb

@@ -0,0 +1,238 @@
+require_relative 'instruction'
+
+module GBRb::InstructionSet
+  class Arithmetic < Instruction
+    def initialize target, m, t, indirect, immediates=0
+      super m, t, immediates
+      @target = target
+      @indirect = indirect
+    end
+
+    def carry? left, right, mask
+      (mask-1 & left).public_send(@op, mask-1 & right) & mask == mask
+    end
+
+    def call r, mem, right_value
+      right_value ||= r.public_send(@target.to_sym).read
+      right_value = mem.read_byte(right_value) if @indirect
+      a_value = r.a.read
+      if carry? a_value, right_value, r.a.half_mask
+        r.set_half_carry_flag
+      else
+        r.clear_half_carry_flag
+      end
+      if carry? a_value, right_value, r.a.mask
+          r.set_carry_flag
+      else
+        r.clear_carry_flag
+      end
+      a_value = a_value.public_send(@op, right_value) & 0xff
+      r.a.store a_value unless @skip_store
+      a_value == 0x00 ? r.set_zero_flag : r.clear_zero_flag
+    end
+  end
+
+  class Add < Arithmetic
+    def initialize target, m=1, t=4, indirect=false, immediates=0
+      super
+      @op = :+
+    end
+
+    def call r, mem, right_value=nil
+      super
+      r.clear_add_sub_flag
+    end
+  end
+
+  class AddHl < Instruction
+    def initialize target, m=2, t=8
+      super m, t
+      @target = target.to_sym
+      @op = :+
+    end
+
+    def call r, mem
+      left = r.hl.read
+      right = r.public_send(@target).read
+      r.hl.store left + right
+      if r.hl.read < left + right
+        r.set_carry_flag
+      else
+        r.clear_carry_flag
+      end
+      if carry? left, right, r.hl.half_mask
+        r.set_half_carry_flag
+      else
+        r.clear_half_carry_flag
+      end
+      r.clear_add_sub_flag
+    end
+  end
+
+  class AddSpR8 < Instruction
+    def initialize m=4, t=16, immediates=1
+      super
+    end
+
+    def call r, mem, offset
+      v = r.sp.read
+      if offset > 127
+        v -= ((offset ^ 0xff) + 1) & 0xff
+      else
+        v += offset
+      end
+      r.clear_zero_flag
+      r.clear_add_sub_flag
+      check = r.sp.read ^ offset ^ ((r.sp.read + offset)& 0xffff)
+      r.sp.store v
+      if check & 0x100 == 0x100
+        r.set_carry_flag
+      else
+        r.clear_carry_flag
+      end
+      if check & 0x10 == 0x10
+        r.set_half_carry_flag
+      else
+        r.clear_half_carry_flag
+      end
+    end
+  end
+
+  class Sub < Arithmetic
+    def initialize target, m=1, t=4, indirect=false, immediates=0
+      super
+      @op = :-
+    end
+
+    def call r, mem, right_value=nil
+      super
+      r.set_add_sub_flag
+    end
+  end
+
+  class Cp < Sub
+    def initialize *args
+      super
+      @skip_store = true
+    end
+  end
+
+  class Adc < Add
+    def call r, mem, right_value=nil
+      carry = r.carry_flag? ? 1 : 0
+      if right_value
+        left_value = r.a.read
+        super r, mem, right_value + carry
+        ((left_value & 0xf) + (right_value & 0xf) + carry) > 0xf ? r.set_half_carry_flag : r.clear_half_carry_flag
+        ((left_value & 0xff) + (right_value & 0xff) + carry) > 0xff ? r.set_carry_flag : r.clear_carry_flag
+      else
+        right_value = r.public_send(@target.to_sym).read
+        right_value = mem.read_byte(right_value) if @indirect
+        left_value = r.a.read
+        r.clear_add_sub_flag
+        ((left_value & 0xf) + (right_value & 0xf) + carry) > 0xf ? r.set_half_carry_flag : r.clear_half_carry_flag
+        ((left_value & 0xff) + (right_value & 0xff) + carry) > 0xff ? r.set_carry_flag : r.clear_carry_flag
+        r.a.store left_value + right_value + carry
+        r.a.zero? ? r.set_zero_flag : r.clear_zero_flag
+      end
+    end
+  end
+
+  class Sbc < Sub
+    def call r, mem, right_value=nil
+      carry = r.carry_flag? ? 1 : 0
+      right_value = r.public_send(@target.to_sym).read unless right_value
+      right_value = mem.read_byte(right_value) if @indirect
+      un = right_value & 0xff
+      tmpa = r.a.read
+      ua = r.a.read
+      ua -= un
+      ua -= 1 if r.carry_flag?
+      r.set_add_sub_flag
+      ua < 0 ? r.set_carry_flag : r.clear_carry_flag
+      (ua ^ un ^ tmpa) & 0x10 == 0x10 ? r.set_half_carry_flag : r.clear_half_carry_flag
+      r.a.store ua
+      r.a.zero? ? r.set_zero_flag : r.clear_zero_flag
+    end
+  end
+
+  class Inc < Instruction
+    def initialize register, m=1, t=4, flags=true, indirect=false
+      super m, t
+
+      @register = register
+      @flags = flags
+      @op = :+
+      @indirect = indirect
+    end
+
+    def call r, mem
+      reg = r.public_send(@register.to_sym)
+      tmp = reg.read
+      if @indirect
+        v = mem.read_byte(tmp) + 1
+        mem.write_byte(tmp, v)
+        tmp = v
+        reg = r.h
+      else
+        reg.store tmp + 1
+      end
+      if @flags
+        r.clear_add_sub_flag
+        if @indirect
+          (tmp & 0xff == 0x00) ? r.set_zero_flag : r.clear_zero_flag
+          if carry? tmp - 1, 0x01, r.h.half_mask
+            r.set_half_carry_flag
+          else
+            r.clear_half_carry_flag
+          end
+        else
+          reg.zero? ? r.set_zero_flag : r.clear_zero_flag
+          if carry? tmp, 0x01, reg.half_mask
+            r.set_half_carry_flag
+          else
+            r.clear_half_carry_flag
+          end
+        end
+      end
+    end
+  end
+
+  class Dec < Instruction
+    def initialize register, m=1, t=4, flags=true, indirect=false
+      super m, t
+
+      @register = register
+      @flags = flags
+      @op = :-
+      @indirect = indirect
+    end
+
+    def call r, mem
+      reg = r.public_send(@register.to_sym)
+      tmp = reg.read
+      if @indirect
+        v = mem.read_byte(tmp)
+        mem.write_byte(tmp, v - 1)
+        tmp = v
+        half_mask = r.a.half_mask
+      else
+        reg.store tmp - 0x01
+        half_mask = reg.half_mask
+      end
+      if @flags
+        r.set_add_sub_flag
+        if (tmp - 0x01) == 0x00
+          r.set_zero_flag
+        else
+          r.clear_zero_flag
+        end
+        if carry? tmp, 0x01, half_mask
+          r.set_half_carry_flag
+        else
+          r.clear_half_carry_flag
+        end
+      end
+    end
+  end
+end

data/lib/gbrb/instruction_set/bitwise.rb

@@ -0,0 +1,64 @@
+require_relative '../cpu'
+require_relative 'instruction'
+
+module GBRb::InstructionSet
+  class Res < Instruction
+    def initialize bit, target, indirect=false, m=2, t=16
+      super m, t
+      @bit = bit
+      @mask = 0xff - 0b10 ** bit
+      @target = target.to_sym
+      @indirect = indirect
+    end
+
+    def call r, mem
+      if @indirect
+        addr = r.public_send(@target).read
+        mem.write_byte(addr, mem.read_byte(addr) & @mask)
+      else
+        r.public_send(@target).store r.public_send(@target).read & @mask
+      end
+    end
+  end
+
+  class Set < Instruction
+    def initialize bit, target, indirect=false, m=2, t=16
+      super m, t
+      @bit = bit
+      @mask = 0b10 ** bit
+      @target = target.to_sym
+      @indirect = indirect
+    end
+
+    def call r, mem
+      if @indirect
+        addr = r.public_send(@target).read
+        mem.write_byte(addr, mem.read_byte(addr) | @mask)
+      else
+        r.public_send(@target).store r.public_send(@target).read | @mask
+      end
+    end
+  end
+
+  class Bit < Instruction
+    def initialize bit, target, indirect=false, m=2, t=8
+      super m,t
+      @target = target
+      @bit = bit
+      @indirect = indirect
+      @mask = 1 << @bit
+    end
+
+    def call r, mem
+      if @indirect
+        v = mem.read_byte r.public_send(@target).read
+      else
+        v = r.public_send(@target).read
+      end
+
+      v & @mask != @mask ? r.set_zero_flag : r.clear_zero_flag
+      r.set_half_carry_flag
+      r.clear_add_sub_flag
+    end
+  end
+end

data/lib/gbrb/instruction_set/boolean.rb

@@ -0,0 +1,61 @@
+require_relative '../cpu'
+require_relative 'instruction'
+
+module GBRb::InstructionSet
+  class Boolean < Instruction
+    def initialize target, m, t, indirect, immediates=0
+      @target = target
+      @indirect = indirect
+      super m, t, immediates
+    end
+
+    def call r, mem, v=nil
+      if v
+        value = v
+      else
+        value = r.public_send(@target.to_sym).read
+        value = mem.read_byte value if @indirect
+      end
+      r.a.store r.a.read.public_send(@op, value)
+      r.a.zero? ? r.set_zero_flag : r.clear_zero_flag
+      r.clear_carry_flag
+      r.clear_add_sub_flag
+    end
+  end
+
+  class And < Boolean
+    def initialize target, m=1, t=4, indirect=false, immediates=0
+      @op = :&
+      super
+    end
+
+    def call r, mem, v=nil
+      super
+      r.set_half_carry_flag
+    end
+  end
+
+  class Or < Boolean
+    def initialize target, m=1, t=4, indirect=false, immediates=0
+      @op = :|
+      super
+    end
+
+    def call r, mem, right_value=nil
+      super
+      r.clear_half_carry_flag
+    end
+  end
+
+  class Xor < Boolean
+    def initialize target, m=1, t=4, indirect=false, immediates=0
+      @op = :^
+      super
+    end
+
+    def call r, mem, right_value=nil
+      super
+      r.clear_half_carry_flag
+    end
+  end
+end

data/lib/gbrb/instruction_set/call.rb

@@ -0,0 +1,40 @@
+require_relative 'instruction'
+
+module GBRb::InstructionSet
+  class Call < Instruction
+    def initialize condition, m=3, t_high=24, t_low=12, immediates=2
+      @condition = condition
+      @t_high = t_high
+      @t_low = t_low
+      @m_low = m
+      super m, t_low, immediates
+    end
+
+    def call r, mem, addr
+      condition_met = case @condition
+                      when :c
+                        r.carry_flag?
+                      when :nc
+                        not r.carry_flag?
+                      when :nz
+                        not r.zero_flag?
+                      when :z
+                        r.zero_flag?
+                      when :none
+                        true
+                      else
+                        false
+                      end
+      if condition_met
+        r.sp.store r.sp.read - 2
+        mem.write_word(r.sp.read, r.pc.read)
+        r.pc.store addr
+        @t = @t_high
+        @m = @t_high / 4
+      else
+        @t = @t_low
+        @m = @m_low
+      end
+    end
+  end
+end

data/lib/gbrb/instruction_set/carry.rb

@@ -0,0 +1,23 @@
+require_relative 'instruction'
+
+module GBRb::InstructionSet
+  class Ccf < Instruction
+    def call r, mem
+      if r.carry_flag?
+        r.clear_carry_flag
+      else
+        r.set_carry_flag
+      end
+      r.clear_add_sub_flag
+      r.clear_half_carry_flag
+    end
+  end
+
+  class Scf < Instruction
+    def call r, mem
+      r.clear_half_carry_flag
+      r.clear_add_sub_flag
+      r.set_carry_flag
+    end
+  end
+end