fiddley 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e5efaacddbd8392ed670102f7b62b32fe2a6024c
-  data.tar.gz: 20a196def56f4a803388c342ad513832fd7632ff
+  metadata.gz: ff58c14e7eed618a4c40f23d0b962f6e4d4aac51
+  data.tar.gz: 84ce3629b10e1cd0d6f068f60d4c9c6891b5d0f8
 SHA512:
-  metadata.gz: 231465cbe7a2a2a87ca7dc43b0186d8f0df8d044b9ae0ab0ea0ea76c11d99ac9a622444739501bd7536233a6eb77c20be99c51f9e406dd9f61440f812dfbf083
-  data.tar.gz: 924b4785615ba80370947d36fa9c7263e38cd763fd63c2198cf23a56a9a6847fb4770f9ba60130a397592a6484e4ae358d8b2f847d61ac6bd791285822e4b9e8
+  metadata.gz: 96a3282bf572735f15aeff0a21a472f50da36df876bcce23e8d3a1785fa8d8c06ba1be2b4eaceaa6984a4bb89968a9f9c8435fc4888266b5052964c02664a7e0
+  data.tar.gz: 2b9cae8442c68515937c62c0697604f9ad2b249fce6f3b4fa09aa38f9cf90499baf07fe1c433f699b3ef021ff58760b82a539e154772a7db2d4cb4b5dce54325

data/lib/ffi.rb

@@ -1 +1,3 @@
 require "fiddley"
+
+FFI = Fiddley

data/lib/fiddley.rb

@@ -1,9 +1,7 @@
 module Fiddley
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end
 
-FFI = Fiddley
-
 require "fiddley/function"
 require "fiddley/memory_pointer"
 require "fiddley/library"

data/lib/fiddley/function.rb

@@ -1,4 +1,5 @@
 require "fiddle/import"
+require "fiddley/utils"
 
 module Fiddley
   class Function
@@ -6,7 +7,7 @@ module Fiddley
       Module.new do
         extend Fiddle::Importer
         dlload Fiddley::Library::LIBC
-        @@func = bind("#{Fiddley.type2str(ret)} callback(#{params.map{|e|Fiddley.type2str(e)}.join(', ')})", &blk)
+        @@func = bind("#{Fiddley::Utils.type2str(ret)} callback(#{params.map{|e| Fiddley::Utils.type2str(e)}.join(', ')})", &blk)
       end
     end
   end

data/lib/fiddley/library.rb

@@ -1,21 +1,37 @@
 require "fiddle/import"
+require "fiddley/utils"
 
 module Fiddley
   module Library
+    include Fiddley::Utils
     include Fiddle::Importer
+
     alias ffi_lib dlload
 
     def extended(mod)
       @convention = nil
     end
 
+    def ffi_convention(conv)
+      @convention = conv
+    end
+
     def attach_function(rname, cname, params, ret = nil, blocking: false)
       if ret.nil?
         ret = params
         params = cname
         cname = rname
       end
-      extern "#{Fiddley.type2str(ret)} #{cname}(#{params.map{|e| Fiddley.type2str(e)}.join(', ')})", @convention
+      extern "#{type2str(ret)} #{cname}(#{params.map{|e| type2str(e)}.join(', ')})", @convention
+      if ret == :string
+        tname = (cname.to_s + '+').to_sym
+        instance_eval <<-end
+          alias #{tname.inspect} #{cname.inspect}
+        end
+        define_singleton_method(cname) do |*args|
+          __send__(tname, *args).to_s
+        end
+      end
       if cname != rname
         instance_eval <<-end
           alias #{rname.inspect} #{cname.inspect}
@@ -23,10 +39,6 @@ module Fiddley
       end
     end
 
-    def ffi_convention(conv)
-      @convention = conv
-    end
-
     case RUBY_PLATFORM
     when /cygwin/
       libc_so = "cygwin1.dll"
@@ -83,12 +95,10 @@ module Fiddley
     libm_so = nil if !libm_so || (libm_so[0] == ?/ && !File.file?(libm_so))
 
     if !libc_so || !libm_so
-      ruby = EnvUtil.rubybin
-      ldd = `ldd #{ruby}`
-      #puts ldd
+      require "rbconfig"
+      ldd = `ldd #{RbConfig.ruby}`
       libc_so = $& if !libc_so && %r{/\S*/libc\.so\S*} =~ ldd
       libm_so = $& if !libm_so && %r{/\S*/libm\.so\S*} =~ ldd
