r6502 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MGMyOTkxOTE5YjI1MTI5MTZmODQwMzI2OGJiMDUzZWRhYzcyZDVkNg==
+  data.tar.gz: !binary |-
+    NDVhZmEwZjc0NmY4MWU3OTYxZmY2YmY2NmQ2YjllMjBkMDAwZDVkMQ==
+SHA512:
+  metadata.gz: !binary |-
+    NThlMDg4ODY5MDgxMjU1NDVmMzVhODgyM2I5OTQ5MGI1OTc2MDZhMzY5NDYx
+    NTYzYmE3NTFmYjQ2NWJmNjQxZTVkY2EyMDkyMzNmYjg5NWI0NmQ1M2M1ZDY3
+    MzM1NDNhNGVjMmI3Y2I3YzNiNDBlNjZjZDFlYmY1NWE3ZDZkOTg=
+  data.tar.gz: !binary |-
+    OGQyMjFhN2FjNTRiODgwMjY2NmQxMzE5MjEwMDdmYWM4YjcxODkxYzU5ZWU1
+    OGQ5ZDkxMTYxOTE0NDJhZjQxY2QyNGQ1M2ZkN2FmZjg3MThlZmIwN2QwNmY1
+    Y2IxY2MyOTA2NDcwZjc0ZWM5ZmFlYjUyZWUxMTJhYTUyMDkyNmE=

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2014 Joe Landers
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,27 @@
+# Update: 14 November 2012
+It works. [See my blog post](http://0xfffc.tumblr.com/post/35751220092/6502-assembler-and-simulator-in-ruby)
+
+It probably bears no resemblance to the JS code
+which inspired the project, so don't get confused
+by that.
+
+Also, the code (and especially the specs) need
+cleanup and refactoring, so don't judge. :)
+
+# Original intro:
+Work-in-progress assembler and simulator of the 6502,
+written in Ruby.
+
+Originally, I was going to fork Nick Morgan's JS simulation
+(github.com/skilldrick/6502js), but I decided to do a
+rewrite in Ruby. (He's got a very nice interactive "book"
+on 6502 assembly programming.)
+
+Nick's version is a modification of the excellent original,
+by Stian Soreng (6502asm.com), so probably the most thanks
+for the code goes to him.
+
+I'm using the JS code as reference, but probably most of
+the internal structure will be quite different.
+
+MIT Licensed

data/bin/r6502

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.expand_path('../../lib',__FILE__)
+require 'r6502'
+
+@mem = R6502::Memory.new
+@asm = R6502::Assembler.new(@mem)
+@cpu = R6502::Cpu.new(@mem)
+@cpu.pc = 0x0600 #start of execution, for now
+
+file = []
+puts "Hello! Enter some 6502 assembly, and an empty line when done."
+until (line = gets.chomp).empty?
+  file << line
+end
+
+@asm.process_file( file.join("\n") )
+
+puts "Now give me the first and last address of the memory"
+puts "that you want me to print out."
+inpt = gets
+first = inpt.split[0].to_i(16)
+second = inpt.split[1].to_i(16)
+@mem.get_range(first, second).each {|b| print ("%02x " % b)}
+print "\n\n"
+
+puts "Now I'll run that code"
+
+while( @mem.get(@cpu.pc) != 0 ) do
+  @cpu.step
+end
+
+puts "Now give me the first and last address of the memory"
+puts "that you want me to print out."
+inpt = gets
+first = inpt.split[0].to_i(16)
+second = inpt.split[1].to_i(16)
+@mem.get_range(first, second).each {|b| print ("%02x " % b)}
+print "\n\n"
+
+puts "That looks excellent. Have a good day."
+

data/lib/r6502.rb

@@ -0,0 +1,6 @@
+require 'r6502/memory'
+require 'r6502/assembler'
+require 'r6502/opcode_table'
+require 'r6502/instr_table'
+require 'r6502/cpu_instructions.rb'
+require 'r6502/cpu_execution.rb'

data/lib/r6502/assembler.rb

@@ -0,0 +1,204 @@
+module R6502
+  class Assembler
+
+    def initialize(memory)
+      @memory = memory
+      @pc = 0x600
+      # @labels holds 'label' => 0xabcd mappings
+      # where the address is what gets subbed for the label
+      @labels = {}
+      # @deferred holds 0x0601 => 'main' mappings
+      # where the addr. marks memory we need to fill in 2nd pass
+      # (after we know all the label => addr. mappings)
+      @deferred = {}
+    end
+
+    def pc
+      @pc
+    end
+
+    def labels
+      @labels
+    end
+
+    def deferred
+      @deferred
+    end
+
+    def label_get(label)
+      @labels[label]
+    end
+
+    def uncomment(line)
+      line.sub(/\s*;.*/, '')
+    end
+
+    def extract_command(instr)
+      instr = instr.sub(/^\s*/, '')
+      instr.sub(/\s.*/, '').to_sym
+    end
+
+    def extract_param(instr)
+      instr.sub(/[a-zA-Z]+\s*/, '').downcase
+    end
+
+    def addr_mode(param)
+      case param
+      when /#\$[0-9a-f]{1,2}$/
+        :imm
+      when /\$[0-9a-f]{1,2}$/
+        :zp
+      when /\$[0-9a-f]{1,2},x$/
+        :zpx
+      when /\$[0-9a-f]{1,2},y$/
+        :zpy
+      when /\$[0-9a-f]{3,4}$/
+        :abs
+      when /^[a-z]+/
+        :abs
+      when /\$[0-9a-f]{3,4},x$/
+        :absx
+      when /\$[0-9a-f]{3,4},y$/
+        :absy
+      when /\(\$[0-9a-f]{3,4}\)$/
+        :ind
+      when /\(\$[0-9a-f]{1,2},x\)$/
+        :indx
+      when /\(\$[0-9a-f]{1,2}\),y$/
+        :indy
+      when //
+        :imp
+      end
+    end
+
+    # This method got nasty.
+    def asm_instr(instr)
+      command = extract_command(instr)
+      param = extract_param(instr)
+
+      # Branch instructions always in relative
+      # mode. No other instructions use this mode.
+      # Relative mode and zero-page mode look the
+      # same to addr_mode(), so we need to handle
+      # this here.
+      if [:bpl, :bmi, :bvc, :bvs,
+          :bcc, :bcs, :bne, :beq].
+         include?(command)
+        mode = :rel
+      else
+        mode = addr_mode(param)
+      end
+
+      bytes = []
+      bytes << opcode(command, mode)
+
+      # If implied mode, it's a 1-byte instruction.
+      if [:imp].include?(mode)
+        return bytes
+      end
+
+      # Handle label or address / immediate value
+      if param =~ /\$/ # non-labels always have a $
+        # Extract hex number from param string.
+        number = /[0-9a-f]{1,4}/.match(param)[0].to_i(16)
+      else
+        # Store a dummy value and record this location
+        # to be updated in 2nd pass.
+        defer_value(@pc + 1, param)
+        number = mode == :rel ? 0xff : 0xffff
+      end
+
+      # These instructions take 1 byte.
+      if [:imm,  :zp,   :zpx,  :zpy,
+          :indx, :indy, :rel].include?(mode)
+        (number <= 0xff) || (raise "#{command}'s number too big")
+        return bytes << number
+      # These instructions take 2 bytes.
+      elsif [:abs, :absx, :absy, :ind].include?(mode)
+        (number <= 0xffff) || (raise 'number too big')
+        bytes << (number & 0xff) # least-sig. byte
+        bytes << (number >> 8)   # most-sig. byte
+      end
+    end
+
+    def write_byte(byte)
+      @memory.set(@pc, byte)
+      @pc += 1
+    end
+
+    def process_line(line)     # can have label, cmd, param, cmt
+      line.downcase!
+      instr = uncomment(line)  # strips comment
+      instr = delabel(instr)   # strips label
+      if instr == '' then return end
+      bytes = asm_instr(instr) # convert remainder to machine code
+      bytes.each { |b| write_byte(b) } # pop bytes into memory
+    end
+
+    def delabel(instr)
+      instr = instr.sub(/^\s+/, '') #strip leading whitespace
+      first = instr.split(/\s+/)[0] #get first non-ws substr.
+      # if first word is an instruction, then there's
+      # no label in this instr, so we're done.
+      if ['adc', 'and', 'asl', 'bit', 'bpl', 'bmi',
+          'bvc', 'bvs', 'bcc', 'bcs', 'bne', 'beq',
+          'brk', 'cmp', 'cpx', 'cpy', 'dec', 'eor',
+          'clc', 'sec', 'cli', 'sei', 'clv', 'cld',
+          'sed', 'inc', 'jmp', 'jsr', 'lda', 'ldx',
+          'ldy', 'lsr', 'nop', 'ora', 'tax', 'txa',
+          'dex', 'inx', 'tay', 'tya', 'dey', 'iny',
+          'ror', 'rol', 'rti', 'rts', 'sbc', 'sta',
+          'txs', 'tsx', 'pha', 'pla', 'php', 'plp',
+          'stx', 'sty', 'nil'].include?(first) || first == nil
+        return instr
+      end
+
+      # otherwise, it is a label.
+      first = /\w+/.match(first)[0]
+      new_label(first)
+
+      return instr.sub(/^\S+\s*/, '') # rm label from instr
+    end
+
+    def new_label(name)
+      @labels.member?(name) && (raise 'label already defined')
+      @labels[name] = @pc
+    end
+
+    def defer_value(addr, label)
+      @deferred[addr] = label
+    end
+
+    def process_file(lines)
+      # First pass places machine code and records the locations
+      # of referred-to labels, the values of which we'll need
+      # to write in the second pass.
+      lines.split("\n").each do |line|
+        process_line( line )
+      end
+      # Goes through the saved locations (filled with dummy
+      # values) and writes the real values.
+      @deferred.keys.each do |addr|
+        instr = @memory.get( addr - 1 )
+        # hopefully temporary quickfix
+        if [0x10, 0x30, 0x50, 0x70,
+            0x90, 0xb0, 0xd0, 0xf0].include?(instr)
+          to_addr = label_get( @deferred[addr] )
+          delta = to_addr - addr - 1
+          raise 'bad rel address' unless (-128..127).include? delta
+          value = delta < 0 ? 256 + delta : delta
+          @memory.set( addr, value )
+        else
+          both_bytes = label_get( @deferred[addr] )
+          low_byte = both_bytes & 0x00ff
+          high_byte = both_bytes >> 8
+          @memory.set( addr, low_byte )
+          @memory.set( addr+1, high_byte )
+        end
+      end
+
+    end
+
+  end
+end
+

data/lib/r6502/cpu_execution.rb

@@ -0,0 +1,95 @@
+module R6502
+  class Cpu
+    attr_accessor :mem, :pc, :s, :x, :y, :a
+    attr_accessor :c, :z, :i, :d, :b, :v, :n
+    def initialize(mem)
+      @mem = mem
+      @pc = @mem.get_word(0xfffc)
+      @s  = 0xff
+      @x  = 0x00
+      @y  = 0x00
+      @a  = 0x00
+      @c  = 0
+      @z  = 0
+      @i  = 0
+      @d  = 0
+      @b  = 0
+      @v  = 0
+      @n  = 0
+    end
+    def step
+      instr, mode = instr_mode( mem.get(pc) )
+      arg = decode_arg( mode, mem.get(pc+1), mem.get(pc+2) )
+
+      puts "instr: #{instr} at pc 0x#{pc.to_s(16)} with arg #{arg.to_i.to_s(16)}"
+      method( instr ).call( arg, mode )
+      puts " a: #{a.to_s(16)} x: #{x.to_s(16)} y: #{y.to_s(16)} z: #{z.to_s(16)} n: #{n.to_s(16)} c: #{c.to_s(16)}"
+      puts "==="
+    end
+    def decode_arg(mode, sec_word, thd_word)
+      case mode
+      when :imp
+          nil
+      when :imm
+        sec_word
+      when :zp
+        sec_word
+      when :zpx
+        sec_word + @x
+      when :zpy
+        sec_word + @y
+      when :rel
+        sec_word <= 127 ? sec_word : sec_word - 256
+      when :abs
+        (thd_word<<8) + sec_word
+      when :absx
+        (thd_word<<8) + sec_word + @x
+      when :absy
+        (thd_word<<8) + sec_word + @y
+      when :ind
+        lb = @mem.get( (thd_word<<8) + sec_word )
+        hb = @mem.get( (thd_word<<8) + sec_word + 1 )
+        (hb<<8) + lb
+      when :indx
+        lb = @mem.get( 0xff & (@x + sec_word) )
+        hb = @mem.get( 0xff & (@x + sec_word) + 1 )
+        @mem.get( (hb<<8) + lb )
+      when :indy
+        lb = @mem.get( 0xff & sec_word )
+        hb = @mem.get( 0xff & sec_word + 1)
+        addr = (hb<<8) + lb
+        @mem.get( addr + @y )
+      end
+    end
+    def inc_pc_by_mode(mode)
+      case mode
+      when :imp
+        @pc += 1
+      when :acc
+        @pc += 1
+      when :imm
+        @pc += 2
+      when :zp
+        @pc += 2
+      when :zpx
+        @pc += 2
+      when :zpy
+        @pc += 2
+      when :abs
+        @pc += 3
+      when :absx
+        @pc += 3
+      when :absy
+        @pc += 3
+      when :indx
+        @pc += 2
+      when :indy
+        @pc += 2
+      when :rel
+        @pc += 2
+      when :ind #only used by jmp, which explicitly sets the pc,
+        @pc += 3 #so hopefully this is never used here.
+      end
+    end
+  end
+end

data/lib/r6502/cpu_instructions.rb

@@ -0,0 +1,517 @@
+module R6502
+  class Cpu
+    # add with carry
+    def adc(arg, mode)
+      x = @a
+      y = mode == :imm ? arg : @mem.get(arg)
+      if @d == 0 #normal binary mode
+        r = x + y + @c
+        @a = 0xff & r
+        @v = (((0x7f&x) + (0x7f&y) + @c)>>7) ^ ((x + y + @c)>>8)
+        @z = (r&0xff).zero? ? 1 : 0
+        @c = r > 255 ? 1 : 0
+        @n = (0x80&r)>>7
+      else #BCD mode
+        ones = (0xf&x) + (0xf&y)
+        tens = ((0xf0&x)>>4) + ((0xf0&y)>>4)
+        r0 = ones + 10*tens + @c
+        @c = r0 > 99 ? 1 : 0
+        r = r0 % 100
+        @z = r.zero? ? 1 : 0
+        @a = r + 6*((r/10).floor)
+        @n = (0x80&@a)>>7
+      end
+      inc_pc_by_mode(mode)
+    end
+    # subtract with carry
+    def sbc(arg, mode)
+      x = @a
+      y = mode == :imm ? arg : @mem.get(arg)
+      if @d == 0 #normal binary mode
+        y = (y^0xff)
+        r = x + y + @c
+        @a = 0xff & r
+        @v = (((0x7f&x) + (0x7f&y) + @c)>>7) ^ ((x + y + @c)>>8)
+        @z = (0xff&r).zero? ? 1 : 0
+        @c = r > 255 ? 1 : 0
+        @n = (0x80&r)>>7
+      else #BCD mode
+        ones = (0xf&x) - (0xf&y)
+        tens = ((0xf0&x)>>4) - ((0xf0&y)>>4)
+        r0 = ones + 10*tens - (1 - @c)
+        @c = r0 >= 0 ? 1 : 0
+        r = r0 % 100
+        @z = r.zero? ? 1 : 0
+        @a = r + 6*((r/10).floor)
+        @n = (0x80&@a)>>7
+      end
+      inc_pc_by_mode(mode)
+    end
+    # logical and
+    def and(arg, mode)
+      case mode
+      when :imm
+        @a = @a & arg
+      else
+        @a = @a & @mem.get(arg)
+      end
+      @z = @a.zero? ? 1 : 0
+      @n = @a>>7
+      inc_pc_by_mode(mode)
+    end
+    # shift left
+    def asl(arg, mode)
+      case mode
+      when :acc
+        r = @a<<1
+        @a = r&0xff
+        @z = @a.zero? ? 1 : 0
+        @n = @a>>7
+        @c = r > 0xff ? 1 : 0
+      else
+        r = @mem.get(arg)<<1
+        @mem.set( arg, r&0xff )
+        @z = r.zero? ? 1 : 0
+        @n = r>>7
+        @c = r > 0xff ? 1 : 0
+      end
+      inc_pc_by_mode(mode)
+    end
+    # logical and (result discarded)
+    def bit(arg, mode)
+      m = @mem.get( arg )
+      a = @a
+      result = a & m
+      @z = result.zero? ? 1 : 0
+      @v = (m & 0x40)>>6
+      @n = (m & 0x80)>>7
+      inc_pc_by_mode(mode)
+    end
+    # decrement (memory)
+    def dec(arg, mode)
+      r = @mem.get(arg) - 1
+      @mem.set( arg, r&0xff )
+      @z = r.zero? ? 1 : 0
+      @n = (r&0x80)>>7
+      inc_pc_by_mode(mode)
+    end
+    # decrement (x)
+    def dex(arg, mode)
+      r = @x - 1
+      @x = r&0xff
+      @z = @x.zero? ? 1 : 0
+      @n = (@x&0x80)>>7
+      inc_pc_by_mode(mode)
+    end
+    # decrement (y)
+    def dey(arg, mode)
+      r = @y - 1
+      @y = r&0xff
+      @z = @y.zero? ? 1 : 0
+      @n = (@y&0x80)>>7
+      inc_pc_by_mode(mode)
+    end
+    # exclusive or
+    def eor(arg, mode)
+      case mode
+      when :imm
+        @a = @a ^ arg
+      else
+        @a = @a ^ @mem.get(arg)
+      end
+      @z = @a.zero? ? 1 : 0
+      @n = (@a&0x80)>>7
+      inc_pc_by_mode(mode)
+    end
+    # increment (memory)
+    def inc(arg, mode)
+      r = (@mem.get(arg) + 1)&0xff
+      @mem.set( arg, r )
+      @z = r.zero? ? 1 : 0
+      @n = (r&0x80)>>7
+      inc_pc_by_mode(mode)
+    end
+    # increment (x)
+    def inx(arg, mode)
+      r = (@x + 1)&0xff
+      @x = r
+      @z = r.zero? ? 1 : 0
+      @n = (r&0x80)>>7
+      inc_pc_by_mode(mode)
+    end
+    # increment (y)
+    def iny(arg, mode)
+      r = (@y + 1)&0xff
+      @y = r
+      @z = r.zero? ? 1 : 0
+      @n = (r&0x80)>>7
+      inc_pc_by_mode(mode)
+    end
+    # shift right
+    def lsr(arg, mode)
+      case mode
+      when :acc
+        @c = 0x01&@a
+        @a = @a>>1
+        @z = @a.zero? ? 1 : 0
+        @n = (@a&0x80)>>7 #bit 7 will always be zero, though
+      else
+        v = @mem.get(arg)
+        @c = 0x01&v
+        r = v>>1
+        @z = r.zero? ? 1 : 0
+        @n = (r&0x80)>>7
+        @mem.set( arg, r )
+      end
+      inc_pc_by_mode(mode)
+    end
+    # inclusive or
+    def ora(arg, mode)
+      case mode
+      when :imm
+        @a = @a | arg
+      else
+        @a = @a | @mem.get( arg )
+      end
+      @z = @a.zero? ? 1 : 0
+      @n = (@a&0x80)>>7
+      inc_pc_by_mode(mode)
+    end
+    # rotate left
+    def rol(arg, mode)
+      case mode
+      when :acc
+        c = @c
+        @c = (@a&0x80)>>7
+        @a = 0xff & (@a<<1) | c
+        @z = @a.zero? ? 1 : 0
+        @n = (@a&0x80)>>7
+      else
+        val = @mem.get(arg)
+        c = @c
+        @c = (val&0x80)>>7
+        r = 0xff & (val<<1) | c
+        @z = r.zero? ? 1 : 0
+        @n = (r&0x80)>>7
+        @mem.set(arg, r)
+      end
+      inc_pc_by_mode(mode)
+    end
+    # rotate right
+    def ror(arg, mode)
+      case mode
+      when :acc
+        c = @c
+        @c = @a&0x01
+        @a = (@a>>1) | (c<<7)
+        @z = @a.zero? ? 1 : 0
+        @n = (@a&0x80)>>7
+      else
+        val = @mem.get(arg)
+        c = @c
+        @c = val&0x01
+        r = (val>>1) | (c<<7)
+        @mem.set(arg, r)
+        @z = r.zero? ? 1 : 0
+        @n = (r&0x80)>>7
+      end
+      inc_pc_by_mode(mode)
+    end
+    # no operation
+    def nop(arg, mode)
+      inc_pc_by_mode(mode)
+    end
+    def sec(arg, mode)
+      @c = 1
+      inc_pc_by_mode(mode)
+    end
+    def sed(arg, mode)
+      @d = 1
+      inc_pc_by_mode(mode)
+    end
+    def sei(arg, mode)
+      @i = 1
+      inc_pc_by_mode(mode)
+    end
+    def bcc(arg, mode)
+      inc_pc_by_mode(:rel)
+      @pc += arg if @c == 0
+    end
+    def bcs(arg, mode)
+      inc_pc_by_mode(:rel)
+      @pc += arg if @c == 1
+    end
+    def beq(arg, mode)
+      inc_pc_by_mode(:rel)
+      @pc += arg if @z == 1
+    end
+    def bmi(arg, mode)
+      inc_pc_by_mode(:rel)
+      @pc += arg if @n == 1
+    end
+    def bne(arg, mode)
+      inc_pc_by_mode(:rel)
+      @pc += arg if @z == 0
+    end
+    def bpl(arg, mode)
+      inc_pc_by_mode(:rel)
+      @pc += arg if @n == 0
+    end
+    def bvc(arg, mode)
+      inc_pc_by_mode(:rel)
+      @pc += arg if @v == 0
+    end
+    def bvs(arg, mode)
+      inc_pc_by_mode(:rel)
+      @pc += arg if @v == 1
+    end
+    def clc(arg, mode)
+      @c = 0
+      inc_pc_by_mode(mode)
+    end
+    def cld(arg, mode)
+      @d = 0
+      inc_pc_by_mode(mode)
+    end
+    def cli(arg, mode)
+      @i = 0
+      inc_pc_by_mode(mode)
+    end
+    def clv(arg, mode)
+      @v = 0
+      inc_pc_by_mode(mode)
+    end
+    def cmp(arg, mode)
+      case mode
+      when :imm
+        result = @a - arg
+        @c = result >= 0 ? 1 : 0
+        @z = result == 0 ? 1 : 0
+        @n = (0xff&result)>>7
+      else
+        m = @mem.get( arg )
+        result = @a - m
+        @c = result >= 0 ? 1 : 0
+        @z = result == 0 ? 1 : 0
+        @n = (0xff&result)>>7
+      end
+      inc_pc_by_mode(mode)
+    end
+    def cpx(arg, mode)
+      case mode
+      when :imm
+        result = @x - arg
+        @c = result >= 0 ? 1 : 0
+        @z = result == 0 ? 1 : 0
+        @n = (0xff&result)>>7
+      else
+        m = @mem.get( arg )
+        result = @x - m
+        @c = result >= 0 ? 1 : 0
+        @z = result == 0 ? 1 : 0
+        @n = (0xff&result)>>7
+      end
+      inc_pc_by_mode(mode)
+    end
+    def cpy(arg, mode)
+      case mode
+      when :imm
+        result = @y - arg
+        @c = result >= 0 ? 1 : 0
+        @z = result == 0 ? 1 : 0
+        @n = (0xff&result)>>7
+      else
+        m = @mem.get( arg )
+        result = @y - m
+        @c = result >= 0 ? 1 : 0
+        @z = result == 0 ? 1 : 0
+        @n = (0xff&result)>>7
+      end
+      inc_pc_by_mode(mode)
+    end
+    def jmp(arg, mode)
+      case mode
+      when :abs
+        @pc = arg
+      else #indirect
+        lsb = @mem.get( arg )
+        msb = @mem.get( arg + 1)
+        @pc = lsb + msb<<8
+      end
+    end
+    def lda(arg, mode)
+      case mode
+      when :imm
+        @a = arg
+      else
+        @a = @mem.get( arg )
+      end
+      @z = @a.zero? ? 1 : 0
+      @n = (0x80&@a)>>7
+      inc_pc_by_mode(mode)
+    end
+    def ldx(arg, mode)
+      case mode
+      when :imm
+        @x = arg
+      else
+        @x = @mem.get( arg )
+      end
+      @z = @x.zero? ? 1 : 0
+      @n = (0x80&@x)>>7
+      inc_pc_by_mode(mode)
+    end
+    def ldy(arg, mode)
+      case mode
+      when :imm
+        @y = arg
+      else
+        @y = @mem.get( arg )
+      end
+      @z = @y.zero? ? 1 : 0
+      @n = (0x80&@y)>>7
+      inc_pc_by_mode(mode)
+    end
+    def pha(arg, mode)
+      addr = 0x0100 + (0xff & @s)
+      @mem.set( addr, @a )
+      @s -= 1
+      inc_pc_by_mode(mode)
+    end
+    def pla(arg, mode)
+      addr = 0x0100 + (0xff & (@s + 1))
+      @a = @mem.get( addr )
+      @s += 1
+      @z = @a.zero? ? 1 : 0
+      @n = (0x80&@a)>>7
+      inc_pc_by_mode(mode)
+    end
+    def php(arg, mode)
+      addr = 0x0100 + (0xff & @s)
+      val =            @n #bit 7
+      val = (val<<1) + @v #bit 6
+      val = (val<<1) +  1 #bit 5
+      val = (val<<1) + @b #bit 4
+      val = (val<<1) + @d #bit 3
+      val = (val<<1) + @i #bit 2
+      val = (val<<1) + @z #bit 1
+      val = (val<<1) + @c #bit 0
+
+      @mem.set( addr, val )
+      @s -= 1
+      inc_pc_by_mode(mode)
+    end
+    def plp(arg, mode)
+      addr = 0x0100 + (0xff & (@s + 1))
+      val = @mem.get( addr )
+      @c = 0x1 & val
+      @z = 0x1 & (val>>1)
+      @i = 0x1 & (val>>2)
+      @d = 0x1 & (val>>3)
+      @b = 0x1 & (val>>4)
+      # bit 5
+      @v = 0x1 & (val>>6)
+      @n = 0x1 & (val>>7)
+      inc_pc_by_mode(mode)
+    end
+    def sta(arg, mode)
+      @mem.set( arg, @a )
+      inc_pc_by_mode(mode)
+    end
+    def stx(arg, mode)
+      @mem.set( arg, @x )
+      inc_pc_by_mode(mode)
+    end
+    def sty(arg, mode)
+      @mem.set( arg, @y )
+      inc_pc_by_mode(mode)
+    end
+    def tax(arg, mode)
+      @x = @a
+      @z = @x.zero? ? 1 : 0
+      @n = (0x80&@x)>>7
+      inc_pc_by_mode(mode)
+    end
+    def tay(arg, mode)
+      @y = @a
+      @z = @y.zero? ? 1 : 0
+      @n = (0x80&@y)>>7
+      inc_pc_by_mode(mode)
+    end
+    def tsx(arg, mode)
+      @x = @s
+      @z = @x.zero? ? 1 : 0
+      @n = (0x80&@x)>>7
+      inc_pc_by_mode(mode)
+    end
+    def txa(arg, mode)
+      @a = @x
+      @z = @a.zero? ? 1 : 0
+      @n = (0x80&@a)>>7
+      inc_pc_by_mode(mode)
+    end
+    def txs(arg, mode)
+      @s = @x
+      inc_pc_by_mode(mode)
+    end
+    def tya(arg, mode)
+      @a = @y
+      @z = @a.zero? ? 1 : 0
+      @n = (0x80&@a)>>7
+      inc_pc_by_mode(mode)
+    end
+    def brk(arg, mode)
+      @mem.set(0x0100 + @s, @pc>>8)
+      @s -= 1
+      @mem.set(0x0100 + @s, (0xff&@pc))
+      @s -= 1
+      val =            @n #bit 7
+      val = (val<<1) + @v #bit 6
+      val = (val<<1) +  1 #bit 5
+      val = (val<<1) +  1 #bit 4 break flag
+      val = (val<<1) + @d #bit 3
+      val = (val<<1) + @i #bit 2
+      val = (val<<1) + @z #bit 1
+      val = (val<<1) + @c #bit 0
+      @mem.set(0x0100 + @s, val)
+      @s -= 1
+
+      lo = @mem.get(0xfffe)
+      hi = @mem.get(0xffff)
+      @pc = (hi<<8) + lo
+    end
+    def rti( arg, mode )
+      flags = @mem.get(0x0100 + @s + 1)
+      @s += 1
+
+      @c = 0x1 & flags
+      @z = 0x1 & (flags>>1)
+      @i = 0x1 & (flags>>2)
+      @d = 0x1 & (flags>>3)
+      @b = 0x1 & (flags>>4)
+      # bit 5
+      @v = 0x1 & (flags>>6)
+      @n = 0x1 & (flags>>7)
+
+      hi = @mem.get(0x0100 + @s + 1)
+      @s += 1
+      lo = @mem.get(0x0100 + @s + 1)
+      @s += 1
+      @pc = 0xffff&((hi<<8) + lo)
+    end
+    def jsr( arg, mode )
+      @mem.set(0x0100 + @s, @pc>>8)
+      @s -= 1
+      @mem.set(0x0100 + @s, (0xff&@pc) + 2)
+      @s -= 1
+      @pc = arg
+    end
+    def rts( arg, mode )
+      hi = @mem.get(0x0100 + @s + 1)
+      @s += 1
+      lo = @mem.get(0x0100 + @s + 1)
+      @s += 1
+      @pc = 0xffff&((hi<<8) + lo + 1)
+    end
+  end
+end