crabstone 3.0.3 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: acf2c718e307944c7535140d1048d7bff42e35d3
-  data.tar.gz: 60877a5b5d2cbc318431ae9c6019dcdd24e6b75b
+SHA256:
+  metadata.gz: 140a7d4cf44612a3205d95039371d243db5f7eabf5cc218eaafd6ac30a348846
+  data.tar.gz: 13bda9437d26890e825cfea3f661c12a50673fffc9710333fc04b025a5f0059c
 SHA512:
-  metadata.gz: 5fc96a476ee596c02d0c60805e27348503aba244a910c3aa4fc8596590c1e9c337a5a8cebd9cb9df8551352f95d07b3d6f957b578b0f4620b25d3a5f6fb734ac
-  data.tar.gz: 4821da92a28077e91a03759c8cf986d4b7bd68ff56df30f2d760189d50a0af1f0b6e216a7cca62134b01dbe7647261d8b8319bf2048e96a5cfb6b16a9eeba319
+  metadata.gz: bdb675faa5efd7eb608ac44d21b8b39e8e3cdbf3592a72df42ac4364b956c1c43463200cf5381556ccd532b3ed20e884a0505eb62d558a12e82156ba26135218
+  data.tar.gz: a38739c9b5a190673b29b1ccc0defcc27cbdf0d4a08fccc45822a3d3ae9bf80447c9ef5647167d1421cc5ab09300cbc0aaab9b43ed8e16b42f28746687cf6287

data/CHANGES.md

@@ -1,23 +1,40 @@
-## 0.0.1
-* Alpha release.
+## 4.0.0
+* Supported *both* Capstone 3.x and 4.x.
+* Supported 4 new architectures: M68K, M680X, TMS320C64x, and EVM.
+* Added `cs_regs_access` API (wrapped as `Instruction#regs_access` in Crabstone).
+* Changed some internal constants and methods.
+* Fixed tons of bugs.
+* For more details, see https://github.com/david942j/crabstone/pull/2
 
-## 0.0.2
-* Update tests, add syntax sugar
+## 3.0.3-rc1
+* Internal binding updates, updated some test specs.
 
-## 0.0.3
-* Refactoring and cosmetics
+## 3.0
+* See https://github.com/aquynh/capstone/wiki/ChangeLog-since-3.0-rc3
+* Shouldn't be breaking, most changes are internal.
 
-## 0.0.4
-* Verify MIPS support, tests, slight API changes
+## 3.0rc3
+* Generic groups ( CS_GRP_JUMP, CS_GRP_CALL etc)
+* Mips 32R6 + MICRO
+* Many constant changes
+* PPC CRX operand
+* X86: added prefixed symbols
+* THIS IS A BREAKING CHANGE ( even from rc1 )
 
-## 0.0.5
-* API changes including cs_errno.
+## 3.0rc1
+* Update for C side changes
+* Add support for Xcore
+* ARM, ARM64 and X86 passing, rest waiting for upstream
 
-## 0.0.6
-* Final set of API changes before public beta.
+## 2.2.0
+* Add support for Sparc and SystemZ
 
-## 1.0.0
-* Move to new github repo
+## 2.1rc1
+* Many constant changes
+* disasm CAN now return an Array, with a slightly scary built-in finalizer
+
+## 2.0.1
+* Update X86 constants
 
 ## 2.0.0
 * Add PPC support
@@ -25,37 +42,23 @@
 * disasm can now ONLY be used with a block ( hopefully fix later )
 * THIS IS A BREAKING CHANGE
 
-## 2.0.1
-* Update X86 constants
-
-## 2.1rc1
-* Many constant changes
-* disasm CAN now return an Array, with a slightly scary built-in finalizer
+## 1.0.0
+* Move to new github repo
 
-## 2.1.0
-* Full compliance with 2.1 API
-* Better error handling for diet mode
-* Internally change cs_close() signature, so closed handles can't be used
+## 0.0.6
+* Final set of API changes before public beta.
 
-## 2.2.0
-* Add support for Sparc and SystemZ
+## 0.0.5
+* API changes including cs_errno.
 