-      #p [libc_so, libm_so]
     end
 
     LIBC = libc_so

data/lib/fiddley/memory_pointer.rb

@@ -1,85 +1,139 @@
 require "fiddle/import"
+require "fiddley/utils"
 
 module Fiddley
   class MemoryPointer
-    def initialize(type, num = 1)
-      size = Fiddley.type2size(type) * num
-      @ptr = Fiddle::Pointer.malloc(size)
+    if defined?(Fiddley::RefineStringUnpack1)
+      using Fiddley::RefineStringUnpack1
     end
 
-    def write_int16(val)
-      @ptr[0, 2] = [val].pack('s')
-    end
+    include Fiddley::Utils
 
-    def write_int32(val)
-      @ptr[0, 4] = [val].pack('l')
+    def initialize(type, num = 1, clear = true)
+      @size = type2size(type) * num
+      @ptr = Fiddle::Pointer.malloc(@size)
     end
 
-    def write_array_of_uint32(ary)
-      write_string(ary.pack('L*'))
-    end
+    attr_reader :size
 
-    def write_string(str)
-      @ptr[0, str.bytesize] = str
+    def to_ptr
+      @ptr
     end
 
-    def read_bytes(size)
-      @ptr[0, size]
-    end
+    {8 => 'c', 16 => 's', 32 => 'l', 64 => 'q'}.each_pair do |bits, form|
+      bytes = bits/8
 
-    def read_int8
-      get_int8(0)
-    end
+      define_method("put_int#{bits}") do |offset, val|
+        @ptr[offset, bytes] = [val].pack(form)
+      end
 
-    def read_uint8
-      get_uint8(0)
-    end
+      define_method("write_int#{bits}") do |val|
+        __send__("put_int#{bits}", 0, val)
+      end
+
+      define_method("put_array_of_int#{bits}") do |offset, ary|
+        put_bytes(offset, ary.pack(form + '*'))
+      end
+
+      define_method("write_array_of_int#{bits}") do |ary|
+        __send__("put_array_of_int#{bits}", 0, ary)
+      end
+
+      define_method("get_int#{bits}") do |offset|
+        @ptr[offset, bytes].unpack1(form)
+      end
+
+      define_method("read_int#{bits}") do
+        __send__("get_int#{bits}", 0)
+      end
+
+      define_method("get_array_of_int#{bits}") do |offset, num|
+        @ptr[offset, bytes*num].unpack1(form + '*')
+      end
+
+      define_method("read_array_of_int#{bits}") do |num|
+        __send__("get_array_of_int#{bits}", 0, num)
+      end
 
-    def read_int16
-      get_int16(0)
+      form2 = form.upcase
+
+      define_method("put_uint#{bits}") do |offset, val|
+        @ptr[offset, bytes] = [val].pack(form2)
+      end
+
+      define_method("write_uint#{bits}") do |val|
+        __send__("put_uint#{bits}", 0, val)
+      end
+
+      define_method("put_array_of_uint#{bits}") do |offset, ary|
+        put_bytes(offset, ary.pack(form2 + '*'))
+      end
+
+      define_method("write_array_of_uint#{bits}") do |ary|
+        __send__("put_array_of_uint#{bits}", 0, ary)
+      end
+
+      define_method("get_uint#{bits}") do |offset|
+        @ptr[offset, bytes].unpack1(form2)
+      end
+
+      define_method("read_uint#{bits}") do
+        __send__("get_uint#{bits}", 0)
+      end
+
+      define_method("get_array_of_uint#{bits}") do |offset, num|
+        @ptr[offset, bytes*num].unpack1(form2 + '*')
+      end
+
+      define_method("read_array_of_uint#{bits}") do |num|
+        __send__("get_array_of_uint#{bits}", 0, num)
+      end
     end
 
-    def read_uint16
-      get_uint16(0)
+    def put_bytes(offset, str, len = nil)
+      @ptr[offset, len ? len : str.bytesize] = len ? str[0, len] : str
     end
 
-    def read_int32
-      get_int32(0)
+    def write_bytes(str, len = nil)
+      put_bytes(0, str, len)
     end
 
-    def read_uint32
-      get_uint32(0)
+    def get_bytes(offset, len)
+      @ptr[offset, len]
     end
 
