GBRb 0.1.0

data/lib/gbrb/cpu.rb

@@ -0,0 +1,7 @@
+module GBRb
+  module CPU
+    class CPUError < StandardError; end
+    class UnknownRegister < CPUError; end
+    class InstructionNotImplemented < CPUError; end
+  end
+end

data/lib/gbrb/cpu/concatenated_register.rb

@@ -0,0 +1,44 @@
+require_relative '../cpu'
+
+module GBRb::CPU
+  class ConcatenatedRegister
+    def initialize high, low
+      @high = high
+      @low = low
+      @bits = @high.bits + @low.bits
+    end
+
+    def store value
+      value &= mask - 1
+      @high.store value >> @high.bits
+      @low.store value << @low.bits >> @low.bits
+    end
+
+    def read
+      @low.read + (@high.read << @high.bits)
+    end
+
+    def zero?
+      @low.zero? && @high.zero?
+    end
+
+    def == other
+      other.read == read && other.bits == bits
+    end
+
+    def mask
+      @mask ||= 0x10 ** (@bits/4)
+    end
+
+    def half_mask
+      @half_mask ||= 0x10 ** (@bits/8)
+    end
+
+    def clear
+      @high.clear
+      @low.clear
+    end
+
+    attr_reader :bits
+  end
+end

data/lib/gbrb/cpu/flags_register.rb

@@ -0,0 +1,42 @@
+require_relative '../cpu'
+require_relative 'register'
+
+module GBRb::CPU
+  class FlagsRegister < Register
+    ZERO_FLAG_POS       = 0x80
+    ADD_SUB_FLAG_POS    = 0x40
+    HALF_CARRY_FLAG_POS = 0x20
+    CARRY_FLAG_POS      = 0x10
+
+    FLAGS = { zero:       ZERO_FLAG_POS,
+              add_sub:    ADD_SUB_FLAG_POS,
+              half_carry: HALF_CARRY_FLAG_POS,
+              carry:      CARRY_FLAG_POS
+            }
+
+    FLAGS.each_pair do |flag, position|
+      method_name = "#{flag}_flag?".to_sym
+      send :define_method, method_name do
+        not (@value & position).zero?
+      end
+    end
+
+    FLAGS.each_pair do |flag, position|
+      method_name = "set_#{flag}_flag".to_sym
+      send :define_method, method_name do
+        store @value | position
+      end
+    end
+
+    FLAGS.each_pair do |flag, position|
+      method_name = "clear_#{flag}_flag".to_sym
+      send :define_method, method_name do
+        store @value & ~position
+      end
+    end
+
+    def initialize value=0x0
+      super value, 8
+    end
+  end
+end

data/lib/gbrb/cpu/instruction.rb

