ffi-struct_ex 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b5f6419c35f3fafa8e32d334891f9ff94c8de5d8
+  data.tar.gz: 44f8717d43e0bd7704fbafd3a5b86f884bafe3c5
+SHA512:
+  metadata.gz: 1f3ed97c400af758499755b85d04f06886a595bd5fd6a1cc729ba0dceaaa2df964368c45c26429cf9393a031b43da2473c35206f63e5f69efd629643f7a8760b
+  data.tar.gz: 0d3840f2325ca19f4178121ad9bd450fb906c80f85ce4bb1be390e36a89490bff6b2f4e8db7ada1c6390add4b4b11a1d7351cbca82030d67fb1b10f5c9afcf0d

data/.gitattributes

@@ -0,0 +1,22 @@
+# Auto detect text files and perform LF normalization
+* text=auto
+
+# Custom for Visual Studio
+*.cs     diff=csharp
+*.sln    merge=union
+*.csproj merge=union
+*.vbproj merge=union
+*.fsproj merge=union
+*.dbproj merge=union
+
+# Standard to msysgit
+*.doc	 diff=astextplain
+*.DOC	 diff=astextplain
+*.docx diff=astextplain
+*.DOCX diff=astextplain
+*.dot  diff=astextplain
+*.DOT  diff=astextplain
+*.pdf  diff=astextplain
+*.PDF	 diff=astextplain
+*.rtf	 diff=astextplain
+*.RTF	 diff=astextplain

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.project

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>ffi-struct_ex</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>com.aptana.ide.core.unifiedBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>com.aptana.ruby.core.rubynature</nature>
+		<nature>com.aptana.projects.webnature</nature>
+	</natures>
+</projectDescription>

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ffi-struct_ex.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 RUIJIA LI
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,73 @@
+# FFI::StructEx
+
+The gem adds bit field for C struct by FFI::StructEx inherited from FFI::Struct. The functionality is limited now, refer to usage section for supported forms.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ffi-struct_ex'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ffi-struct_ex
+
+## Usage
+
+* Struct (only support "unsigned" field)
+
+```ruby
+require 'ffi/struct_ex'
+
+class Subject < FFI::StructEx
+  layout :bits_0_2, 3,
+         :bit_3,    1,
+         :bit_4,    1,
+         :bits_5_7, 3
+end
+
+subject = Subject.new(bits_0_2: 0b001, bit_3: 0b1, bit_4: 0b0, bits_5_7: 0b011)
+
+subject[:bits_0_2] #=> 0b101
+subject.read #=> 0b0110_1001
+```
+
+* Struct (embedded bit fields)
+
+```ruby
+require 'ffi/struct_ex'
+
+class Subject < FFI::StructEx
+  layout :field_0, bit_fields(:bits_0_2, 3,
+                              :bit_3,    1,
+                              :bit_4,    1,
+                              :bits_5_7, 3),
+         :field_1, :uint8,
+         :field_2, :uint8,
+         :field_3, [:uint8, 2]
+end
+
+subject[:field_0].class.superclass #=> FFI::StructEx
+
+subject[:field_0] = 0b0110_1001
+subject[:field_0].read #=> 0b0110_1001
+
+subject[:field_0][:bits_0_2] = 0b101
+subject[:field_0][:bits_0_2] #=> 0b101
+subject[:field_0].read #=> 0b0110_1101
+
+subject[:field_0] = {bits_0_2: 0b001, bit_3: 0b1, bit_4: 0b0, bits_5_7: 0b011}
+subject[:field_0].read #=> 0b0110_1001
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'bundler/setup'
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib' << 'test'
+end

data/ffi-struct_ex.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ffi/struct_ex/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ffi-struct_ex"
+  spec.version       = Ffi::StructEx::VERSION
+  spec.authors       = ["Ruijia Li"]
+  spec.email         = ["ruijia.li@gmail.com"]
+  spec.description   = %q{A module to add extra functionalities to FFI::Struct}
+  spec.summary       = %q{A module to add extra functionalities to FFI::Struct}
+  spec.homepage      = "https://github.com/rli9/ffi-struct_ex"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "ffi", "~> 1.0"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/lib/ffi/struct_ex/struct_ex.rb

@@ -0,0 +1,160 @@
+require 'ffi'
+
+class Integer
+  def to_bytes(size)
+    bytes = [0] * size
+    bytes.each_index do |i|
+      bytes[i] = (self >> (i * 8)) & 0xff
+    end
+
+    bytes
+  end
+end
+
+module FFI
+  class StructEx < FFI::Struct
+    BitLayout = ::Struct.new(:name, :bits, :offset, :texts)
+
+    class << self
+      def bit_fields(*descs)
+        struct_class = Class.new(StructEx) do
+          layout(*descs)
+        end
+
+        bit_fields_class = Class.new(FFI::StructLayout::Field) do
+          def initialize(name, offset, type)
+            #TODO use a different native_type to avoid dummy field for struct
+            super(name, offset, FFI::Type::Struct.new(self.class.struct_class))
+          end
+
+          def get(ptr)
+            #self.class.struct_class == type.struct_class
+            self.class.struct_class.new(ptr.slice(self.offset, self.size))
+          end
+
+          def put(ptr, value)
+            self.class.struct_class.new(ptr.slice(self.offset, self.size)).write(value)
+          end
+
+          class << self
+            attr_accessor :struct_class
+
+            def alignment
+              struct_class.alignment
+            end
+          end
+
+          self.struct_class = struct_class
+        end
+      end
+
+      attr_reader :bits_size, :bit_layouts
+
+      def layout(*descs)
+        if descs.size == 0 || !descs[1].is_a?(Integer)
+          super(*descs)
+        else
+          @bit_layouts = {}
+
+          index = @bits_size = 0
+
+          while index < descs.size
+            bit_field_name, bits, texts = descs[index, 3]
+
+            if texts.kind_of?(Hash)
+              @bit_layouts[bit_field_name] = BitLayout.new(bit_field_name, bits, @bits_size, texts)
+              index += 3
+            else
+              @bit_layouts[bit_field_name] = BitLayout.new(bit_field_name, bits, @bits_size)
+              index += 2
+            end
+
+            @bits_size += bits
+          end
+
+          #FIXME consider 24 bits situation or larger than 32 bits
+          #FIXME remove dummy field or have a better name for this field
+          super(:dummy, "uint#{bytes_size * 8}".to_sym)
+        end
+      end
+
+      def bytes_size
+        (bits_size + 7) >> 3
+      end
+
+      def alignment
+        #FIXME consider 24 bits situation
+        FFI.find_type("uint#{bytes_size * 8}".to_sym).alignment
+      end
+    end
+
+    def initialize(options = {})
+      if options.is_a?(FFI::Pointer)
+        super(options)
+      else
+        super()
+        write(options)
+      end
+    end
+
+    def [](bit_field_name)
+      return super unless self.class.bit_layouts && self.class.bit_layouts.keys.include?(bit_field_name)
+
+      bit_layout = self.class.bit_layouts[bit_field_name]
+      mask = ((1 << bit_layout.bits) - 1) << bit_layout.offset
+
+      (self.read & mask) >> bit_layout.offset
+    end
+
+    def []=(bit_field_name, value)
+      return super unless self.class.bit_layouts && self.class.bit_layouts.keys.include?(bit_field_name)
+      value = look_for_value(bit_field_name, value)
+
+      bit_layout = self.class.bit_layouts[bit_field_name]
+      mask = ((1 << bit_layout.bits) - 1) << bit_layout.offset
+
+      self.write((self.read & (-1 - mask)) | ((value << bit_layout.offset) & mask))
+    end
+
+    def write(value)
+      if value.is_a?(Integer)
+        to_ptr.write_array_of_uint8(value.to_bytes(self.class.bytes_size))
+      elsif value.is_a?(Hash)
+        value.each do |bit_field_name, v|
+          self[bit_field_name] = v if self.class.bit_layouts.keys.include? bit_field_name
+        end
+      end
+    end
+
+    def read
+      bytes = to_ptr.read_array_of_uint8(self.class.bytes_size)
+      bytes.reverse.inject(0) {|value, n| (value << 8) | n}
+    end
+
+    def size
+      self.class.bytes_size
+    end
+
+    def look_for_value(bit_field_name, value)
+      #FIXME add error handling
+      if value.kind_of?(Integer)
+        value
+      elsif value.kind_of?(String)
+        #FIXME this requires texts hash to have downcase key
+        value = value.downcase
+        if self.class.bit_layouts[bit_field_name].texts && self.class.bit_layouts[bit_field_name].texts[value]
+          self.class.bit_layouts[bit_field_name].texts[value]
+        else
+          case value
+            when /^\d+$/
+              value.to_i
+            when /^0x[\da-fA-F]+$/
+              value.to_i(16)
+            when /^0b[01]+$/
+              value.to_i(2)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ffi/struct_ex/version.rb

@@ -0,0 +1,5 @@
+module Ffi
+  module StructEx
+    VERSION = "0.0.1"
+  end
+end

data/lib/ffi/struct_ex.rb

@@ -0,0 +1,5 @@
+require "ffi/struct_ex/version"
+require "ffi/struct_ex/struct_ex"
+
+module FFI
+end

data/test/test_helper.rb

@@ -0,0 +1 @@
+

data/test/test_struct_ex.rb

@@ -0,0 +1,89 @@
+require 'test_helper'
+require 'test/unit'
+require 'ffi/struct_ex'
+
+class TestStructEx < Test::Unit::TestCase
+  def test_bit_fields
+    subject = Class.new(FFI::StructEx) do
+      layout :field_0, bit_fields(:bits_0_2, 3,
+                                  :bit_3,    1,
+                                  :bit_4,    1,
+                                  :bits_5_7, 3),
+             :field_1, :uint8,
+             :field_2, :uint8,
+             :field_3, [:uint8, 2]
+    end.new
+
+    assert_equal(FFI::StructEx, subject[:field_0].class.superclass)
+
+    subject[:field_0] = 0b0110_1001
+    assert_equal(0b0110_1001, subject[:field_0].read)
+    assert_equal(0b001, subject[:field_0][:bits_0_2])
+
+    subject[:field_0][:bits_0_2] = 0b101
+    assert_equal(0b101, subject[:field_0][:bits_0_2])
+    assert_equal(0b0110_1101, subject[:field_0].read)
+
+    subject[:field_0] = {bits_0_2: 0b001, bit_3: 0b1, bit_4: 0b0, bits_5_7: 0b011}
+    assert_equal(0b0110_1001, subject[:field_0].read)
+    assert_equal(0b001, subject[:field_0][:bits_0_2])
+  end
+
+  def test_pure_bit_fields
+    subject_class = Class.new(FFI::StructEx) do
+      layout :bits_0_2, 3,
+             :bit_3,    1,
+             :bit_4,    1,
+             :bits_5_7, 3
+    end
+
+    subject = subject_class.new
+
+    subject[:bits_0_2] = 0b101
+    assert_equal(0b101, subject[:bits_0_2])
+
+    subject[:bit_3] = 0b1
+    assert_equal(0b1, subject[:bit_3])
+    assert_equal(0b101, subject[:bits_0_2])
+
+    subject = subject_class.new(0b0110_1001)
+    assert_equal(0b001, subject[:bits_0_2])
+    assert_equal(0b1, subject[:bit_3])
+    assert_equal(0b0, subject[:bit_4])
+    assert_equal(0b011, subject[:bits_5_7])
+
+    subject = subject_class.new(bits_0_2: 0b001, bit_3: 0b1, bit_4: 0b0, bits_5_7: 0b011)
+    assert_equal(0b001, subject[:bits_0_2])
+    assert_equal(0b1, subject[:bit_3])
+    assert_equal(0b0, subject[:bit_4])
+    assert_equal(0b011, subject[:bits_5_7])
+    assert_equal(0b0110_1001, subject.read)
+  end
+
+  def test_interpreted_bit_fields
+    subject_class = Class.new(FFI::StructEx) do
+      layout :bits_0_2, 3, {'all_1' => 0b111, 'all_0' => 0b000},
+             :bit_3,    1, {'yes' => 0b1, 'no' => 0b0},
+             :bit_4,    1,
+             :bits_5_7, 3
+    end
+
+    subject = subject_class.new(bits_0_2: 'all_1', bit_3: 'yes')
+    assert_equal(0b111, subject[:bits_0_2])
+    assert_equal(0b1, subject[:bit_3])
+    assert_equal(0b0, subject[:bit_4])
+    assert_equal(0b0, subject[:bits_5_7])
+
+    subject[:bits_0_2] = 'all_0'
+    assert_equal(0b000, subject[:bits_0_2])
+
+    subject[:bits_0_2] = 0b010
+    assert_equal(0b010, subject[:bits_0_2])
+
+    subject[:bit_3] = 'no'
+    assert_equal(0b0, subject[:bit_3])
+
+    subject[:bit_3] = 1
+    assert_equal(0b1, subject[:bit_3])
+  end
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: ffi-struct_ex
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ruijia Li
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A module to add extra functionalities to FFI::Struct
+email:
+- ruijia.li@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitattributes
+- .gitignore
+- .project
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ffi-struct_ex.gemspec
+- lib/ffi/struct_ex.rb
+- lib/ffi/struct_ex/struct_ex.rb
+- lib/ffi/struct_ex/version.rb
+- test/test_helper.rb
+- test/test_struct_ex.rb
+homepage: https://github.com/rli9/ffi-struct_ex
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: A module to add extra functionalities to FFI::Struct
+test_files:
+- test/test_helper.rb
+- test/test_struct_ex.rb