-## 3.0rc1
-* Update for C side changes
-* Add support for Xcore
-* ARM, ARM64 and X86 passing, rest waiting for upstream
+## 0.0.4
+* Verify MIPS support, tests, slight API changes
 
-## 3.0rc3
-* Generic groups ( CS_GRP_JUMP, CS_GRP_CALL etc)
-* Mips 32R6 + MICRO
-* Many constant changes
-* PPC CRX operand
-* X86: added prefixed symbols
-* THIS IS A BREAKING CHANGE ( even from rc1 )
+## 0.0.3
+* Refactoring and cosmetics
 
-## 3.0
-* See https://github.com/aquynh/capstone/wiki/ChangeLog-since-3.0-rc3
-* Shouldn't be breaking, most changes are internal.
+## 0.0.2
+* Update tests, add syntax sugar
 
-## 3.0.3-rc1
-* Internal binding updates, updated some test specs.
+## 0.0.1
+* Alpha release.

data/README.md

@@ -1,12 +1,7 @@
 crabstone
 ====
 
-STATUS
-===
-
-Hopefully working.
-
-Current Library binding: 3.0.3-rc1
+Current library support: 4.0.1
 ----
 
 ( FROM THE CAPSTONE README )
@@ -41,55 +36,43 @@ To install:
 First install the capstone library from either https://github.com/aquynh/capstone
 or http://www.capstone-engine.org
 
-Then (until we publish a gem) clone the repo, then do this:
+Then:
 
 ```bash
-gem build crabstone.gemspec
-gem install crabstone-3.0.3.gem
-rake test
+gem install crabstone
 ```
 
 To write code:
 ----
 
