NCPrePatcher 0.2.0-arm64-darwin-23 → 0.3.1-arm64-darwin-23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a03184e1276f20cc90dcd3381650b1bbe52a7e91f211bea078a7a1efa9b6262
-  data.tar.gz: 06d1a6c30b148086de8fe2f1141a986c37c33cb40c7cf2721cb767158ff23b84
+  metadata.gz: 37692a1442bcc5997344dc3f71242341872479f65af528919b0c839470282f80
+  data.tar.gz: 47e53518bad77f58a88e4595c51344eafa80d8a71359b0f7757f4e20d961790d
 SHA512:
-  metadata.gz: 52e113dd581e24a588fefe89c7752969a2273e692a87fce274f4c31f114b4a4acbb633b03d7d6bb37548f1dbb597312fe90e6bb3927141610c6786763c49a9d5
-  data.tar.gz: 859f6af14ba5a640a8f97920daf6b77d81ad836903433d64544f30370752e9e2c2dc1b7694a1fdc3a9414d0ea9967b0c7b0f46ee589869930cdb607103f686c8
+  metadata.gz: 3ee086281238d3e3a4d17fa7a09c7832f715fda726c3f8f2095f80593d272015d785ada46ec39983692fad698d96b5ac61d73b9b64882f4982f5bde23ef8aae6
+  data.tar.gz: ed9396fa204a4a376bf9577261f26b1a9d26aae045d3ff58f5118717efdc5a3418bb2910f7cf52e9273c472be27a3a30fd06b7efa0a284411c3593ff569b21f5

data/README.md

@@ -1,6 +1,6 @@
 # NCPrePatcher
 
-A preprocessor for [NCPatcher](https://github.com/TheGameratorT/NCPatcher) with access to your NDS ROM and a disassembler.
+A preprocessor for [NCPatcher](https://github.com/TheGameratorT/NCPatcher) with access to your NDS ROM, a disassembler, an assembler, and an emulator.
 
 ## Installation
 
@@ -8,9 +8,9 @@ A preprocessor for [NCPatcher](https://github.com/TheGameratorT/NCPatcher) with
 
 - [Ruby (≥ 3.4 required)](https://www.ruby-lang.org/en/downloads/)
 
-Go to Releases, download the .gem file for your platform, then open up the command line where it was downloaded to and enter:
+From the command line, enter:
 ```console
-gem install NCPrePatcher-[version]-[platform].gem
+gem install NCPrePatcher
 ```
 
 The `ncpp` command should now be available at your command line (a system reboot may be required).
@@ -47,13 +47,19 @@ ncpp --help
 - Ruby
 - CMake and a modern C++ compiler
 - Rust and Cargo
+- vcpkg
 
-To build the required native libraries, go to /ext/ and run:
+To build the nitro and unarm native libraries, go to /ext/ and run:
 ```console
 ruby build.rb
 ```
 
-Then go back to the base directory and run:
+To build the unicorn and keystone native libraries run:
+```console
+vcpkg install unicorn keystone --triplet [your platform]-dynamic
+```
+
+Move the built binaries to `lib/unicorn` and `lib/keystone` respectively, and finally, go back to the base directory and run:
 ```console
 gem build ncpp.gemspec
 ```
@@ -63,4 +69,6 @@ gem build ncpp.gemspec
 - Code from NCPatcher used by the **nitro** library
 - [unarm](https://github.com/AetiasHax/unarm) used for disassembling
 - [Ruby-FFI](https://github.com/ffi/ffi) used for binding the above libraries to Ruby
-- [Parslet](https://github.com/kschiess/parslet) used for parsing the DSL
+- [Parslet](https://github.com/kschiess/parslet) used for parsing the DSL
+- [Unicorn](https://github.com/unicorn-engine/unicorn/tree/master) used for emulating
+- [Keystone](https://github.com/keystone-engine/keystone/tree/master) used for assembling

data/lib/keystone/arm_const.rb

@@ -0,0 +1,7 @@
+# For Keystone Engine. AUTO-GENERATED FILE, DO NOT EDIT [arm_const.rb]
+
+module Keystone
+  KS_ERR_ASM_ARM_INVALIDOPERAND = 512
+  KS_ERR_ASM_ARM_MISSINGFEATURE = 513
+  KS_ERR_ASM_ARM_MNEMONICFAIL = 514
+end

data/lib/keystone/keystone.rb

@@ -0,0 +1,76 @@
+require 'ffi'
+
+require_relative 'arm_const.rb'
+require_relative 'keystone_const.rb'
+require_relative 'version.rb'
+
+module KeystoneBind
+  extend FFI::Library
+  ffi_lib [
+    File.expand_path("keystone", __dir__),
+    File.expand_path("keystone.dylib", __dir__),
+    File.expand_path("keystone.so", __dir__),
+  ]
+
+  typedef :pointer, :ks_engine
+  typedef :pointer, :ks_engine_handle
+  typedef :uint, :ks_arch
+  typedef :uint, :ks_err
+  typedef :uint, :ks_opt_type
+
+  attach_function :ks_version, [:pointer, :pointer], :uint
+  attach_function :ks_arch_supported, [:ks_arch], :bool
+  attach_function :ks_open, [:ks_arch, :int, :ks_engine_handle], :ks_err
+  attach_function :ks_close, [:ks_engine], :ks_err
+  attach_function :ks_errno, [:ks_engine], :ks_err
+  attach_function :ks_strerror, [:ks_err], :string
+  attach_function :ks_option, [:ks_engine, :ks_opt_type, :size_t], :ks_err
+  attach_function :ks_asm, [:ks_engine, :string, :uint64, :pointer, :pointer, :pointer], :int
+  attach_function :ks_free, [:pointer], :void
+end
+
+module Keystone
+  extend KeystoneBind
+
+  def self.major_version
+    ks_version(nil, nil)
+  end
+
+  def self.arch_supported?(ks_arch)
+    ks_arch_supported(ks_arch)
+  end
+
+  class Assembler
+    include KeystoneBind
+
+    def initialize(arch: KS_ARCH_ARM, mode: KS_MODE_ARM)
+
+      FFI::MemoryPointer.new(:pointer,1) do |ptr|
+        safe_call(:ks_open, arch, mode, ptr)
+        @engine = FFI::AutoPointer.new(ptr.read_pointer, method(:ks_close))
+      end
+    end
+
+    def assemble(asm_str, addr: 0)
+      encoding_ptr = FFI::MemoryPointer.new(:pointer)
+      encoding_size = FFI::MemoryPointer.new(:size_t)
+      stat_count = FFI::MemoryPointer.new(:size_t)
+      safe_call(:ks_asm, @engine, asm_str, addr, encoding_ptr, encoding_size, stat_count)
+      encoded_bytes = encoding_ptr.read_pointer.read_array_of_uint8(encoding_size.read_uint)
+      ks_free(encoding_ptr.read_pointer)
+      encoded_bytes.pack('C*')
+    end
+
+    def set_option(ks_opt_type, value)
+      safe_call(:ks_option, @engine, ks_opt_type, value)
+    end
+
+  private
+    def safe_call(meth_sym, *args)
+      err = send(meth_sym, *args)
+      raise "Error from #{meth_sym}: #{ks_strerror(err)}" if err != KS_ERR_OK
+    end
+  end
+end
+
+Ks = Keystone

data/lib/keystone/keystone_const.rb

@@ -0,0 +1,97 @@
+# For Keystone Engine. AUTO-GENERATED FILE, DO NOT EDIT [keystone_const.rb]
+
+module Keystone
+  KS_API_MAJOR = 0
+  KS_API_MINOR = 9
+  KS_VERSION_MAJOR = 0
+  KS_VERSION_MINOR = 9
+  KS_VERSION_EXTRA = 2
+  KS_ARCH_ARM = 1
+  KS_ARCH_ARM64 = 2
+  KS_ARCH_MIPS = 3
+  KS_ARCH_X86 = 4
+  KS_ARCH_PPC = 5
+  KS_ARCH_SPARC = 6
+  KS_ARCH_SYSTEMZ = 7
+  KS_ARCH_HEXAGON = 8
+  KS_ARCH_EVM = 9
+  KS_ARCH_RISCV = 10
+  KS_ARCH_MAX = 11
+  KS_MODE_LITTLE_ENDIAN = 0
+  KS_MODE_BIG_ENDIAN = 1073741824
+  KS_MODE_ARM = 1
+  KS_MODE_THUMB = 16
+  KS_MODE_V8 = 64
+  KS_MODE_MICRO = 16
+  KS_MODE_MIPS3 = 32
+  KS_MODE_MIPS32R6 = 64
+  KS_MODE_MIPS32 = 4
+  KS_MODE_MIPS64 = 8
+  KS_MODE_16 = 2
+  KS_MODE_32 = 4
+  KS_MODE_64 = 8
+  KS_MODE_PPC32 = 4
+  KS_MODE_PPC64 = 8
+  KS_MODE_QPX = 16
+  KS_MODE_RISCV32 = 4
+  KS_MODE_RISCV64 = 8
+  KS_MODE_SPARC32 = 4
+  KS_MODE_SPARC64 = 8
+  KS_MODE_V9 = 16
+  KS_ERR_ASM = 128
+  KS_ERR_ASM_ARCH = 512
+  KS_ERR_OK = 0
+  KS_ERR_NOMEM = 1
+  KS_ERR_ARCH = 2
+  KS_ERR_HANDLE = 3
+  KS_ERR_MODE = 4
+  KS_ERR_VERSION = 5
+  KS_ERR_OPT_INVALID = 6
+  KS_ERR_ASM_EXPR_TOKEN = 128
+  KS_ERR_ASM_DIRECTIVE_VALUE_RANGE = 129
+  KS_ERR_ASM_DIRECTIVE_ID = 130
+  KS_ERR_ASM_DIRECTIVE_TOKEN = 131
+  KS_ERR_ASM_DIRECTIVE_STR = 132
+  KS_ERR_ASM_DIRECTIVE_COMMA = 133
+  KS_ERR_ASM_DIRECTIVE_RELOC_NAME = 134
+  KS_ERR_ASM_DIRECTIVE_RELOC_TOKEN = 135
+  KS_ERR_ASM_DIRECTIVE_FPOINT = 136
+  KS_ERR_ASM_DIRECTIVE_UNKNOWN = 137
+  KS_ERR_ASM_DIRECTIVE_EQU = 138
+  KS_ERR_ASM_DIRECTIVE_INVALID = 139
+  KS_ERR_ASM_VARIANT_INVALID = 140
+  KS_ERR_ASM_EXPR_BRACKET = 141
+  KS_ERR_ASM_SYMBOL_MODIFIER = 142
+  KS_ERR_ASM_SYMBOL_REDEFINED = 143
+  KS_ERR_ASM_SYMBOL_MISSING = 144
+  KS_ERR_ASM_RPAREN = 145
+  KS_ERR_ASM_STAT_TOKEN = 146
+  KS_ERR_ASM_UNSUPPORTED = 147
+  KS_ERR_ASM_MACRO_TOKEN = 148
+  KS_ERR_ASM_MACRO_PAREN = 149
+  KS_ERR_ASM_MACRO_EQU = 150
+  KS_ERR_ASM_MACRO_ARGS = 151
+  KS_ERR_ASM_MACRO_LEVELS_EXCEED = 152
+  KS_ERR_ASM_MACRO_STR = 153
+  KS_ERR_ASM_MACRO_INVALID = 154
+  KS_ERR_ASM_ESC_BACKSLASH = 155
+  KS_ERR_ASM_ESC_OCTAL = 156
+  KS_ERR_ASM_ESC_SEQUENCE = 157
+  KS_ERR_ASM_ESC_STR = 158
+  KS_ERR_ASM_TOKEN_INVALID = 159
+  KS_ERR_ASM_INSN_UNSUPPORTED = 160
+  KS_ERR_ASM_FIXUP_INVALID = 161
+  KS_ERR_ASM_LABEL_INVALID = 162
+  KS_ERR_ASM_FRAGMENT_INVALID = 163
+  KS_ERR_ASM_INVALIDOPERAND = 512
+  KS_ERR_ASM_MISSINGFEATURE = 513
+  KS_ERR_ASM_MNEMONICFAIL = 514
+  KS_OPT_SYNTAX = 1
+  KS_OPT_SYM_RESOLVER = 2
+  KS_OPT_SYNTAX_INTEL = 1
+  KS_OPT_SYNTAX_ATT = 2
+  KS_OPT_SYNTAX_NASM = 4
+  KS_OPT_SYNTAX_MASM = 8
+  KS_OPT_SYNTAX_GAS = 16
+  KS_OPT_SYNTAX_RADIX16 = 32
+end

data/lib/keystone/version.rb

@@ -0,0 +1,3 @@
+module KeystoneEngine
+	VERSION = '0.9.2'
+end

data/lib/ncpp/commands.rb

@@ -206,6 +206,9 @@ module NCPP
     hex: ->(i) { Utils.integer_check(i,'hex'); i.to_hex }.returns(String)
       .describe('Returns a hexadecimal representation of the given Integer.'),
 
+    ord: ->(s) { s.ord }.returns(Integer)
+      .describe('Gets the Integer ordinal of the first character in the given String.'),
+
     string: ->(x) { String(x) }.returns(String)
       .describe('Gets the given argument as a String.'),
 
@@ -587,6 +590,7 @@ module NCPP
     exp: ->(n) { Math.exp(n) }.returns(Float).describe('Gets e raised to the power of the given number.'),
     log: ->(n) { Math.log(n) }.returns(Float).describe('Gets the base logarithm of the given number.'),
     sqrt: ->(n) { Math.sqrt(n) }.returns(Float).describe('Gets the square root of the given number.'),
+    round: ->(f, n_digits=0) { f.round(n_digits) }.returns(Numeric),
     clamp: ->(n, min,max=nil) { n.clamp(min,max) }.returns(Numeric)
       .describe('Clamps number between given min and max values.'),
 
@@ -644,7 +648,7 @@ module NCPP
                 "the original ASM with the immediate swapped to the value given."),
 
     repl_array: ->(loc, ov, dtype, arr) { Utils.gen_repl_array(loc,ov,dtype,arr) }.returns(String),
-    
+
     repl_u64_array: ->(loc,ov_or_arr,arr=nil) { Utils.gen_repl_type_array(loc, ov_or_arr, :u64, arr) }.returns(String),
     repl_s64_array: ->(loc,ov_or_arr,arr=nil) { Utils.gen_repl_type_array(loc, ov_or_arr, :s64, arr) }.returns(String),
     repl_u32_array: ->(loc,ov_or_arr,arr=nil) { Utils.gen_repl_type_array(loc, ov_or_arr, :u32, arr) }.returns(String),
@@ -677,11 +681,15 @@ module NCPP
     get_signed_byte:  ->(addr,ov=nil) { Utils.get_signed_byte(addr,ov) }.returns(Integer),
     get_cstring: ->(addr,ov=nil) { Utils.get_cstring(addr,ov) }.returns(String),
     get_array: ->(addr,ov,e_type_id,e_count=1) { Utils.get_array(addr,ov,e_type_id,e_count) }.returns(Array),
+    get_chars: ->(addr,ov, char_count) { Utils.get_array(addr,ov,Utils::DTYPE_IDS[:u8],char_count).map { it.chr } }
+      .returns(Array),
 
     get_c_array: ->(addr,ov,e_type_id,e_count=1) {
       Utils.to_c_array(Utils.get_array(addr,ov,e_type_id,e_count))
     }.returns(Array),
 
+    get_byte_str: ->(loc,ov,size) { Utils.get_byte_str(loc,ov,size) }.returns(String),
+
     find_first_branch_to: ->(branch_dest, start_loc,start_ov=nil) {
       Utils.find_branch_to(branch_dest, start_loc,start_ov)
     }.returns(Integer),
@@ -772,6 +780,14 @@ module NCPP
     s16: ->(n) { n.signed(16)   }.returns(Integer).describe('Gets the given number as a signed 16-bit Integer.'),
     u8: ->(n)  { n.unsigned(8)  }.returns(Integer).describe('Gets the given number as an unsigned 8-bit Integer.'),
     s8: ->(n)  { n.signed(8)    }.returns(Integer).describe('Gets the given number as a signed 8-bit Integer.'),
+    char: ->(n) { n.unsigned(8).chr }.returns(String).describe('Gets the given number as an ASCII character.'),
+
+    sizeof: ->(dtype) { Utils::DTYPES[dtype][:size] }.returns(Integer),
+
+    f32: ->(n) { [n].pack('g').unpack('L>') }.returns(Integer),
+    f64: ->(n) { [n].pack('G').unpack('Q>') }.returns(Integer),
+    from_f32: ->(n) { [n].pack('L>').unpack('g')[0] }.returns(Float),
+    from_f64: ->(n) { [n].pack('Q>').unpack('G')[0] }.returns(Float),
 
     from_fx_deg: ->(fx_num) {
       Float(fx_num) / 0x10000 * 360
@@ -794,7 +810,36 @@ module NCPP
     from_gx_rgb: ->(n) { [(n >> 0) & 31, (n >> 5) & 31, (n >> 10) & 31] }.returns(Array)
       .describe('Unpacks the given RGB x1B5G5R5 value as an Array ([R,G,B]).'),
     from_gx_rgba: ->(n) { [(n >> 0) & 31, (n >> 5) & 31, (n >> 10) & 31, (n >> 15) & 1] }.returns(Array)
-      .describe('Unpacks the given packed RGB A1B5G5R5 value as an Array ([R,G,B,A]).')
+      .describe('Unpacks the given packed RGB A1B5G5R5 value as an Array ([R,G,B,A]).'),
+
+    pack_u64_array: ->(arr) { arr.pack('Q*') }.returns(String),
+    pack_u32_array: ->(arr) { arr.pack('L*') }.returns(String),
+    pack_u16_array: ->(arr) { arr.pack('S*') }.returns(String),
+    pack_u8_array: ->(arr) { arr.pack('C*') }.returns(String),
+    pack_s64_array: ->(arr) { arr.pack('q*') }.returns(String),
+    pack_s32_array: ->(arr) { arr.pack('l*') }.returns(String),
+    pack_s16_array: ->(arr) { arr.pack('s*') }.returns(String),
+    pack_s8_array: ->(arr) { arr.pack('c*') }.returns(String),
+
+    unpack_u64_array: ->(byte_str) { byte_str.unpack('Q*') }.returns(Array),
+    unpack_u32_array: ->(byte_str) { byte_str.unpack('L*') }.returns(Array),
+    unpack_u16_array: ->(byte_str) { byte_str.unpack('S*') }.returns(Array),
+    unpack_u8_array: ->(byte_str) { byte_str.unpack('C*') }.returns(Array),
+    unpack_s64_array: ->(byte_str) { byte_str.unpack('q*') }.returns(Array),
+    unpack_s32_array: ->(byte_str) { byte_str.unpack('l*') }.returns(Array),
+    unpack_s16_array: ->(byte_str) { byte_str.unpack('s*') }.returns(Array),
+    unpack_s8_array: ->(byte_str) { byte_str.unpack('c*') }.returns(Array),
+
+    emulate_func: ->(loc,ov,*args) { Utils.emulate_func(loc,ov,*args) }.returns(Object).impure,
+    emu_get_reg: ->(reg_s) { $emu.read_reg(reg_s.to_sym) }.returns(Integer).impure,
+    emu_set_reg: ->(reg_s,val) { $emu.write_reg(reg_s.to_sym,val) }.impure,
+    emu_get_mem: ->(loc,size) { Utils.emu_get_mem(loc,size) }.returns(String).impure,
+    emu_set_mem: ->(loc,byte_str) { Utils.emu_set_mem(loc,byte_str) }.impure,
+    emu_load_ov: ->(ov_id) { $emu.load_overlay(ov_id) }.impure,
+    emu_reset: -> { $emu = Uc::Emu.new(); $emu.load_arm9 }.impure,
+
+    assemble_arm: ->(asm,addr=0) { Utils.assemble_arm(asm,addr:addr) }.returns(Integer),
+    assemble_thumb: ->(asm,addr=0) { Utils.assemble_thumb(asm,addr:addr) }.returns(Integer),
 
   },
 
@@ -839,6 +884,7 @@ module NCPP
     get_s8:        :get_signed_byte,
     get_cstr:      :get_cstring,
     disasm_ins:    :disasm_arm_ins,
+    disasm:        :disasm_arm_ins,
     disasm_hex_seq: :disasm_arm_hex_seq,
     disasm_hex_str: :disasm_arm_hex_seq,
     disasm_arm_hex_str: :disasm_arm_hex_seq,
@@ -876,7 +922,34 @@ module NCPP
     is_addr_in_ov:                :is_address_in_overlay,
     is_addr_in_arm9:              :is_address_in_arm9,
     is_addr_in_arm7:              :is_address_in_arm7,
-    find_hex_seq:                 :find_hex_bytes
+    find_hex_seq:                 :find_hex_bytes,
+    pack_u64_arr:                 :pack_u64_array,
+    pack_u32_arr:                 :pack_u32_array,
+    pack_u16_arr:                 :pack_u16_array,
+    pack_u8_arr:                  :pack_u8_array,
+    pack_s64_arr:                 :pack_s64_array,
+    pack_s32_arr:                 :pack_s32_array,
+    pack_s16_arr:                 :pack_s16_array,
+    pack_s8_arr:                  :pack_s8_array,
+    unpack_u64_arr:               :unpack_u64_array,
+    unpack_u32_arr:               :unpack_u32_array,
+    unpack_u16_arr:               :unpack_u16_array,
+    unpack_u8_arr:                :unpack_u8_array,
+    unpack_s64_arr:               :unpack_s64_array,
+    unpack_s32_arr:               :unpack_s32_array,
+    unpack_s16_arr:               :unpack_s16_array,
+    unpack_s8_arr:                :unpack_s8_array,
+    emulate_function:             :emulate_func,
+    emu_call_func:                :emulate_func,
+    emu_get_register:             :emu_get_reg,
+    emu_set_register:             :emu_set_reg,
+    emu_get_memory:               :emu_get_mem,
+    emu_set_memory:               :emu_set_mem,
+    emu_load_overlay:             :emu_load_ov,
+    assemble:                     :assemble_arm,
+    assemble_ins:                 :assemble_arm,
+    assemble_arm_ins:             :assemble_arm,
+    assemble_thumb_ins:           :assemble_thumb
   }).freeze
 
 

data/lib/ncpp/interpreter.rb

@@ -170,7 +170,8 @@ module NCPP
         def:           :define,
         desc:          :describe,
         get_cmd_names: :get_command_names,
-        get_var_names: :get_variable_names
+        get_var_names: :get_variable_names,
+        clear_cache:   :invalidate_cache
       }).freeze
     end
 

data/lib/ncpp/utils.rb

@@ -1,5 +1,6 @@
 require_relative '../nitro/nitro.rb'
 require_relative '../unarm/unarm.rb'
+require_relative '../unicorn/unicorn.rb'
 
 require 'did_you_mean/jaro_winkler'
 require 'did_you_mean/levenshtein'
@@ -265,6 +266,11 @@ module NCPP
       end
     end
 
+    def self.get_byte_str(loc, ov, size)
+      addr, _ov, code_bin = resolve_code_loc(loc, ov)
+      code_bin.get_sect_ptr(addr,size).read_array_of_uint8(size).pack('C*')
+    end
+
     def self.find_branch_to(branch_dest, start_loc, start_ov=nil, from_func: false, find_all: false)
       start_addr, _ov, code_bin = resolve_code_loc(start_loc, start_ov)
       if branch_dest.is_a? Array
@@ -423,6 +429,40 @@ module NCPP
       gen_repl_array(addr, ov, DTYPE_IDS[:u8], [new_hex_str].pack('H*').unpack('C*'))
     end
 
+    def self.emulate_func(func_loc, ov, *args)
+      addr, ov, code_bin = resolve_code_loc(func_loc,ov)
+      $emu.load_overlay(ov) if !ov.nil? && ov >= 0
+      $emu.call_func(addr, *args)
+    end
+
+    def self.emu_get_mem(loc, size)
+      addr, ov = resolve_loc(loc)
+      $emu.load_overlay(ov) if !ov.nil? && ov >= 0
+      $emu.read_mem(addr, size)
+    end
+
+    def self.emu_set_mem(loc, byte_str)
+      addr, ov = resolve_loc(loc)
+      $emu.load_overlay(ov) if !ov.nil? && ov >= 0
+      $emu.write_mem(addr, byte_str)
+    end
+
+    def self.assemble_arm(asm, addr: 0)
+      if asm.is_a? Array
+        asm.map.with_index {|ins,idx| $arm_assembler.assemble(ins,addr+4*idx).unpack('L')[0] }
+      else
+        $arm_assembler.assemble(asm).unpack('L')[0]
+      end
+    end
+
+    def self.assemble_thumb(asm, addr: 0)
+      if asm.is_a? Array
+        asm.map.with_index {|ins,idx| $thumb_assembler.assemble(ins,addr+2*idx).unpack('S')[0] }
+      else
+        $thumb_assembler.assemble(asm).unpack('S')[0]
+      end
+    end
+
     class << self
       alias_method :get_u64,  :get_dword
       alias_method :get_u32,  :get_word
@@ -596,7 +636,7 @@ class Nitro::CodeBin
 
       instructions << ins
 
-      if target = ins.target_addr
+      if target = ins.target_addr # if target addr not nil
         pool[target] ||= Unarm::Data.new(read_word(target), addr: target, loc: get_loc)
       end
 
@@ -698,3 +738,44 @@ class Nitro::CodeBin
   end
 
 end
+
+#
+# Various utility methods tying Unicorn to the Unarm and Nitro modules
+#
+class Unicorn::Emulator
+
+  def load_arm9
+    arm = $rom.arm9
+    main_added = false
+    arm.autoload_entries.sort_by {|e| e[:address] }.each do |e|
+      if e[:address] > arm.end_addr # DTCM found
+        add_region(Uc::Region.new(e[:address], 16*1024))
+        next
+      end
+      if !main_added && e[:address] > arm.start_addr # Main section found
+        size = e[:address] - arm.start_addr
+        add_section(Uc::Sect.new(arm.start_addr, arm.get_sect_ptr(arm.start_addr,size), size))
+        main_added = true
+      end
+      next if e[:address]+e[:size] <= e[:address]
+      ptr = arm.get_sect_ptr(e[:address],e[:size])
+      add_section(Uc::Sect.new(e[:address], ptr, e[:size]))
+    end
+  end
+
+  def load_overlay(ov_id)
+    ov = $rom.get_overlay(ov_id)
+    add_section(Uc::Sect.new(ov.start_addr, ov.get_sect_ptr(ov.start_addr, ov.size), ov.size))
+  end
+  alias_method :load_ov, :load_overlay
+
+  def call_func(addr, *args)
+    raise "Calling functions with more than 4 args isn't supported yet" if args.length > 4
+    args.each_with_index do |arg,i|
+      send(:"write_r#{i}", arg)
+    end
+    run(from: addr, to: read_lr, timeout_ms: 5000)
+    read_r0
+  end
+
+end

data/lib/ncpp/version.rb

@@ -1,4 +1,4 @@
 
 module NCPP
-  VERSION = '0.2.0'
+  VERSION = '0.3.1'
 end

data/lib/ncpp.rb

@@ -1,5 +1,7 @@
 require_relative 'nitro/nitro.rb'
 require_relative 'unarm/unarm.rb'
+require_relative 'unicorn/unicorn.rb'
+require_relative 'keystone/keystone.rb'
 require_relative 'ncpp/interpreter.rb'
 
 require 'json'
@@ -15,6 +17,10 @@ module NCPP
 
   alias $rom $clean_rom # In most cases the clean rom will be desired
 
+  $emu = nil
+  $arm_assembler = nil
+  $thumb_assembler = nil
+
   $config = nil
 
   NCP_CONFIG_FILE_PATH   = 'ncpatcher.json'
@@ -141,6 +147,11 @@ module NCPP
 
     Unarm.load_symbols9(cfg['symbols9'].gsub(/\$\{env:([^}]+)\}/) { ENV[$1] }) unless cfg['symbols9'].empty?
     Unarm.load_symbols7(cfg['symbols7'].gsub(/\$\{env:([^}]+)\}/) { ENV[$1] }) unless cfg['symbols7'].empty?
+
+    $emu = Uc::Emu.new
+    $emu.load_arm9
+    $arm_assembler = Ks::Assembler.new
+    $thumb_assembler = Ks::Assembler.new(mode: Ks::KS_MODE_THUMB)
   end
 
   def self.uninstall(cfg_path = CONFIG_FILE_PATH)
@@ -426,20 +437,6 @@ module NCPP
         end
       end
 
-      # interpreter = CFileInterpreter.new(
-      #   files, $config['gen_path'], $config['command_prefix'], extra_commands, extra_variables,
-      #   safe: safe_mode, puritan: puritan_mode
-      # )
-      # interpreter.run(verbose: !quiet)
-      # lines_parsed += interpreter.lines_parsed
-
-      # unless interpreter.incomplete_files.empty?
-      #   interpreter.incomplete_files.each do |file|
-      #     timestamp_cache.delete(file)
-      #     success = false
-      #   end
-      # end
-
     end
 
     timestamp_cache['NCPP_VERSION'] = VERSION
@@ -447,9 +444,6 @@ module NCPP
     FileUtils.mkdir_p(File.dirname(timestamp_cache_path))
     File.write(timestamp_cache_path, JSON.generate(timestamp_cache))
 
-    # FileUtils.mkdir_p(File.dirname(cmd_cache_path))
-    # File.write(cmd_cache_path, JSON.generate(command_cache))
-
     unless quiet
       if lines_parsed > 0
         msg = "\nParsed #{lines_parsed} line#{'s' if lines_parsed != 1} across " \

data/lib/nitro/nitro.rb

@@ -13,6 +13,7 @@ module NitroBind
   typedef :pointer, :codebin_handle
   typedef :pointer, :ovte_handle
   typedef :pointer, :module_params_handle
+  typedef :pointer, :autoload_entry_handle
 
   attach_function :nitroRom_alloc, [], :rom_handle
   attach_function :nitroRom_release, [:rom_handle], :void
@@ -48,12 +49,15 @@ module NitroBind
   attach_function :codeBin_readCString, [:codebin_handle, :uint32], :string
   attach_function :codeBin_getSize, [:codebin_handle], :uint32
   attach_function :codeBin_getStartAddress, [:codebin_handle], :uint32
+  attach_function :codeBin_getSectPtr, [:codebin_handle, :uint32, :size_t], :pointer
 
   attach_function :armBin_alloc, [], :codebin_handle
   attach_function :armBin_release, [:codebin_handle], :void
   attach_function :armBin_load, [:codebin_handle, :string, :uint32, :uint32, :uint32, :bool], :bool
   attach_function :armBin_getEntryPointAddress, [:codebin_handle], :uint32
   attach_function :armBin_getModuleParams, [:codebin_handle], :module_params_handle
+  attach_function :armBin_getAutoloadEntry, [:codebin_handle, :size_t], :autoload_entry_handle
+  attach_function :armBin_getAutoloadEntryCount, [:codebin_handle], :size_t
   attach_function :armBin_sanityCheckAddress, [:codebin_handle, :uint32], :bool
 
   attach_function :overlayBin_alloc, [], :codebin_handle
@@ -176,7 +180,7 @@ module Nitro
       raise ArgumentError, 'step must be 1, 2, 4, or 8 (bytes)' unless [1,2,4,8].include? step
       raise ArgumentError, 'range must be a Range' unless range.is_a? Range
 
-      clamped = Range.new([range.begin || start_addr, start_addr].max, [range.end || end_addr, end_addr].min)
+      clamped = Range.new(range.begin || start_addr, [range.end || end_addr, end_addr].min)
 
       clamped.step(step).map { |addr| [send(:"read#{step * 8}", addr), addr] }
     end
@@ -211,17 +215,25 @@ module Nitro
       end
     end
 
-    def read_cstring(start_addr)
-      codeBin_readCString(@ptr, start_addr)
+    def read_cstring(addr)
+      codeBin_readCString(@ptr, addr)
     end
     alias_method :read_cstr, :read_cstring
 
+    def get_section_ptr(addr, sect_size)
+      ptr = FFI::MemoryPointer.new(:pointer, 1)
+      ptr.write_pointer(codeBin_getSectPtr(@ptr, addr, sect_size))
+      raise "Could not read #{sect_size} bytes from address #{addr.to_hex}" if ptr.read_pointer == FFI::Pointer::NULL
+      ptr.read_pointer
+    end
+    alias_method :get_sect_ptr, :get_section_ptr
+
   end
 
   class ArmBin < CodeBin
     include NitroBind
 
-    attr_reader :module_params
+    attr_reader :module_params, :autoload_entries
 
     class ModuleParams < FFI::Struct
       layout :autoload_list_start, :uint32,
@@ -235,10 +247,17 @@ module Nitro
              :nitro_code_le,       :uint32
     end
 
+    class AutoLoadEntry < FFI::Struct
+      layout :address,     :uint32,
+             :size,        :uint32,
+             :bss_size,    :uint32,
+             :data_offset, :uint32
+    end
+
     def initialize(args = {})
       if args.has_key? :file_path
         @ptr = FFI::AutoPointer.new(armBin_alloc, method(:armBin_release))
-        if not File.exist? args[:file_path]
+        if !File.exist?(args[:file_path])
           puts "Error: #{args[:file_path]} does not exist"
           raise 'ArmBin initialization failed'
         end
@@ -253,6 +272,9 @@ module Nitro
       end
 
       @module_params = ModuleParams.new(armBin_getModuleParams(@ptr))
+      @autoload_entries = []
+      autoload_entry_count = armBin_getAutoloadEntryCount(@ptr)
+      autoload_entry_count.times {|id| autoload_entries << AutoLoadEntry.new(armBin_getAutoloadEntry(@ptr,id)) }
     end
 
     def entry_point_address

data/lib/unicorn/arm_const.rb

@@ -0,0 +1,196 @@
+# For Unicorn Engine. AUTO-GENERATED FILE, DO NOT EDIT [arm_const.rb]
+
+module UnicornEngine
+
+# ARM CPU
+
+  UC_CPU_ARM_926 = 0
+  UC_CPU_ARM_946 = 1
+  UC_CPU_ARM_1026 = 2
+  UC_CPU_ARM_1136_R2 = 3
+  UC_CPU_ARM_1136 = 4
+  UC_CPU_ARM_1176 = 5
+  UC_CPU_ARM_11MPCORE = 6
+  UC_CPU_ARM_CORTEX_M0 = 7
+  UC_CPU_ARM_CORTEX_M3 = 8
+  UC_CPU_ARM_CORTEX_M4 = 9
+  UC_CPU_ARM_CORTEX_M7 = 10
+  UC_CPU_ARM_CORTEX_M33 = 11
+  UC_CPU_ARM_CORTEX_R5 = 12
+  UC_CPU_ARM_CORTEX_R5F = 13
+  UC_CPU_ARM_CORTEX_A7 = 14
+  UC_CPU_ARM_CORTEX_A8 = 15
+  UC_CPU_ARM_CORTEX_A9 = 16
+  UC_CPU_ARM_CORTEX_A15 = 17
+  UC_CPU_ARM_TI925T = 18
+  UC_CPU_ARM_SA1100 = 19
+  UC_CPU_ARM_SA1110 = 20
+  UC_CPU_ARM_PXA250 = 21
+  UC_CPU_ARM_PXA255 = 22
+  UC_CPU_ARM_PXA260 = 23
+  UC_CPU_ARM_PXA261 = 24
+  UC_CPU_ARM_PXA262 = 25
+  UC_CPU_ARM_PXA270 = 26
+  UC_CPU_ARM_PXA270A0 = 27
+  UC_CPU_ARM_PXA270A1 = 28
+  UC_CPU_ARM_PXA270B0 = 29
+  UC_CPU_ARM_PXA270B1 = 30
+  UC_CPU_ARM_PXA270C0 = 31
+  UC_CPU_ARM_PXA270C5 = 32
+  UC_CPU_ARM_MAX = 33
+  UC_CPU_ARM_ENDING = 34
+
+# ARM registers
+
+  UC_ARM_REG_INVALID = 0
+  UC_ARM_REG_APSR = 1
+  UC_ARM_REG_APSR_NZCV = 2
+  UC_ARM_REG_CPSR = 3
+  UC_ARM_REG_FPEXC = 4
+  UC_ARM_REG_FPINST = 5
+  UC_ARM_REG_FPSCR = 6
+  UC_ARM_REG_FPSCR_NZCV = 7
+  UC_ARM_REG_FPSID = 8
+  UC_ARM_REG_ITSTATE = 9
+  UC_ARM_REG_LR = 10
+  UC_ARM_REG_PC = 11
+  UC_ARM_REG_SP = 12
+  UC_ARM_REG_SPSR = 13
+  UC_ARM_REG_D0 = 14
+  UC_ARM_REG_D1 = 15
+  UC_ARM_REG_D2 = 16
+  UC_ARM_REG_D3 = 17
+  UC_ARM_REG_D4 = 18
+  UC_ARM_REG_D5 = 19
+  UC_ARM_REG_D6 = 20
+  UC_ARM_REG_D7 = 21
+  UC_ARM_REG_D8 = 22
+  UC_ARM_REG_D9 = 23
+  UC_ARM_REG_D10 = 24
+  UC_ARM_REG_D11 = 25
+  UC_ARM_REG_D12 = 26
+  UC_ARM_REG_D13 = 27
+  UC_ARM_REG_D14 = 28
+  UC_ARM_REG_D15 = 29
+  UC_ARM_REG_D16 = 30
+  UC_ARM_REG_D17 = 31
+  UC_ARM_REG_D18 = 32
+  UC_ARM_REG_D19 = 33
+  UC_ARM_REG_D20 = 34
+  UC_ARM_REG_D21 = 35
+  UC_ARM_REG_D22 = 36
+  UC_ARM_REG_D23 = 37
+  UC_ARM_REG_D24 = 38
+  UC_ARM_REG_D25 = 39
+  UC_ARM_REG_D26 = 40
+  UC_ARM_REG_D27 = 41
+  UC_ARM_REG_D28 = 42
+  UC_ARM_REG_D29 = 43
+  UC_ARM_REG_D30 = 44
+  UC_ARM_REG_D31 = 45
+  UC_ARM_REG_FPINST2 = 46
+  UC_ARM_REG_MVFR0 = 47
+  UC_ARM_REG_MVFR1 = 48
+  UC_ARM_REG_MVFR2 = 49
+  UC_ARM_REG_Q0 = 50
+  UC_ARM_REG_Q1 = 51
+  UC_ARM_REG_Q2 = 52
+  UC_ARM_REG_Q3 = 53
+  UC_ARM_REG_Q4 = 54
+  UC_ARM_REG_Q5 = 55
+  UC_ARM_REG_Q6 = 56
+  UC_ARM_REG_Q7 = 57
+  UC_ARM_REG_Q8 = 58
+  UC_ARM_REG_Q9 = 59
+  UC_ARM_REG_Q10 = 60
+  UC_ARM_REG_Q11 = 61
+  UC_ARM_REG_Q12 = 62
+  UC_ARM_REG_Q13 = 63
+  UC_ARM_REG_Q14 = 64
+  UC_ARM_REG_Q15 = 65
+  UC_ARM_REG_R0 = 66
+  UC_ARM_REG_R1 = 67
+  UC_ARM_REG_R2 = 68
+  UC_ARM_REG_R3 = 69
+  UC_ARM_REG_R4 = 70
+  UC_ARM_REG_R5 = 71
+  UC_ARM_REG_R6 = 72
+  UC_ARM_REG_R7 = 73
+  UC_ARM_REG_R8 = 74
+  UC_ARM_REG_R9 = 75
+  UC_ARM_REG_R10 = 76
+  UC_ARM_REG_R11 = 77
+  UC_ARM_REG_R12 = 78
+  UC_ARM_REG_S0 = 79
+  UC_ARM_REG_S1 = 80
+  UC_ARM_REG_S2 = 81
+  UC_ARM_REG_S3 = 82
+  UC_ARM_REG_S4 = 83
+  UC_ARM_REG_S5 = 84
+  UC_ARM_REG_S6 = 85
+  UC_ARM_REG_S7 = 86
+  UC_ARM_REG_S8 = 87
+  UC_ARM_REG_S9 = 88
+  UC_ARM_REG_S10 = 89
+  UC_ARM_REG_S11 = 90
+  UC_ARM_REG_S12 = 91
+  UC_ARM_REG_S13 = 92
+  UC_ARM_REG_S14 = 93
+  UC_ARM_REG_S15 = 94
+  UC_ARM_REG_S16 = 95
+  UC_ARM_REG_S17 = 96
+  UC_ARM_REG_S18 = 97
+  UC_ARM_REG_S19 = 98
+  UC_ARM_REG_S20 = 99
+  UC_ARM_REG_S21 = 100
+  UC_ARM_REG_S22 = 101
+  UC_ARM_REG_S23 = 102
+  UC_ARM_REG_S24 = 103
+  UC_ARM_REG_S25 = 104
+  UC_ARM_REG_S26 = 105
+  UC_ARM_REG_S27 = 106
+  UC_ARM_REG_S28 = 107
+  UC_ARM_REG_S29 = 108
+  UC_ARM_REG_S30 = 109
+  UC_ARM_REG_S31 = 110
+  UC_ARM_REG_C1_C0_2 = 111
+  UC_ARM_REG_C13_C0_2 = 112
+  UC_ARM_REG_C13_C0_3 = 113
+  UC_ARM_REG_IPSR = 114
+  UC_ARM_REG_MSP = 115
+  UC_ARM_REG_PSP = 116
+  UC_ARM_REG_CONTROL = 117
+  UC_ARM_REG_IAPSR = 118
+  UC_ARM_REG_EAPSR = 119
+  UC_ARM_REG_XPSR = 120
+  UC_ARM_REG_EPSR = 121
+  UC_ARM_REG_IEPSR = 122
+  UC_ARM_REG_PRIMASK = 123
+  UC_ARM_REG_BASEPRI = 124
+  UC_ARM_REG_BASEPRI_MAX = 125
+  UC_ARM_REG_FAULTMASK = 126
+  UC_ARM_REG_APSR_NZCVQ = 127
+  UC_ARM_REG_APSR_G = 128
+  UC_ARM_REG_APSR_NZCVQG = 129
+  UC_ARM_REG_IAPSR_NZCVQ = 130
+  UC_ARM_REG_IAPSR_G = 131
+  UC_ARM_REG_IAPSR_NZCVQG = 132
+  UC_ARM_REG_EAPSR_NZCVQ = 133
+  UC_ARM_REG_EAPSR_G = 134
+  UC_ARM_REG_EAPSR_NZCVQG = 135
+  UC_ARM_REG_XPSR_NZCVQ = 136
+  UC_ARM_REG_XPSR_G = 137
+  UC_ARM_REG_XPSR_NZCVQG = 138
+  UC_ARM_REG_CP_REG = 139
+  UC_ARM_REG_ESR = 140
+  UC_ARM_REG_ENDING = 141
+
+# alias registers
+  UC_ARM_REG_R13 = 12
+  UC_ARM_REG_R14 = 10
+  UC_ARM_REG_R15 = 11
+  UC_ARM_REG_SB = 75
+  UC_ARM_REG_SL = 76
+  UC_ARM_REG_FP = 77
+  UC_ARM_REG_IP = 78
+end

data/lib/unicorn/unicorn.rb

@@ -0,0 +1,204 @@
+require 'ffi'
+
+require_relative 'arm_const.rb'
+require_relative 'unicorn_const.rb'
+
+include UnicornEngine
+
+module UnicornBind
+  extend FFI::Library
+  ffi_lib [
+    File.expand_path("unicorn", __dir__),
+    File.expand_path("unicorn.dylib", __dir__),
+    File.expand_path("unicorn.so", __dir__),
+  ]
+
+  typedef :pointer, :uc_engine        # ptr to uc_engine instance
+  typedef :pointer, :uc_engine_handle # ptr to a uc_engine ptr
+  typedef :pointer, :reg_val_ptr
+  typedef :pointer, :reg_val_ptr_arr
+  typedef :pointer, :reg_id_arr
+  typedef :uint64,  :addr
+  typedef :uint,    :uc_arch
+  typedef :uint,    :uc_mode
+  typedef :uint,    :uc_err
+  typedef :uint,    :uc_query_type
+  typedef :uint,    :uc_control_type
+  typedef :int,     :reg_id
+
+  attach_function :uc_version, [:pointer,:pointer], :uint
+  attach_function :uc_arch_supported, [:uc_arch], :bool
+  attach_function :uc_open, [:uc_arch, :uc_mode, :uc_engine_handle], :uc_err
+  attach_function :uc_close, [:uc_engine], :uc_err
+  attach_function :uc_query, [:uc_engine, :uc_query_type, :pointer], :uc_err
+  attach_function :uc_ctl, [:uc_engine, :uc_control_type, :varargs], :uc_err
+  attach_function :uc_errno, [:uc_engine], :uc_err
+  attach_function :uc_strerror, [:uc_err], :string
+  attach_function :uc_reg_write, [:uc_engine, :reg_id, :reg_val_ptr], :uc_err
+  attach_function :uc_reg_read, [:uc_engine, :reg_id, :reg_val_ptr], :uc_err
+  attach_function :uc_reg_write_batch, [:uc_engine, :reg_id_arr, :reg_val_ptr_arr, :int], :uc_err
+  attach_function :uc_reg_read_batch, [:uc_engine, :reg_id_arr, :reg_val_ptr_arr, :int], :uc_err
+  attach_function :uc_mem_write, [:uc_engine, :addr, :pointer, :uint64], :uc_err
+  attach_function :uc_mem_read, [:uc_engine, :addr, :pointer, :uint64], :uc_err
+  attach_function :uc_emu_start, [:uc_engine, :addr, :addr, :uint64, :size_t], :uc_err
+  attach_function :uc_emu_stop, [:uc_engine], :uc_err
+  attach_function :uc_mem_map, [:uc_engine, :addr, :uint64, :uint32], :uc_err
+  attach_function :uc_mem_map_ptr, [:uc_engine, :addr, :uint64, :uint32, :pointer], :uc_err
+  attach_function :uc_mem_unmap, [:uc_engine, :addr, :uint64], :uc_err
+  attach_function :uc_mem_protect, [:uc_engine, :addr, :uint64, :uint32], :uc_err
+
+  REG_ID = {
+    r0:   UC_ARM_REG_R0,
+    r1:   UC_ARM_REG_R1,
+    r2:   UC_ARM_REG_R2,
+    r3:   UC_ARM_REG_R3,
+    r4:   UC_ARM_REG_R4,
+    r5:   UC_ARM_REG_R5,
+    r6:   UC_ARM_REG_R6,
+    r7:   UC_ARM_REG_R7,
+    r8:   UC_ARM_REG_R8,
+    r9:   UC_ARM_REG_R9,
+    r10:  UC_ARM_REG_R10,
+    r11:  UC_ARM_REG_R11,
+    r12:  UC_ARM_REG_R12,
+    sp:   UC_ARM_REG_SP,
+    lr:   UC_ARM_REG_LR,
+    pc:   UC_ARM_REG_PC,
+    cpsr: UC_ARM_REG_CPSR,
+    spsr: UC_ARM_REG_SPSR
+  }.freeze
+end
+
+module Unicorn
+  extend UnicornBind
+
+  class Region
+    attr_reader :addr, :size, :prot, :end_addr
+    def initialize(addr, size, prot = UC_PROT_ALL)
+      @addr = addr
+      @size = size
+      @prot = prot
+      @end_addr = addr + size
+    end
+  end
+
+  NDS_REGIONS = [
+    Region.new(0x1ff8000, 32*1024),      # ITCM         -> 32KB
+    Region.new(0x2000000, 4*1024*1024),  # Main memory  -> 4MB
+    Region.new(0x4000000, 64*1024*1024), # I/O and VRAM -> 64MB
+    Region.new(0xffff000, 32*1024)       # BIOS         -> 32KB
+  ].freeze
+
+  class Section
+    attr_reader :addr, :ptr, :size, :end_addr
+    def initialize(addr, ffi_ptr, size)
+      @addr = addr
+      @ptr = ffi_ptr
+      @size = size
+      @end_addr = addr + size
+    end
+  end
+  Sect = Section
+
+  class Emulator
+    include UnicornBind
+
+    def initialize(arch: UC_ARCH_ARM, mode: UC_MODE_ARM946, regions: NDS_REGIONS, sections: [], registers: {})
+
+      FFI::MemoryPointer.new(:pointer, 1) do |ptr|
+        safe_call(:uc_open, arch, mode, ptr)
+        @engine = FFI::AutoPointer.new(ptr.read_pointer, method(:uc_close))
+      end
+
+      regions.each { add_region(it) } unless regions.empty?
+      sections.each { add_sect(it) } unless sections.empty?
+      registers.each {|r,v| write_register(r,v) } unless registers.empty?
+    end
+
+    def run(from: nil, to: -1, timeout_ms: 0, max_ins: 0)
+      raise "The 'from' parameter must be specified" if from.nil?
+      if to == -1 && timeout_ms == 0 && max_ins == 0
+        raise "The 'to' parameter must be specified if 'timeout_ms' or 'max_ins' are not"
+      end
+      safe_call(:uc_emu_start, @engine, from, to, timeout_ms, max_ins)
+    end
+
+    def add_region(region)
+      safe_call(:uc_mem_map, @engine, region.addr, region.size, region.prot)
+    end
+
+    def add_section(sect)
+      safe_call(:uc_mem_write, @engine, sect.addr, sect.ptr, sect.size)
+    end
+    alias_method :add_sect, :add_section
+
+    def write_mem(addr, byte_str)
+      FFI::MemoryPointer.new(:uint8, byte_str.bytesize) do |ptr|
+        ptr.write_array_of_uint8(byte_str.bytes)
+        safe_call(:uc_mem_write, @engine, addr, ptr, byte_str.bytesize)
+      end
+    end
+
+    def read_mem(addr, size)
+      byte_str = nil
+      FFI::MemoryPointer.new(:uint8, size) do |ptr|
+        safe_call(:uc_mem_read, @engine, addr, ptr, size)
+        byte_str = ptr.read_array_of_uint8(size).pack('C*')
+      end
+      byte_str
+    end
+
+    def write_register(reg, val)
+      FFI::MemoryPointer.new(:int32, 1) do |pv|
+        pv.write_int(val)
+        safe_call(:uc_reg_write, @engine, REG_ID[reg], pv)
+      end
+    end
+    alias_method :write_reg, :write_register
+
+    def write_registers(regs_h)
+      regs_h.each {|r,v| write_register(r,v) }
+    end
+    alias_method :write_regs, :write_registers
+
+    REG_ID.each do |name, id|
+      define_method("write_#{name.to_s}".to_sym) do |val|
+        write_register(name, val)
+      end
+    end
+
+    def read_register(reg)
+      val = nil
+      FFI::MemoryPointer.new(:int32, 1) do |pv|
+        safe_call(:uc_reg_read, @engine, REG_ID[reg], pv)
+        val = pv.read_int32
+      end
+      val
+    end
+    alias_method :read_reg, :read_register
+
+    def read_registers(reg_names = REG_ID.keys)
+      regs_h = {}
+      reg_names.each {|r| regs_h[r] = read_register(r) }
+      regs_h
+    end
+    alias_method :read_regs, :read_registers
+
+    REG_ID.each do |name, id|
+      define_method("read_#{name.to_s}".to_sym) do
+        read_register(name)
+      end
+    end
+
+  private
+    def safe_call(meth_sym, *args)
+      err = send(meth_sym, *args)
+      raise "Error from #{meth_sym.to_s}: #{uc_strerror(err)}" if err != UC_ERR_OK
+    end
+  end
+
+  Emu = Emulator
+
+end
+
+Uc = Unicorn

data/lib/unicorn/unicorn_const.rb

@@ -0,0 +1,152 @@
+# For Unicorn Engine. AUTO-GENERATED FILE, DO NOT EDIT [unicorn_const.rb]
+
+module UnicornEngine
+  UC_API_MAJOR = 2
+  UC_API_MINOR = 1
+  UC_API_PATCH = 4
+  UC_API_EXTRA = 255
+  UC_VERSION_MAJOR = 2
+  UC_VERSION_MINOR = 1
+  UC_VERSION_PATCH = 4
+  UC_VERSION_EXTRA = 255
+  UC_SECOND_SCALE = 1000000
+  UC_MILISECOND_SCALE = 1000
+  UC_ARCH_ARM = 1
+  UC_ARCH_ARM64 = 2
+  UC_ARCH_MIPS = 3
+  UC_ARCH_X86 = 4
+  UC_ARCH_PPC = 5
+  UC_ARCH_SPARC = 6
+  UC_ARCH_M68K = 7
+  UC_ARCH_RISCV = 8
+  UC_ARCH_S390X = 9
+  UC_ARCH_TRICORE = 10
+  UC_ARCH_MAX = 11
+
+  UC_MODE_LITTLE_ENDIAN = 0
+  UC_MODE_BIG_ENDIAN = 1073741824
+
+  UC_MODE_ARM = 0
+  UC_MODE_THUMB = 16
+  UC_MODE_MCLASS = 32
+  UC_MODE_V8 = 64
+  UC_MODE_ARMBE8 = 1024
+  UC_MODE_ARM926 = 128
+  UC_MODE_ARM946 = 256
+  UC_MODE_ARM1176 = 512
+  UC_MODE_MICRO = 16
+  UC_MODE_MIPS3 = 32
+  UC_MODE_MIPS32R6 = 64
+  UC_MODE_MIPS32 = 4
+  UC_MODE_MIPS64 = 8
+  UC_MODE_16 = 2
+  UC_MODE_32 = 4
+  UC_MODE_64 = 8
+  UC_MODE_PPC32 = 4
+  UC_MODE_PPC64 = 8
+  UC_MODE_QPX = 16
+  UC_MODE_SPARC32 = 4
+  UC_MODE_SPARC64 = 8
+  UC_MODE_V9 = 16
+  UC_MODE_RISCV32 = 4
+  UC_MODE_RISCV64 = 8
+
+  UC_ERR_OK = 0
+  UC_ERR_NOMEM = 1
+  UC_ERR_ARCH = 2
+  UC_ERR_HANDLE = 3
+  UC_ERR_MODE = 4
+  UC_ERR_VERSION = 5
+  UC_ERR_READ_UNMAPPED = 6
+  UC_ERR_WRITE_UNMAPPED = 7
+  UC_ERR_FETCH_UNMAPPED = 8
+  UC_ERR_HOOK = 9
+  UC_ERR_INSN_INVALID = 10
+  UC_ERR_MAP = 11
+  UC_ERR_WRITE_PROT = 12
+  UC_ERR_READ_PROT = 13
+  UC_ERR_FETCH_PROT = 14
+  UC_ERR_ARG = 15
+  UC_ERR_READ_UNALIGNED = 16
+  UC_ERR_WRITE_UNALIGNED = 17
+  UC_ERR_FETCH_UNALIGNED = 18
+  UC_ERR_HOOK_EXIST = 19
+  UC_ERR_RESOURCE = 20
+  UC_ERR_EXCEPTION = 21
+  UC_ERR_OVERFLOW = 22
+
+  UC_PROT_NONE = 0
+  UC_PROT_READ = 1
+  UC_PROT_WRITE = 2
+  UC_PROT_EXEC = 4
+  UC_PROT_ALL = 7
+  UC_MEM_READ = 16
+  UC_MEM_WRITE = 17
+  UC_MEM_FETCH = 18
+  UC_MEM_READ_UNMAPPED = 19
+  UC_MEM_WRITE_UNMAPPED = 20
+  UC_MEM_FETCH_UNMAPPED = 21
+  UC_MEM_WRITE_PROT = 22
+  UC_MEM_READ_PROT = 23
+  UC_MEM_FETCH_PROT = 24
+  UC_MEM_READ_AFTER = 25
+
+  UC_TCG_OP_SUB = 0
+  UC_TCG_OP_FLAG_CMP = 1
+  UC_TCG_OP_FLAG_DIRECT = 2
+  UC_HOOK_INTR = 1
+  UC_HOOK_INSN = 2
+  UC_HOOK_CODE = 4
+  UC_HOOK_BLOCK = 8
+  UC_HOOK_MEM_READ_UNMAPPED = 16
+  UC_HOOK_MEM_WRITE_UNMAPPED = 32
+  UC_HOOK_MEM_FETCH_UNMAPPED = 64
+  UC_HOOK_MEM_READ_PROT = 128
+  UC_HOOK_MEM_WRITE_PROT = 256
+  UC_HOOK_MEM_FETCH_PROT = 512
+  UC_HOOK_MEM_READ = 1024
+  UC_HOOK_MEM_WRITE = 2048
+  UC_HOOK_MEM_FETCH = 4096
+  UC_HOOK_MEM_READ_AFTER = 8192
+  UC_HOOK_INSN_INVALID = 16384
+  UC_HOOK_EDGE_GENERATED = 32768
+  UC_HOOK_TCG_OPCODE = 65536
+  UC_HOOK_TLB_FILL = 131072
+  UC_HOOK_MEM_UNMAPPED = 112
+  UC_HOOK_MEM_PROT = 896
+  UC_HOOK_MEM_READ_INVALID = 144
+  UC_HOOK_MEM_WRITE_INVALID = 288
+  UC_HOOK_MEM_FETCH_INVALID = 576
+  UC_HOOK_MEM_INVALID = 1008
+  UC_HOOK_MEM_VALID = 7168
+  UC_QUERY_MODE = 1
+  UC_QUERY_PAGE_SIZE = 2
+  UC_QUERY_ARCH = 3
+  UC_QUERY_TIMEOUT = 4
+
+  UC_CTL_IO_NONE = 0
+  UC_CTL_IO_WRITE = 1
+  UC_CTL_IO_READ = 2
+  UC_CTL_IO_READ_WRITE = 3
+
+  UC_TLB_CPU = 0
+  UC_TLB_VIRTUAL = 1
+
+  UC_CTL_UC_MODE = 0
+  UC_CTL_UC_PAGE_SIZE = 1
+  UC_CTL_UC_ARCH = 2
+  UC_CTL_UC_TIMEOUT = 3
+  UC_CTL_UC_USE_EXITS = 4
+  UC_CTL_UC_EXITS_CNT = 5
+  UC_CTL_UC_EXITS = 6
+  UC_CTL_CPU_MODEL = 7
+  UC_CTL_TB_REQUEST_CACHE = 8
+  UC_CTL_TB_REMOVE_CACHE = 9
+  UC_CTL_TB_FLUSH = 10
+  UC_CTL_TLB_FLUSH = 11
+  UC_CTL_TLB_TYPE = 12
+  UC_CTL_TCG_BUFFER_SIZE = 13
+  UC_CTL_CONTEXT_MODE = 14
+  UC_CTL_CONTEXT_CPU = 1
+  UC_CTL_CONTEXT_MEMORY = 2
+end

data/lib/unicorn/version.rb

@@ -0,0 +1,3 @@
+module Unicorn
+  VERSION = "2.1.4"
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: NCPrePatcher
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.1
 platform: arm64-darwin-23
 authors:
 - Will Smith
@@ -55,6 +55,11 @@ files:
 - example/README.md
 - example/disasm.rb
 - exe/ncpp
+- lib/keystone/arm_const.rb
+- lib/keystone/keystone.dylib
+- lib/keystone/keystone.rb
+- lib/keystone/keystone_const.rb
+- lib/keystone/version.rb
 - lib/ncpp.rb
 - lib/ncpp/commands.rb
 - lib/ncpp/interpreter.rb
@@ -66,6 +71,11 @@ files:
 - lib/nitro/nitro.rb
 - lib/unarm/unarm.dylib
 - lib/unarm/unarm.rb
+- lib/unicorn/arm_const.rb
+- lib/unicorn/unicorn.dylib
+- lib/unicorn/unicorn.rb
+- lib/unicorn/unicorn_const.rb
+- lib/unicorn/version.rb
 homepage: https://github.com/pete420griff/NCPrePatcher
 licenses:
 - GPL-3.0-only
@@ -78,7 +88,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.1'
+      version: '3.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="