@@ -0,0 +1,648 @@
+require_relative '../cpu'
+
+module GBRb::CPU
+  class Instruction
+    attr_reader :i, :m, :t
+
+    def initialize m=1, t=4, immediates=0, *extra
+      @m = m
+      @t = t
+      @immediates = immediates
+    end
+
+    def immediate_count
+      @immediates
+    end
+
+    def call r, mem
+      nil
+    end
+
+    def carry? left, right, mask
+      (mask-1 & left).public_send(@op, mask-1 & right) & mask == mask
+    end
+  end
+
+  class Stop < Instruction; end
+
+  class Scf < Instruction
+    def call r, mem
+      r.clear_half_carry_flag
+      r.clear_add_sub_flag
+      r.set_carry_flag
+    end
+  end
+
+  class Cpl < Instruction
+    def call r, mem
+      r.set_add_sub_flag
+      r.set_half_carry_flag
+      r.a.store r.a.read ^ 0xff
+    end
+  end
+
+  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 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)
+      else
+        reg.store tmp + 1
+      end
+      if @flags
+        r.clear_add_sub_flag
+        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
+
+  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) - 1
+        mem.write_byte(tmp, v)
+      else
+        reg.store tmp - 0x01
+      end
+      if @flags
+        r.set_add_sub_flag
+        if reg.zero?
+          r.set_zero_flag
+        else
+          r.clear_zero_flag
+        end
+        if carry? tmp, 0x01, reg.half_mask
+          r.set_half_carry_flag
+        else
+          r.clear_half_carry_flag
+        end
+      end
+    end
+  end
+
+  class Ld < Instruction
+    def initialize destination, target, m=1, t=4, indirect_dest=false, indirect_target=false, immediates=0, offset=0x00
+      super m, t, immediates
+
+      @destination = destination
+      @target = target
+      @indirect_dest = indirect_dest
+      @indirect_target = indirect_target
+      @offset = offset
+    end
+
+    def call r, mem, v=nil
+      if not v
+        v = r.public_send(@target.to_sym).read
+      end
+
+      if @indirect_target
+        v = mem.read_byte(v + @offset)
+        target_reg = r.public_send(@destination.to_sym)
+        if @indirect_target == :increment
+          target_reg.store target_reg.read + 1
+        elsif @indirect_target == :decrement
+          target_reg.store target_reg.read - 1
+        end
+      end
+
+
+      if @indirect_dest
+        if @indirect_dest == :immediate
+          if @target.to_s.chars.length == 2
+            mem.write_word(v + @offset, r.public_send(@target.to_sym).read)
+          else
+            mem.write_byte(v + @offset, r.public_send(@target.to_sym).read)
+          end
+        else
+          reg = r.public_send(@destination.to_sym)
+          mem.write_byte(reg.read + @offset, v)
+          if @indirect_dest == :increment
+            reg.store reg.read + 1
+          elsif @indirect_dest == :decrement
+            reg.store reg.read - 1
+          end
+        end
+      else
+        r.public_send(@destination.to_sym).store v
+      end
+    end
+  end
+
+  class Ldh < Ld
+    def call r, mem, address
+      if @indirect_dest
+        value = r.public_send(@target.to_sym).read
+        mem.write_byte address + @offset, value
+      elsif @indirect_target
+        value = mem.read_byte address + @offset
+        r.public_send(@destination.to_sym).store value
+      end
+    end
+  end
+
+  class Ldhlsp < Instruction
+    def initialize m=2, t=12, immediates=1
+      super
+      @op = :+
+    end
+
+    def call r, mem, offset
+      sign = (offset >> 7 == 1) ? :- : :+
+      offset = ((offset ^ 0xff) + 1) & 0xff
+      value = r.sp.read.public_send(sign, offset)
+      r.hl.store value
+      r.clear_zero_flag
+      r.clear_add_sub_flag
+      carry?(value, 0x00, r.hl.mask) ? r.set_carry_flag : r.clear_carry_flag
+      carry?(value, 0x00, r.hl.half_mask) ? r.set_half_carry_flag : r.clear_half_carry_flag
+    end
+  end
+
+  class Jump < Instruction
+    def initialize condition, m=2, t_high=12, t_low=8, immediates=1
+      super m, t_low, immediates
+      @t_high = t_high
+      @condition = condition.downcase.to_sym
+    end
+
+    def call r, mem, offset
+      do_it = case @condition
+              when :c
+                r.carry_flag?
+              when :none
+                true
+              when :nc
+                not r.carry_flag?
+              when :nz
+                not r.zero_flag?
+              when :z
+                r.zero_flag?
+              else
+                false
+              end
+
+      if do_it
+        @t = @t_high
+        if @immediates == 1
+          sign = (offset >> 7 == 1) ? :- : :+
+          offset = ((offset ^ 0xff) + 1) & 0xff if sign == :-
+          r.pc.store r.pc.read.public_send(sign, offset)
+        else
+          r.pc.store offset
+        end
+      end
+    end
+  end
+
+  class Rl < Instruction
+    def initialize target, carry=false, indirect=false, m=2, t=8
+      super m, t
+      @target = target.to_sym
+      @carry = carry
+      @indirect = indirect
+    end
+
+    def call r, mem
+      if @indirect
+        address = r.public_send(@target).read
+        v = mem.read_byte(address) << 1
+      else
+        v = r.public_send(@target).read << 1
+      end
+
+      carry_in = if @carry
+                   v & 0x100 == 0x100 ? 1 : 0
+                 else
+                   r.carry_flag? ? 1 : 0
+                 end
+
+      v += carry_in
+
+      if @indirect
+        mem.write_byte(address, v)
+      else
+        r.public_send(@target).store v
+      end
+
+      r.clear_add_sub_flag
+      r.clear_half_carry_flag
+      v & 0xff == 0 ? r.set_zero_flag : r.clear_zero_flag
+      carry_out = v >> 8
+      carry_out == 1 ? r.set_carry_flag : r.clear_carry_flag
+    end
+  end
+
+  class Rr < Instruction
+    def initialize target, carry=false, indirect=false, m=2, t=8
+      super m, t
+      @target = target.to_sym
+      @carry = carry
+      @indirect = indirect
+    end
+
+    def call r, mem
+      if @indirect
+        address = r.public_send(@target).read
+        v = mem.read_byte(address)
+      else
+        v = r.public_send(@target).read
+      end
+
+      carry_out = v & 0x01
+
+      carry_in = if @carry
+                   carry_out
+                 else
+                   r.carry_flag? ? 1 : 0
+                 end
+
+      v >>= 1
+
+      v += carry_in << 7
+
+      if @indirect
+        original = mem.read_byte address
+        mem.write_byte(address, v)
+      else
+        r.public_send(@target).store v
+      end
+
+      r.clear_add_sub_flag
+      r.clear_half_carry_flag
+      v & 0xff == 0 ? r.set_zero_flag : r.clear_zero_flag
+      carry_out == 1 ? r.set_carry_flag : r.clear_carry_flag
+    end
+  end
+
+  class Swap < Instruction
+    def initialize target, m=2, t=8, indirect=false
+      @target = target
+      @indirect = indirect
+      super m, t
+    end
+
+    def call r, mem
+      initial = r.public_send(@target).read
+      initial = mem.read_byte(initial) if @indirect
+      high = initial >> 4
+      low = initial & ((1 << 4) - 1)
+
+      result = (low << 4) + high
+
+      if @indirect
+        mem.write_byte r.public_send(@target).read, result
+        mem.read_byte(r.public_send(@target).read) == 0 ? r.set_zero_flag : r.clear_zero_flag
+      else
+        r.public_send(@target).store result
+        r.public_send(@target).read == 0 ? r.set_zero_flag : r.clear_zero_flag
+      end
+      r.clear_add_sub_flag
+      r.clear_half_carry_flag
+      r.clear_carry_flag
+    end
+  end
+
+  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=1, 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
+      r.set_carry_flag if carry? left, right, r.hl.mask
+      r.set_half_carry_flag if carry? left, right, r.hl.half_mask
+    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
+      super r, mem, r.public_send(@target.to_sym).read + carry
+    end
+  end
+
+  class Sbc < Sub
+    def call r, mem, right_value=nil
+      carry = r.carry_flag? ? 1 : 0
+      super r, mem, r.public_send(@target.to_sym).read + carry
+    end
+  end
+
+  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
+      @op = :|
+      super
+    end
+
+    def call r, mem
+      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
+
+  class Pop < Instruction
+    def initialize target, m=1, t=12
+      super m, t
+      @targets = target.to_s.chars.map{|a| a.to_sym}.reverse
+    end
+
+    def call r, mem
+      @targets.each do |target|
+        r.public_send(target).store mem.read_byte(r.sp.read)
+        r.sp.store r.sp.read + 1
+      end
+    end
+  end
+
+  class Push < Instruction
+    def initialize target, m=1, t=16
+      super m, t
+      @targets = target.to_s.chars.map{|a| a.to_sym}
+    end
+
+    def call r, mem
+      @targets.each do |target|
+        r.sp.store r.sp.read - 1
+        mem.write_byte(r.sp.read, r.public_send(target).read)
+      end
+    end
+  end
+
+  class Rst < Instruction
+    def initialize offset
+      @offset = offset
+      super 1, 16
+    end
+
+    def call r, mem
+      r.sp.store r.sp.read - 2
+      mem.write_word r.sp.read, r.pc.read
+      r.pc.store 0x0000 + @offset
+    end
+  end
+
+  class Call < Instruction
+    def initialize m=3, t=24, immediates=2, condition=:none
+      @condition = condition
+      super
+    end
+
+    def call r, mem, addr
+      condition_met = case @condition
+                      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
+      end
+    end
+  end
+
+  class Ret < Instruction
+    def initialize m=1, t=16, t_high=16, condition=:none
+      @condition = condition
+      @t_high = t_high
+      super m, t, 0
+    end
+
+    def call r, mem
+      condition_met = case @condition
+                      when :NZ
+                        not r.zero_flag?
+                      when :none
+                        true
+                      else
+                        false
+                      end
+      if condition_met
+        @t = @t_high
+        low = mem.read_byte(r.sp.read)
+        r.sp.store r.sp.read + 1
+        high = mem.read_byte(r.sp.read)
+        r.sp.store r.sp.read + 1
+
+        r.pc.store (high << 8) + low
+      end
+    end
+  end
+
+  class EnableInterrupts < Instruction; end
+  class DisableInterrupts < Instruction; end
+
+  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