-    def get_int8(offset)
-      @ptr[offset, 1].unpack1('c')
+    def read_bytes(len)
+      get_bytes(0, len)
     end
 
-    def get_uint8(offset)
-      @ptr[offset, 1].unpack1('C')
+    def put_string(offset, str)
+      @ptr[offset, str.bytesize] = str
     end
 
-    def get_int16(offset)
-      @ptr[offset, 2].unpack1('s')
+    def write_string(str, len = nil)
+      put_string(0, len ? str[0, len] : str)
     end
 
-    def get_uint16(offset)
-      @ptr[offset, 2].unpack1('S')
+    def write_string_length(str, len)
+      put_string(0, str[0, len])
     end
 
-    def get_int32(offset)
-      @ptr[offset, 4].unpack1('l')
+    def get_string(offset, len = nil)
+      @ptr[offset, len ? len : @size - offset]
     end
 
-    def get_uint32(offset)
-      @ptr[offset, 4].unpack1('L')
+    def read_string(len = nil)
+      get_string(0, len)
     end
 
-    alias read_int read_int32
+    alias put_int put_int32
+    alias write_int write_int32
     alias get_int get_int32
+    alias read_int read_int32
 
-    def to_ptr
-      @ptr
-    end
+    alias put_uint put_uint32
+    alias write_uint write_uint32
+    alias get_uint get_uint32
+    alias read_uint read_uint32
   end
 end

data/lib/fiddley/struct.rb

@@ -1,13 +1,17 @@
 require "fiddle/import"
+require "fiddley/utils"
 
 module Fiddley
   class Struct
+    include Fiddley::Utils
+    extend Fiddley::Utils
+
     def self.layout(*args)
       @members = {}
       @size = 0
       args.each_slice(2) do |name, type|
         @members[name] = [type, @size]
-        @size += Fiddley.type2size(type)
+        @size += type2size(type)
       end
     end
 
@@ -36,13 +40,13 @@ module Fiddley
     def [](key)
       raise IndexError, "#{key} is not defined" unless self.class.members.has_key?(key)
       type, offset = self.class.members[key]
-      Fiddley.str2value(type, @ptr[offset, Fiddley.type2size(type)])
+      str2value(type, @ptr[offset, type2size(type)])
     end
 
     def []=(key, value)
       raise IndexError, "#{key} is not defined" unless self.class.members.has_key?(key)
       type, offset = self.class.members[key]
-      @ptr[offset, Fiddley.type2size(type)] = Fiddley.value2str(type, value)
+      @ptr[offset, type2size(type)] = value2str(type, value)
     end
 
     def to_ptr

data/lib/fiddley/utils.rb

@@ -1,81 +1,145 @@
 module Fiddley
-  def self.type2size(type)
-    case type
-    when :char, :uchar, :int8, :uint8
-      1
-    when :short, :ushort, :int16, :uint16
-      2
-    when :int, :uint, :int32, :uint32
-      4
-    when :long, :ulong, :int64, :uint64
-      8
-    when :string, :pointer
-      8
-    else
-      raise TypeError, "unknown type #{type}"
+  unless "".respond_to?(:unpack1)
+    module RefineStringUnpack1
+      refine String do
+        def unpack1(arg)
+          unpack(arg).first
+        end
+      end
     end
+
+    using RefineStringUnpack1
   end
 
-  def self.str2value(type, str)
-    case type
-    when :char, :uchar, :int8, :uint8
-      str.unpack1('c')
-    when :short, :ushort, :int16, :uint16
-      str.unpack1('s')
-    when :int, :uint, :int32, :uint32
-      str.unpack1('l')
-    when :long, :ulong, :int64, :uint64
-      str.unpack1('Q')
-    when :string, :pointer
-      str.unpack1('p')
-    else
-      raise TypeError, "unknown type #{type}"
+  module Utils
+    # assumes short = 16bit, int = 32bit, long long = 64bit
+    LONG_SIZE = [0].pack('l!').bytesize
+    POINTER_SIZE = [nil].pack('p').bytesize
+    SIZET_FORMAT = POINTER_SIZE == LONG_SIZE ? 'l!' : 'q'
+    SIZET_TYPE = POINTER_SIZE == LONG_SIZE ? 'unsigned long' : 'unsigned long long'
+
+    module_function def type2size(type)
+      case type
+      when :char, :uchar, :int8, :uint8
+        1
+      when :short, :ushort, :int16, :uint16
+        2
+      when :int, :uint, :int32, :uint32, :bool
+        4
+      when :long, :ulong
+        LONG_SIZE
+      when :int64, :uint64, :long_long, :ulong_long
+        8
+      when :string, :pointer, :size_t
+        POINTER_SIZE
+      else
+        raise ArgumentError, "unknown type #{type}"
+      end
     end