-Check the tests for more examples. Here is "Hello World":
+Check the tests in [Capstone](https://github.com/aquynh/capstone) for more examples. Here is "Hello World":
 ```ruby
+
 require 'crabstone'
 include Crabstone
-
-arm = (
-  "\xED\xFF\xFF\xEB\x04\xe0\x2d\xe5\x00\x00\x00\x00\xe0\x83\x22" <<
+arm =
+  "\xED\xFF\xFF\xEB\x04\xe0\x2d\xe5\x00\x00\x00\x00\xe0\x83\x22" \
   "\xe5\xf1\x02\x03\x0e\x00\x00\xa0\xe3\x02\x30\xc1\xe7\x00\x00\x53\xe3"
-)
 
 begin
-  
   cs = Disassembler.new(ARCH_ARM, MODE_ARM)
-  puts "Hello from Capstone v #{cs.version.join('.')}!"
-  puts "Disasm:"
+  puts "Hello from Capstone v#{cs.version.join('.')}!"
+  puts 'Disasm:'
 
   begin
-    cs.disasm(arm, 0x1000).each {|i|
-      printf("0x%x:\t%s\t\t%s\n",i.address, i.mnemonic, i.op_str)
-    }
-  rescue
-    fail "Disassembly error: #{$!}"
+    cs.disasm(arm, 0x1000).each do |i|
+      printf("0x%x:\t%s\t\t%s\n", i.address, i.mnemonic, i.op_str)
+    end
+  rescue StandardError => e
+    raise "Disassembly error: #{e.message}"
   ensure
     cs.close
   end
-
-rescue
-  fail "Unable to open engine: #{$!}"
+rescue StandardError => e
+  raise "Unable to open engine: #{e.message}"
 end
 ```
 
-Interpreter Support:
-----
-
-I test with JRuby >= 1.7.8, MRI >= 2.0.0. If it doesn't work with any of those
-it's a bug. If it doesn't work with like Rubinius or REE or 1.8 or whatever then
-"patches welcome". ( AFAIK it does, actually, work with rbx )
-
 Contributing:
 ----
 

data/lib/crabstone.rb

@@ -1,564 +1,12 @@
+# frozen_string_literal: true
+
 # Library by Nguyen Anh Quynh
 # Original binding by Nguyen Anh Quynh and Tan Sheng Di
 # Additional binding work by Ben Nagy
 # (c) 2013 COSEINC. All Rights Reserved.
 
-require 'ffi'
-
-require_relative 'arch/x86'
-require_relative 'arch/x86_registers'
-require_relative 'arch/arm'
-require_relative 'arch/arm_registers'
-require_relative 'arch/arm64'
-require_relative 'arch/arm64_registers'
-require_relative 'arch/mips'
-require_relative 'arch/mips_registers'
-require_relative 'arch/ppc'
-require_relative 'arch/ppc_registers'
-require_relative 'arch/sparc'
-require_relative 'arch/sparc_registers'
-require_relative 'arch/systemz'
-require_relative 'arch/sysz_registers'
-require_relative 'arch/xcore'
-require_relative 'arch/xcore_registers'
-
 module Crabstone
-
-  VERSION = '3.0.3'
-
-  # API version
-  BINDING_MAJ = 3
-  BINDING_MIN = 0
-
-  # architectures
-  ARCH_ARM   = 0
-  ARCH_ARM64 = 1
-  ARCH_MIPS  = 2
-  ARCH_X86   = 3
-  ARCH_PPC   = 4
-  ARCH_SPARC = 5
-  ARCH_SYSZ  = 6
-  ARCH_XCORE = 7
-  ARCH_MAX   = 8
-  ARCH_ALL   = 0xFFFF
-
-  # disasm mode
-  MODE_LITTLE_ENDIAN = 0       # little-endian mode (default mode)
-  MODE_ARM           = 0       # 32-bit ARM
-  MODE_16            = 1 << 1  # 16-bit mode (X86)
-  MODE_32            = 1 << 2  # 32-bit mode (X86)
-  MODE_64            = 1 << 3  # 64-bit mode (X86, PPC)
-  MODE_THUMB         = 1 << 4  # ARM's Thumb mode, including Thumb-2
-  MODE_MCLASS        = 1 << 5  # ARM's Cortex-M series
-  MODE_V8            = 1 << 6  # ARMv8 A32 encodings for ARM
-  MODE_MICRO         = 1 << 4  # MicroMips mode (MIPS)
-  MODE_MIPS3         = 1 << 5  # Mips III ISA
-  MODE_MIPS32R6      = 1 << 6  # Mips32r6 ISA
-  MODE_MIPSGP64      = 1 << 7  # General Purpose Registers are 64-bit wide (MIPS)
-  MODE_V9            = 1 << 4  # SparcV9 mode (Sparc)
-  MODE_BIG_ENDIAN    = 1 << 31 # big-endian mode
-  MODE_MIPS32        = MODE_32 # Mips32 ISA (Mips)
-  MODE_MIPS64        = MODE_64 # Mips64 ISA (Mips)
-
-
-  # Capstone option type
-  OPT_SYNTAX         = 1  # Intel X86 asm syntax (ARCH_X86 arch)
-  OPT_DETAIL         = 2  # Break down instruction structure into details
-  OPT_MODE           = 3  # Change engine's mode at run-time
-  OPT_MEM            = 4  # Change engine's mode at run-time
-  OPT_SKIPDATA       = 5  # Skip data when disassembling
-  OPT_SKIPDATA_SETUP = 6  # Setup user-defined function for SKIPDATA option
-
-  # Capstone option value
-  OPT_OFF = 0 # Turn OFF an option - default option of OPT_DETAIL
-  OPT_ON  = 3 # Turn ON an option (OPT_DETAIL)
-
-  # Common instruction operand types - to be consistent across all architectures.
-  OP_INVALID = 0
-  OP_REG     = 1
-  OP_IMM     = 2
-  OP_MEM     = 3
-  OP_FP      = 4
-
-  # Common instruction groups - to be consistent across all architectures.
-  GRP_INVALID = 0  # uninitialized/invalid group.
-  GRP_JUMP    = 1  # all jump instructions (conditional+direct+indirect jumps)
-  GRP_CALL    = 2  # all call instructions
-  GRP_RET     = 3  # all return instructions
-  GRP_INT     = 4  # all interrupt instructions (int+syscall)
-  GRP_IRET    = 5  # all interrupt return instructions
-
-  # Capstone syntax value
-  OPT_SYNTAX_DEFAULT   = 0  # Default assembly syntax of all platforms (OPT_SYNTAX)
-  OPT_SYNTAX_INTEL     = 1  # Intel X86 asm syntax - default syntax on X86 (OPT_SYNTAX, ARCH_X86)
-  OPT_SYNTAX_ATT       = 2  # ATT asm syntax (OPT_SYNTAX, ARCH_X86)
-  OPT_SYNTAX_NOREGNAME = 3  # Asm syntax prints register name with only number - (OPT_SYNTAX, ARCH_PPC, ARCH_ARM)
-
-  # query id for cs_support()
-  SUPPORT_DIET       = ARCH_ALL + 1
-  SUPPORT_X86_REDUCE = ARCH_ALL + 2
-
-  SYNTAX = {
-    :intel      => 1,
-    :att        => 2,
-    :no_regname => 3 # for PPC only
-  }
-
-  DETAIL = {
-    true  => 3, #trololol
-    false => 0
-  }
-
-  SKIPDATA = {
-    true  => 3, #trololol
-    false => 0
-  }
-
-  class ErrArch < StandardError; end
-  class ErrCsh < StandardError; end
-  class ErrHandle < StandardError; end
-  class ErrMem < StandardError; end
-  class ErrMode < StandardError; end
-  class ErrOK < StandardError; end
-  class ErrOption < StandardError; end
-  class ErrDetail < StandardError; end
-  class ErrMemSetup < StandardError; end
-  class ErrVersion < StandardError; end
-  class ErrDiet < StandardError; end
-  class ErrSkipData < StandardError; end
-  class ErrX86ATT < StandardError; end
-  class ErrX86Intel < StandardError; end
-
-  ERRNO = {
-    0  => ErrOK,
-    1  => ErrMem,
-    2  => ErrArch,
-    3  => ErrHandle,
-    4  => ErrCsh,
-    5  => ErrMode,
-    6  => ErrOption,
-    7  => ErrDetail,
-    8  => ErrMemSetup,
-    9  => ErrVersion,
-    10 => ErrDiet,
-    11 => ErrSkipData,
-    12 => ErrX86ATT,
-    13 => ErrX86Intel,
-  }
-
-  ERRNO_KLASS = ERRNO.invert
-
-  def self.raise_errno errno
-    err_klass = ERRNO[errno]
-    raise RuntimeError, "Internal Error: Tried to raise unknown errno" unless err_klass
-    err_str = Binding.cs_strerror(errno)
-    raise err_klass, err_str
-  end
-
-  module Binding
-
-    extend FFI::Library
-    ffi_lib ['capstone', 'libcapstone.so.3']
-
-    # This is because JRuby FFI on x64 Windows thinks size_t is 32 bit
-    case FFI::Platform::ADDRESS_SIZE
-    when 64
-      typedef :ulong_long, :size_t
-    when 32
-      typedef :ulong, :size_t
-    else
-      fail "Unsupported native address size"
-    end
-
-    typedef :size_t, :csh
-    typedef :size_t, :cs_opt_value
-    typedef :uint, :cs_opt_type
-    typedef :uint, :cs_err
-    typedef :uint, :cs_arch
-    typedef :uint, :cs_mode
-
-    class Architecture < FFI::Union
-      layout(
-        :arm, ARM::Instruction,
-        :arm64, ARM64::Instruction,
-        :mips, MIPS::Instruction,
-        :x86, X86::Instruction,
-        :ppc, PPC::Instruction,
-        :sparc, Sparc::Instruction,
-        :sysz, SysZ::Instruction,
-        :xcore, XCore::Instruction
-      )
-    end
-
-    class Detail < FFI::Struct
-      layout(
-        :regs_read, [:uint8, 12],
-        :regs_read_count, :uint8,
-        :regs_write, [:uint8, 20],
-        :regs_write_count, :uint8,
-        :groups, [:uint8, 8],
-        :groups_count, :uint8,
-        :arch, Architecture
-      )
-    end
-
-    class Instruction < FFI::ManagedStruct
-      layout(
-        :id, :uint,
-        :address, :ulong_long,
-        :size, :uint16,
-        :bytes, [:uchar, 16],
-        :mnemonic, [:char, 32],
-        :op_str, [:char, 160],
-        :detail, Detail.by_ref
-      )
-
-      def self.release(ptr)
-        detail_ptr = ptr.+(Instruction.offset_of(:detail)).read_ptr
-        Binding.free(detail_ptr)
-        Binding.free(ptr)
-      end
-    end
-
-    callback :skipdata_cb, [:pointer, :size_t, :size_t, :pointer], :size_t
-
-    class SkipdataConfig < FFI::Struct
-      layout(
-        :mnemonic, :pointer,
-        :callback, :skipdata_cb,
-        :unused, :pointer
-      )
-    end
-
-    attach_function(
-      :cs_disasm,
-      [:csh, :pointer, :size_t, :ulong_long, :size_t, :pointer],
-      :size_t
-    )
-    attach_function :cs_close, [:pointer], :cs_err
-    attach_function :cs_errno, [:csh], :cs_err
-    attach_function :cs_group_name, [:csh, :uint], :string
-    attach_function :cs_insn_group, [:csh, Instruction, :uint], :bool
-    attach_function :cs_insn_name, [:csh, :uint], :string
-    attach_function :cs_op_count, [:csh, Instruction, :uint], :cs_err
-    attach_function :cs_open, [:cs_arch, :cs_mode, :pointer], :cs_err
-    attach_function :cs_option, [:csh, :cs_opt_type, :cs_opt_value], :cs_err
-    attach_function :cs_reg_name, [:csh, :uint], :string
-    attach_function :cs_reg_read, [:csh, Instruction, :uint], :bool
-    attach_function :cs_reg_write, [:csh, Instruction, :uint], :bool
-    attach_function :cs_strerror, [:cs_err], :string
-    attach_function :cs_support, [:cs_arch], :bool
-    attach_function :cs_version, [:pointer, :pointer], :uint
-    attach_function :memcpy, [:pointer, :pointer, :size_t], :pointer
-    attach_function :malloc, [:size_t], :pointer
-    attach_function :free, [:pointer], :void
-
-  end # Binding
-
-  # This is a C engine build option, so we can set it here, not when we
-  # instantiate a new Disassembler.
-  DIET_MODE = Binding.cs_support SUPPORT_DIET
-  # Diet mode means:
-  # - No op_str or mnemonic in Instruction
-  # - No regs_read, regs_write or groups ( even with detail on )
-  # - No reg_name or insn_name id2str convenience functions
-  # - detail mode CAN still be on - so the arch insn operands MAY be available
-
-  class Instruction
-
-    attr_reader :arch, :csh, :raw_insn
-
-    ARCHS = {
-      arm: ARCH_ARM,
-      arm64: ARCH_ARM64,
-      x86: ARCH_X86,
-      mips: ARCH_MIPS,
-      ppc: ARCH_PPC,
-      sparc: ARCH_SPARC,
-      sysz: ARCH_SYSZ,
-      xcore: ARCH_XCORE
-    }.invert
-
-    ARCH_CLASSES = {
-      ARCH_ARM   => ARM,
-      ARCH_ARM64 => ARM64,
-      ARCH_X86   => X86,
-      ARCH_MIPS  => MIPS,
-      ARCH_PPC   => PPC,
-      ARCH_SPARC => Sparc,
-      ARCH_SYSZ  => SysZ,
-      ARCH_XCORE => XCore
-    }
-
-    def initialize csh, insn, arch
-      @arch       = arch
-      @csh        = csh
-      @raw_insn   = insn
-      if detailed?
-        @detail     = insn[:detail]
-        @arch_insn  = @detail[:arch][ARCHS[arch]]
-        @regs_read  = @detail[:regs_read].first( @detail[:regs_read_count] )
-        @regs_write = @detail[:regs_write].first( @detail[:regs_write_count] )
-        @groups     = @detail[:groups].first( @detail[:groups_count] )
-      end
-    end
-
-    def name
-      raise_if_diet
-      name = Binding.cs_insn_name(csh, id)
-      Crabstone.raise_errno( ERRNO_KLASS[ErrCsh] ) unless name
-      name
-    end
-
-    def group_name grp
-      raise_if_diet
-      name = Binding.cs_group_name(csh, Integer(grp))
-      Crabstone.raise_errno( ERRNO_KLASS[ErrCsh] ) unless name
-      name
-    end
-
-    # It's more informative to raise if CS_DETAIL is off than just return nil
-    def detailed?
-      not @raw_insn[:detail].pointer.null?
-    end
-
-    def detail
-      raise_unless_detailed
-      @detail
-    end
-
-    def regs_read
-      raise_unless_detailed
-      raise_if_diet
-      @regs_read
-    end
-
-    def regs_write
-      raise_unless_detailed
-      raise_if_diet
-      @regs_write
-    end
-
-    def groups
-      raise_unless_detailed
-      raise_if_diet
-      @groups
-    end
-
-    def group? groupid
-      raise_unless_detailed
-      raise_if_diet
-      Binding.cs_insn_group csh, raw_insn, groupid
-    end
-
-    def reads_reg? reg
-      raise_unless_detailed
-      raise_if_diet
-      Binding.cs_reg_read csh, raw_insn, ARCH_CLASSES[arch].register( reg )
-    end
-
-    def writes_reg? reg
-      raise_unless_detailed
-      raise_if_diet
-      Binding.cs_reg_write csh, raw_insn, ARCH_CLASSES[arch].register( reg )
-    end
-
-    def mnemonic
-      raise_if_diet
-      raw_insn[:mnemonic]
-    end
-
-    def op_str
-      raise_if_diet
-      raw_insn[:op_str]
-    end
-
-    def op_count op_type=nil
-      raise_unless_detailed
-      if op_type
-        Binding.cs_op_count csh, raw_insn, op_type
-      else
-        self.operands.size
-      end
-    end
-
-    def bytes
-      raw_insn[:bytes].first raw_insn[:size]
-    end
-
-    # So an Instruction should respond to all the methods in Instruction, and
-    # all the methods in the Arch specific Instruction class. The methods /
-    # members that have special handling for detail mode or diet mode are
-    # handled above. The rest is dynamically dispatched below.
-    def method_missing meth, *args
-      if raw_insn.members.include? meth
-        # Dispatch to toplevel Instruction class ( this file )
-        raw_insn[meth]
-      else
-        # Nothing else is available without details.
-        if not detailed?
-          raise(
-            NoMethodError,
-            "Either CS_DETAIL is off, or #{self.class} doesn't implement #{meth}"
-          )
-        end
-        # Dispatch to the architecture specific Instruction ( in arch/ )
-        if @arch_insn.respond_to? meth
-          @arch_insn.send meth, *args
-        elsif @arch_insn.members.include? meth
-          @arch_insn[meth]
-        else
-          raise NoMethodError, "Unknown method #{meth} for #{self.class}"
-        end
-      end
-    end
-
-    private
-
-    def raise_unless_detailed
-      Crabstone.raise_errno( Crabstone::ERRNO_KLASS[ErrDetail] ) unless detailed?
-    end
-
-    def raise_if_diet
-      Crabstone.raise_errno( Crabstone::ERRNO_KLASS[ErrDiet] ) if DIET_MODE
-    end
-
-  end
-
-
-  class Disassembler
-
-    attr_reader :arch, :mode, :csh, :syntax, :decomposer
-
-    def initialize arch, mode
-
-      maj, min = version
-      if maj != BINDING_MAJ || min != BINDING_MIN
-        raise "FATAL: Binding for #{BINDING_MAJ}.#{BINDING_MIN}, found #{maj}.#{min}"
-      end
-
-      @arch    = arch
-      @mode    = mode
-      p_size_t = FFI::MemoryPointer.new :ulong_long
-      @p_csh    = FFI::MemoryPointer.new p_size_t
-      if ( res = Binding.cs_open( arch, mode, @p_csh )).nonzero?
-        Crabstone.raise_errno res
-      end
-
-      @csh = @p_csh.read_ulong_long
-
-    end
-
-    # After you close the engine, don't use it anymore. Can't believe I even
-    # have to write this.
-    def close
-      if ( res = Binding.cs_close(@p_csh) ).nonzero?
-        Crabstone.raise_errno res
-      end
-    end
-
-    def syntax= new_stx
-      Crabstone.raise_errno( Crabstone::ERRNO_KLASS[ErrOption] ) unless SYNTAX[new_stx]
-      res = Binding.cs_option(csh, OPT_SYNTAX, SYNTAX[new_stx])
-      Crabstone.raise_errno res if res.nonzero?
-      @syntax = new_stx
-    end
-
-    def decomposer= new_val
-      res = Binding.cs_option(csh, OPT_DETAIL, DETAIL[!!(new_val)])
-      Crabstone.raise_errno res if res.nonzero?
-      @decomposer = !!(new_val)
-    end
-
-    def version
-      maj = FFI::MemoryPointer.new(:int)
-      min = FFI::MemoryPointer.new(:int)
-      Binding.cs_version maj, min
-      [ maj.read_int, min.read_int ]
-    end
-
-    def diet?
-      DIET_MODE
-    end
-
-    def errno
-      Binding.cs_errno(csh)
-    end
-
-    def skipdata mnemonic='.byte'
-
-      cfg = Binding::SkipdataConfig.new
-      cfg[:mnemonic] = FFI::MemoryPointer.from_string String(mnemonic)
-
-      if block_given?
-
-        real_cb = FFI::Function.new(
-          :size_t,
-          [:pointer, :size_t, :size_t, :pointer]
-        ) {|code, sz, offset, _|
-
-          code = code.read_array_of_uchar(sz).pack('c*')
-          begin
-            res = yield code, offset
-            Integer(res)
-          rescue
-            warn "Error in skipdata callback: #{$!}"
-            # It will go on to crash, but now at least there's more info :)
-          end
-        }
-
-        cfg[:callback] = real_cb
-
-      end
-
-      res = Binding.cs_option(csh, OPT_SKIPDATA_SETUP, cfg.pointer.address)
-      Crabstone.raise_errno res if res.nonzero?
-      res = Binding.cs_option(csh, OPT_SKIPDATA, SKIPDATA[true])
-      Crabstone.raise_errno res if res.nonzero?
-    end
-
-    def skipdata_off
-      res = Binding.cs_option(csh, OPT_SKIPDATA, SKIPDATA[false])
-      Crabstone.raise_errno res if res.nonzero?
-    end
-
-    def reg_name regid
-      Crabstone.raise_errno( Crabstone::ERRNO_KLASS[ErrDiet] ) if DIET_MODE
-      name = Binding.cs_reg_name(csh, regid)
-      Crabstone.raise_errno( Crabstone::ERRNO_KLASS[ErrCsh] ) unless name
-      name
-    end
-
-    def disasm code, offset, count = 0
-      return [] if code.empty?
-
-      insn_ptr   = FFI::MemoryPointer.new :pointer
-      insn_count = Binding.cs_disasm(
-        @csh,
-        code,
-        code.bytesize,
-        offset,
-        count,
-        insn_ptr
-      )
-      Crabstone.raise_errno(errno) if insn_count.zero?
-
-      insns = (0...insn_count * Binding::Instruction.size).step(Binding::Instruction.size).map do |off|
-        cs_insn_ptr = Binding.malloc Binding::Instruction.size
-        cs_insn = Binding::Instruction.new cs_insn_ptr
-        Binding.memcpy(cs_insn_ptr, insn_ptr.read_pointer + off, Binding::Instruction.size)
-        Instruction.new @csh, cs_insn, @arch
-      end
-
-      Binding.free(insn_ptr.read_pointer)
-
-      insns
-    end
-
-    def set_raw_option opt, val
-      res = Binding.cs_option csh, opt, val
-      Crabstone.raise_errno res if res.nonzero?
-    end
-
-  end
 end
+
+require 'crabstone/disassembler'
+require 'crabstone/version'