ruby6502 0.1.0

data/ext/ruby6502/fake6502.h

@@ -0,0 +1,20 @@
+#ifndef FAKE6502
+#define FAKE6502
+
+void reset6502();
+void step6502();
+void exec6502(uint32_t tickcount);
+void nmi6502();
+void irq6502();
+void hookexternal(void *funcptr);
+
+uint16_t getPC();
+uint8_t getSP();
+uint8_t getA();
+uint8_t getX();
+uint8_t getY();
+uint8_t getStatus();
+uint32_t getInstructions();
+uint64_t getTicks();
+
+#endif

data/ext/ruby6502/ruby6502.c

@@ -0,0 +1,253 @@
+#include <stdlib.h>
+#include <time.h>
+#include <stdint.h>
+#include <ruby.h>
+#include "fake6502.h"
+
+static VALUE mRuby6502;
+uint8_t has_instruction_hooks = 0;
+uint8_t has_read_write_hooks = 0;
+
+uint16_t rng_hook_address = 0;
+
+#define MEMSIZE 0x10000
+uint8_t MEMORY[MEMSIZE] = {0};
+
+static VALUE program_counter(VALUE self)
+{
+  return UINT2NUM(getPC());
+}
+
+static VALUE stack_pointer(VALUE self)
+{
+  return UINT2NUM(getSP());
+}
+
+static VALUE a_register(VALUE self)
+{
+  return UINT2NUM(getA());
+}
+
+static VALUE x_register(VALUE self)
+{
+  return UINT2NUM(getX());
+}
+
+static VALUE y_register(VALUE self)
+{
+  return UINT2NUM(getY());
+}
+
+static VALUE status_flags(VALUE self)
+{
+  return UINT2NUM(getStatus());
+}
+
+static VALUE instruction_count(VALUE self)
+{
+  return ULONG2NUM(getInstructions());
+}
+
+static VALUE tick_count(VALUE self)
+{
+  return ULL2NUM(getTicks());
+}
+
+static VALUE reset(VALUE self)
+{
+  reset6502();
+  return Qtrue;
+}
+
+static VALUE interrupt_request(VALUE self)
+{
+  irq6502();
+  return Qtrue;
+}
+
+static VALUE non_maskable_interrupt(VALUE self)
+{
+  nmi6502();
+  return Qtrue;
+}
+
+static VALUE step(VALUE self)
+{
+  step6502();
+  return instruction_count(self);
+}
+
+static VALUE step_times(VALUE self, VALUE stepCount)
+{
+  int steps = NUM2INT(stepCount);
+  for(int i = 0; i < steps; ++i) {
+    step6502();
+  }
+
+  return instruction_count(self);
+}
+
+static VALUE exec(VALUE self, VALUE tickCount)
+{
+  exec6502((uint32_t) NUM2ULONG(tickCount));
+  return instruction_count(self);
+}
+
+static VALUE memory_size(VALUE self)
+{
+  return UINT2NUM(MEMSIZE);
+}
+
+static uint8_t read_address(uint16_t address)
+{
+  if ( address >= 0 && address < MEMSIZE ) {
+    return MEMORY[address];
+  } else return 0;
+}
+
+uint8_t read6502(uint16_t address)
+{
+
+  if ( has_read_write_hooks ) {
+    rb_funcall(mRuby6502, rb_intern("execute_read_write_hook"), 2, UINT2NUM(address), ID2SYM(rb_intern("read")));
+  }
+
+  return read_address(address);
+}
+
+static VALUE read_byte(VALUE self, VALUE location)
+{
+  uint16_t address;
+
+  address = (uint16_t) NUM2UINT(location);
+
+  return UINT2NUM(read_address(address));
+}
+
+static void write_address(uint16_t address, uint8_t value)
+{
+  if ( address >= 0 && address < MEMSIZE ) {
+    MEMORY[address] = value;
+  }
+}
+
+void write6502(uint16_t address, uint8_t value)
+{
+  if ( has_read_write_hooks ) {
+    rb_funcall(mRuby6502, rb_intern("execute_read_write_hook"), 2, INT2NUM(address), ID2SYM(rb_intern("write")));
+  }
+
+  write_address(address, value);
+}
+
+static VALUE load_byte(VALUE self, VALUE location, VALUE r_value)
+{
+  uint16_t address;
+  uint8_t value;
+
+  address = (uint16_t) NUM2UINT(location);
+  value = (uint8_t) NUM2UINT(r_value);
+
+  write_address(address, value);
+
+  return location;
+}
+
+static VALUE set_instruction_hooks(VALUE self)
+{
+  has_instruction_hooks = 1;
+  return Qtrue;
+}
+
+static VALUE unset_instruction_hooks(VALUE self)
+{
+  has_instruction_hooks = 0;
+  return Qtrue;
+}
+
+static VALUE get_has_instruction_hooks(VALUE self)
+{
+  if ( has_instruction_hooks ) {
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
+}
+
+static VALUE set_read_write_hooks(VALUE self)
+{
+  has_read_write_hooks = 1;
+  return Qtrue;
+}
+
+static VALUE unset_read_write_hooks(VALUE self)
+{
+  has_read_write_hooks = 0;
+  return Qtrue;
+}
+
+static VALUE get_has_read_write_hooks(VALUE self)
+{
+  if ( has_read_write_hooks ) {
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
+}
+
+static VALUE configure_rng(VALUE self, VALUE location) {
+  uint16_t address;
+
+  address = (uint16_t) NUM2UINT(location);
+
+  if ( address > 0 && address < MEMSIZE ) {
+    rng_hook_address = address;
+  }
+}
+
+void execute_instruction_hooks() {
+  if ( rng_hook_address ) {
+    write_address(rng_hook_address, (uint8_t) rand());
+  }
+
+  if ( has_instruction_hooks ) {
+    rb_funcall(mRuby6502, rb_intern("execute_instruction_hooks"), 0);
+  }
+}
+
+void Init_ruby6502()
+{
+  mRuby6502 = rb_define_module("Ruby6502");
+  rb_define_singleton_method(mRuby6502, "memory_size", memory_size, 0);
+  rb_define_singleton_method(mRuby6502, "read_byte", read_byte, 1);
+  rb_define_singleton_method(mRuby6502, "load_byte", load_byte, 2);
+
+  rb_define_singleton_method(mRuby6502, "program_counter", program_counter, 0);
+  rb_define_singleton_method(mRuby6502, "stack_pointer", stack_pointer, 0);
+  rb_define_singleton_method(mRuby6502, "a_register", a_register, 0);
+  rb_define_singleton_method(mRuby6502, "x_register", x_register, 0);
+  rb_define_singleton_method(mRuby6502, "y_register", y_register, 0);
+  rb_define_singleton_method(mRuby6502, "status_flags", status_flags, 0);
+  rb_define_singleton_method(mRuby6502, "instruction_count", instruction_count, 0);
+  rb_define_singleton_method(mRuby6502, "tick_count", tick_count, 0);
+
+  rb_define_singleton_method(mRuby6502, "set_instruction_hooks", set_instruction_hooks, 0);
+  rb_define_singleton_method(mRuby6502, "unset_instruction_hooks", unset_instruction_hooks, 0);
+  rb_define_singleton_method(mRuby6502, "instruction_hooks?", get_has_instruction_hooks, 0);
+  rb_define_singleton_method(mRuby6502, "configure_rng", configure_rng, 1);
+
+  rb_define_singleton_method(mRuby6502, "set_read_write_hooks", set_read_write_hooks, 0);
+  rb_define_singleton_method(mRuby6502, "unset_read_write_hooks", unset_read_write_hooks, 0);
+  rb_define_singleton_method(mRuby6502, "read_write_hooks?", get_has_read_write_hooks, 0);
+
+  rb_define_singleton_method(mRuby6502, "reset", reset, 0);
+  rb_define_singleton_method(mRuby6502, "interrupt_request", interrupt_request, 0);
+  rb_define_singleton_method(mRuby6502, "non_maskable_interrupt", non_maskable_interrupt, 0);
+  rb_define_singleton_method(mRuby6502, "step", step, 0);
+  rb_define_singleton_method(mRuby6502, "step_times", step_times, 1);
+  rb_define_singleton_method(mRuby6502, "exec", exec, 1);
+
+  hookexternal(execute_instruction_hooks);
+
+  srand ((unsigned int) time (NULL));
+}

data/lib/ruby6502/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Ruby6502
+  VERSION = "0.1.0"
+end

data/lib/ruby6502.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "ruby6502/ruby6502"
+
+module Ruby6502
+  INSTRUCTION_HOOKS = []
+  READ_WRITE_HOOKS = {}
+
+  class << self
+    def load(bytearray, location: 0)
+      byte_size = bytearray.size
+      location = location.to_i
+
+      if location < 0
+        raise "Cannot load to a negative memory location"
+      end
+
+      if memory_size < location + byte_size
+        raise "Loading #{byte_size} bytes to #{format("%04x", location)} would overflow memory"
+      end
+
+      bytearray.each do |byte|
+        byte_to_load = byte.to_i & 0xff
+        load_byte(location, byte_to_load)
+        location += 1
+      end
+    end
+
+    def read(location:, bytes:)
+      location = location.to_i
+      bytes = bytes.to_i
+
+      unless location >= 0 && location < memory_size
+        raise "#{location} is outside memory bounds"
+      end
+
+      unless bytes >= 0
+        raise "Must read a positive number of bytes"
+      end
+
+      raise "#{format("%04x", location + bytes)} is outside bounds" if location + bytes > memory_size
+
+      bytes.times.map do |byte|
+        read_byte(location + byte)
+      end
+    end
+
+    def register_instruction_hook(&hook)
+      set_instruction_hooks unless instruction_hooks?
+      INSTRUCTION_HOOKS << hook
+    end
+
+    def clear_instruction_hooks
+      unset_instruction_hooks
+      INSTRUCTION_HOOKS.clear
+    end
+
+    def register_read_write_hook(location, read_or_write, &hook)
+      read_or_write = read_or_write.to_sym
+      unless [:read, :write, :read_write].include?(read_or_write)
+        raise "#{read_or_write} must be one of :read, :write, :read_write"
+      end
+
+      set_read_write_hooks unless read_write_hooks?
+
+      if read_or_write == :read_write
+        READ_WRITE_HOOKS[[location, :read]] = hook
+        READ_WRITE_HOOKS[[location, :write]] = hook
+      else
+        READ_WRITE_HOOKS[[location, read_or_write]] = hook
+      end
+    end
+
+    def deregister_read_write_hook(location, read_or_write)
+      if read_or_write == :read_write
+        READ_WRITE_HOOKS.delete([location, :read])
+        READ_WRITE_HOOKS.delete([location, :write])
+      else
+        READ_WRITE_HOOKS.delete([location, read_or_write])
+      end
+
+      unset_read_write_hooks if READ_WRITE_HOOKS.empty?
+    end
+
+    private :read_byte, :load_byte, :set_instruction_hooks, :unset_instruction_hooks, :instruction_hooks?,
+      :set_read_write_hooks, :unset_read_write_hooks, :read_write_hooks?
+
+    def execute_instruction_hooks
+      INSTRUCTION_HOOKS.each(&:call)
+    end
+
+    def execute_read_write_hook(location, read_or_write)
+      READ_WRITE_HOOKS[[location, read_or_write]]&.call(read_or_write)
+    end
+  end
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: ruby6502
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kyle Tate
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-07-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.31'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.31'
+- !ruby/object:Gem::Dependency
+  name: rubocop-shopify
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.8'
+description: A Ruby emulator for the 6502. The 6502 is powered by http://rubbermallet.org/fake6502.c
+email: kbt.tate@gmail.com
+executables: []
+extensions:
+- ext/ruby6502/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/ruby6502/extconf.rb
+- ext/ruby6502/fake6502.c
+- ext/ruby6502/fake6502.h
+- ext/ruby6502/ruby6502.c
+- lib/ruby6502.rb
+- lib/ruby6502/version.rb
+homepage: https://github.com/infiton/ruby6502
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key:
+specification_version: 4
+summary: Ruby 6502 emulator
+test_files: []