-  end
 
-  def self.value2str(type, value)
-    case type
-    when :char, :uchar, :int8, :uint8
-      [value].pack('c')
-    when :short, :ushort, :int16, :uint16
-      [value].pack('s')
-    when :int, :uint, :int32, :uint32
-      [value].pack('l')
-    when :long, :ulong, :int64, :uint64
-      [value].pack('Q')
-    when :string, :pointer
-      [value].pack('p')
-    else
-      raise TypeError, "unknown type #{type}"
+    module_function def str2value(type, str)
+      case type
+      when :char, :int8
+        str.unpack1('c')
+      when :uchar, :uint8
+        str.unpack1('C')
+      when :short, :int16
+        str.unpack1('s')
+      when :ushort, :uint16
+        str.unpack1('S')
+      when :int32
+        str.unpack1('l')
+      when :uint32
+        str.unpack1('L')
+      when :int
+        str.unpack1('i!')
+      when :uint
+        str.unpack1('I!')
+      when :bool
+        str.unpack1('i!') != 0
+      when :long
+        str.unpack1('l!')
+      when :ulong
+        str.unpack1('L!')
+      when :long_long, :int64
+        str.unpack1('q')
+      when :ulong_long, :uint64
+        str.unpack1('Q')
+      when :string, :pointer
+        str.unpack1('p')
+      when :size_t
+        str.unpack1(SIZET_FORMAT)
+      else
+        raise ArgumentError, "unknown type #{type}"
+      end
+    end
+
+    module_function def value2str(type, value)
+      case type
+      when :char, :int8
+        [value].pack('c')
+      when :uchar, :uint8
+        [value].pack('C')
+      when :short, :int16
+        [value].pack('s')
+      when :ushort, :uint16
+        [value].pack('S')
+      when :int32
+        [value].pack('l')
+      when :uint32
+        [value].pack('L')
+      when :int
+        [value].pack('i!')
+      when :uint
+        [value].pack('I!')
+      when :bool
+        [value ? 1 : 0].pack('i!')
+      when :long
+        [value].pack('l!')
+      when :ulong
+        [value].pack('L!')
+      when :long_long, :int64
+        [value].pack('q')
+      when :ulong_long, :uint64
+        [value].pack('Q')
+      when :string, :pointer
+        [value].pack('p')
+      when :size_t
+        [value].pack(SIZET_FORMAT)
+      else
+        raise ArgumentError, "unknown type #{type}"
+      end
     end
-  end
 
-  def self.type2str(type)
-    case type
-    when :char, :int8
-      "char"
-    when :uchar, :uint8
-      "unsigned char"
-    when :short, :int16
-      "short"
-    when :ushort, :uint16
-      "unsigned short"
-    when :int, :int32
-      "int"
-    when :uint, :uint32
-      "unsigned int"
-    when :long, :int64
-      "long"
-    when :ulong, :uint64
-      "unsigned long"
-    when :long_long
-      "long long"
-    when :ulong_long
-      "unsigned long long"
-    when :string, :pointer
-      "void *"
-    else
-      type.to_s
+    module_function def type2str(type)
+      case type
+      when :char, :int8
+        "char"
+      when :uchar, :uint8
+        "unsigned char"
+      when :short, :int16
+        "short"
+      when :ushort, :uint16
+        "unsigned short"
+      when :int, :int32
+        "int"
+      when :uint, :uint32
+        "unsigned int"
+      when :long
+        "long"
+      when :ulong
+        "unsigned long"
+      when :long_long, :int64
+        "long long"
+      when :ulong_long, :uint64
+        "unsigned long long"
+      when :string, :pointer
+        "void *"
+      when :size_t
+        SIZET_TYPE
+      else
+        type.to_s
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fiddley
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - U.Nakamura
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-03-30 00:00:00.000000000 Z
+date: 2017-03-31 00:00:00.000000000 Z
 dependencies: []
 description: Use Fiddle instead of Ruby-FFI !!!
 email: