NCPrePatcher 0.2.0 → 0.3.2

data/README.md

@@ -1,66 +1,69 @@
-# NCPrePatcher
-
-A preprocessor for [NCPatcher](https://github.com/TheGameratorT/NCPatcher) with access to your NDS ROM and a disassembler.
-
-## Installation
-
-#### Requirements
-
-- [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:
-```console
-gem install NCPrePatcher-[version]-[platform].gem
-```
-
-The `ncpp` command should now be available at your command line (a system reboot may be required).
-
-## Usage
-
-NCPrePatcher can be used as a Ruby library or, as it was built for, as a preprocessor alongside NCPatcher.
-
-For the former, simply `require` it as you would with any gem:
-```ruby
-require ncpp
-```
-
-For the latter, navigate to an existing project using NCPatcher (where an `ncpatcher.json` file is present), and run:
-```console
-ncpp
-```
-Follow the directions given, and it will be installed into your project. Subsequently, running `ncpp` manually will no longer be required; being added as a pre-build command in `ncpatcher.json`, it will run when NCPatcher does.
-
-For examples of usage as a preprocessor, see [ncpp-demos](https://github.com/pete420griff/ncpp-demos).
-
-To view what else NCPrePatcher can do, run:
-```console
-ncpp --help
-```
-
-## Building
-
-> [!NOTE]
-> This is an alternative to installing NCPrePatcher via the methods described in [the installation guide](#installation)
-
-#### Requirements
-
-- Ruby
-- CMake and a modern C++ compiler
-- Rust and Cargo
-
-To build the required native libraries, go to /ext/ and run:
-```console
-ruby build.rb
-```
-
-Then go back to the base directory and run:
-```console
-gem build ncpp.gemspec
-```
-
-## Credits
-
-- 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
+# NCPrePatcher
+
+A preprocessor for [NCPatcher](https://github.com/TheGameratorT/NCPatcher) with access to your NDS ROM, a disassembler, an assembler, and an emulator.
+
+## Installation
+
+#### Requirements
+
+- [Ruby (≥ 3.4 required)](https://www.ruby-lang.org/en/downloads/)
+
+From the command line, enter:
+```console
+gem install NCPrePatcher
+```
+
+The `ncpp` command should now be available at your command line (a system reboot may be required).
+
+## Usage
+
+NCPrePatcher can be used as a Ruby library or, as it was built for, as a preprocessor alongside NCPatcher.
+
+For the former, simply `require` it as you would with any gem:
+```ruby
+require ncpp
+```
+
+For the latter, navigate to an existing project using NCPatcher (where an `ncpatcher.json` file is present), and run:
+```console
+ncpp
+```
+Follow the directions given, and it will be installed into your project. Subsequently, running `ncpp` manually will no longer be required; being added as a pre-build command in `ncpatcher.json`, it will run when NCPatcher does.
+
+For examples of usage as a preprocessor, see [ncpp-demos](https://github.com/pete420griff/ncpp-demos).
+
+To view what else NCPrePatcher can do, run:
+```console
+ncpp --help
+```
+
+## Building
+
+> [!NOTE]
+> This is an alternative to installing NCPrePatcher via the methods described in [the installation guide](#installation)
+
+#### Requirements
+
+- Ruby
+- CMake and a modern C++ compiler
+- Rust and Cargo
+- vcpkg
+
+To build the native libraries, go to /ext/ and run:
+```console
+ruby build.rb
+```
+
+Finally, go back to the base directory and run:
+```console
+gem build ncpp.gemspec
+```
+
+## Credits
+
+- Code from NCPatcher used by the **nitro** library
+- [unarm](https://github.com/AetiasHax/unarm) used for disassembling
+- [Keystone](https://github.com/keystone-engine/keystone/tree/master) used for assembling
+- [Unicorn](https://github.com/unicorn-engine/unicorn/tree/master) used for emulating
+- [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

data/example/README.md

@@ -1,3 +1,3 @@
-# Examples
-
-This folder contains examples of using NCPrePatcher as a **Ruby library**.
+# Examples
+
+This folder contains examples of using NCPrePatcher as a **Ruby library**.

data/example/disasm.rb

@@ -1,34 +1,30 @@
-require 'ncpp'
-
-start_time = Time.now
-
-puts 'Loading rom...'
-rom = Nitro::Rom.new('Ratatouille.nds')
-
-NCPP.show_rom_info(rom)
-
-puts "Ov0 sinit start: " + rom.ovt.get_entry(0)[:sinit_start].to_hex
-puts "Ov1 sinit start: " + rom.ovt.get_entry(1)[:sinit_start].to_hex
-puts "Ov2 sinit start: " + rom.ovt.get_entry(2)[:sinit_start].to_hex
-
-# puts 'Loading symbols...'
-# Unarm.load_symbols9('symbols9.x')
-
-f = File.open('rat-disasm.txt', 'w')
-
-puts 'Disassembling arm9...'
-
-# Here we treat every word in the binary as if it's an arm instruction; this is of course not reality
-rom.arm9.each_ins {|ins| f.puts "#{ins.addr.to_hex}: #{ins.str}" }
-
-f.puts
-
-rom.each_overlay do |ov, id|
-  puts "Disassembling overlay#{id}"
-  ov.each_ins {|ins| f.puts "#{ins.addr.to_hex}: #{ins.str}" }
-  f.puts
-end
-
-f.close
-
-puts "Done! Took #{Time.now - start_time} seconds."
+require 'ncpp'
+
+start_time = Time.now
+
+puts 'Loading rom...'
+rom = Nitro::Rom.new('speeeedrun2.nds')
+
+NCPP.show_rom_info(rom)
+
+# puts 'Loading symbols...'
+Unarm.load_symbols9('../symbols9.x')
+
+f = File.open('speedrun-disasm2.txt', 'w')
+
+puts 'Disassembling arm9...'
+
+# Here we treat every word in the binary as if it's an arm instruction; this is of course not reality
+rom.arm9.each_ins {|ins| f.puts "#{ins.addr.to_hex}: #{ins.raw.to_hex} #{ins.str}" }
+
+f.puts
+
+rom.each_overlay do |ov, id|
+  puts "Disassembling overlay#{id}"
+  ov.each_ins {|ins| f.puts "#{ins.addr.to_hex}: #{ins.raw.to_hex} #{ins.str}" }
+  f.puts
+end
+
+f.close
+
+puts "Done! Took #{Time.now - start_time} seconds."

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'
+require_relative 'keystone_const'
+require_relative 'version'
+
+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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'types.rb'
-require_relative 'version.rb'
+require_relative 'types'
+require_relative 'version'
 
 module NCPP
 
@@ -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

@@ -1,5 +1,5 @@
-require_relative 'parser.rb'
-require_relative 'commands.rb'
+require_relative 'parser'
+require_relative 'commands'
 
 require 'fileutils'
 
@@ -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/types.rb

@@ -1,4 +1,4 @@
-require_relative 'utils.rb'
+require_relative 'utils'
 
 module NCPP
 

data/lib/ncpp/utils.rb

@@ -1,5 +1,6 @@
-require_relative '../nitro/nitro.rb'
-require_relative '../unarm/unarm.rb'
+require_relative '../nitro/nitro'
+require_relative '../unarm/unarm'
+require_relative '../unicorn/unicorn'
 
 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