ffi-struct_ex 0.0.3 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 640a03806e45782319f75058970cf5c999927d03
-  data.tar.gz: f5f3247405c6243e66a4d958d356787cb231c7d8
+  metadata.gz: f351f025099f8a13f3c2aeba992b7fd67d8dd90b
+  data.tar.gz: 198834f90618214c7ffb3a811d3de12c114dd4db
 SHA512:
-  metadata.gz: 57dcf4abe3d98e2fe8c0cbcbaed6e17e2ac2a8d877f1c57d53da3f97666099e73de65cca320714451e535ab0a5724361d6c3bbc965838d50d7a58209a4779867
-  data.tar.gz: ece4cba95fbf5095e5151432f072957ed6d3d8eaf4b6e56ace473d745dfa48ccd12c4531464a6cb185698012b1cb942769181e2bcb92649f83023c76378ef8b0
+  metadata.gz: 31828f46959ae2d4a4686b787f0555b3f320c12bfb80d7375920d1a45e8e620a27dc1f75cf13a19233ea157ac208e22f7e1909305cf156ca0b66894e256e22c5
+  data.tar.gz: daf79112bfa648f3aa9343319cf5e21d2cae9668ef1df5a98544e4af347279408032267184325fa080c7bd031446fcc8583327de83bf6b259cbd84d3b3281b39

data/README.md

@@ -18,22 +18,24 @@ Or install it yourself as:
 
 ## Usage
 
-* Struct (only support "unsigned" field)
+* Struct (default type is "unsigned char/short/int" depending on bits size)
 
 ```ruby
 require 'ffi/struct_ex'
 
 class Subject < FFI::StructEx
-  layout :bits_0_2, 3,
-         :bit_3,    1,
+  layout :bits_0_2, 'uint8: 3',
+         :bit_3,    'char: 1',
          :bit_4,    1,
-         :bits_5_7, 3
+         :bits_5_7, 'char: 3'
 end
 
-subject = Subject.new(bits_0_2: 0b001, bit_3: 0b1, bit_4: 0b0, bits_5_7: 0b011)
+Subject.size #=> 1
 
-subject[:bits_0_2] #=> 0b101
-subject.read #=> 0b0110_1001
+subject = Subject.new(bits_0_2: 0b001, bit_3: 0b1, bit_4: 0b1, bits_5_7: 0b100)
+
+subject[:bits_0_2] #=> 1
+subject[:bits_5_7] #=> -4
 ```
 
 * Struct (embedded bit fields)

data/lib/ffi/struct_ex/struct_ex.rb

@@ -9,6 +9,10 @@ class Integer
 
     bytes
   end
+
+  def to_signed(bits_size)
+    self & (1 << bits_size - 1) != 0 ? self - (1 << bits_size) : self
+  end
 end
 
 class String
@@ -26,67 +30,140 @@ end
 
 module FFI
   class StructEx < FFI::Struct
+    SIGNED_NUMBER_TYPES = [FFI::Type::INT8, FFI::Type::INT16, FFI::Type::INT32, FFI::Type::INT64]
+    UNSIGNED_NUMBER_TYPES = [FFI::Type::UINT8, FFI::Type::UINT16, FFI::Type::UINT32, FFI::Type::UINT64]
+
     class << self
       def bit_fields(*field_specs)
-        struct_class = Class.new(StructEx) do
-          layout(*field_specs)
-        end
+        Class.new(FFI::StructLayout::Field) do
+          class << self
+            attr_accessor :struct_class
+
+            def alignment; struct_class.alignment; end
+            def size; struct_class.size; end
+          end
+
+          self.struct_class = Class.new(StructEx) do
+            layout(*field_specs)
+          end
 
-        bit_fields_class = Class.new(FFI::StructLayout::Field) do
           def initialize(name, offset, type)
             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))
+            type.struct_class.new(ptr.slice(offset, size))
           end
 
           def put(ptr, value)
-            self.class.struct_class.new(ptr.slice(self.offset, self.size)).write(value)
+            type.struct_class.new(ptr.slice(offset, size)).write(value)
           end
+        end
+      end
 
+      def bit_field(type, bits_size, bits_offset)
+        Class.new(FFI::StructLayout::Field) do
           class << self
-            attr_accessor :struct_class
+            attr_accessor :type, :bits_size, :bits_offset, :struct_class
+            #no need to implement alignment b/c we always provide offset when adding this field to struct_layout_builder
+          end
 
-            def alignment
-              struct_class.alignment
-            end
+          self.struct_class = Class.new(Struct) do
+            layout('', type)
+          end
 
-            def size
-              struct_class.size
-            end
+          self.type, self.bits_size, self.bits_offset = type, bits_size, bits_offset
+
+          def initialize(name, offset, type)
+            super(name, offset, FFI::Type::Struct.new(self.class.struct_class))
           end
 
-          self.struct_class = struct_class
+          def read(ptr)
+            ptr.slice(offset, size).send("read_uint#{size * 8}".to_sym)
+          end
+
+          def write(ptr, value)
+            ptr.slice(offset, size).send("write_uint#{size * 8}".to_sym, value)
+          end
+
+          def get(ptr)
+            mask = (1 << self.class.bits_size) - 1
+            value = (read(ptr) >> self.class.bits_offset) & mask
+
+            SIGNED_NUMBER_TYPES.include?(self.class.type) ? value.to_signed(self.class.bits_size) : value
+          end
+
+          def put(ptr, value)
+            mask = ((1 << self.class.bits_size) - 1) << self.class.bits_offset
+            write(ptr, (read(ptr) & ~mask) | ((value << self.class.bits_offset) & mask))
+          end
         end
       end
 
-      attr_reader :bits_size, :field_specs, :has_bit_field
+      attr_reader :field_specs
 
-      def layout(*field_specs)
-        return super if field_specs.size == 0
+      private
+      def array_layout(builder, field_specs)
+        @field_specs = {}
 
-        field_spec_class = ::Struct.new(:name, :type, :bits_offset, :descriptors)
+        field_spec_class = ::Struct.new(:name, :type, :descriptors)
 
-        @field_specs = {}
+        current_allocation_unit = nil
 
-        i = bits_offset = 0
+        offset = i = 0
 
         while i < field_specs.size
-          field_name, type = field_specs[i, 2]
+          name, type = field_specs[i, 2]
           i += 2
 
-          unless type.is_a?(Integer)
-            type = find_field_type(type)
-            bits_size = type.size * 8
-
+          unless type.is_a?(Integer) || type.is_a?(String)
+            # If the next param is a Integer, it specifies the offset
             if field_specs[i].is_a?(Integer)
-              bits_offset = field_specs[i] * 8
+              offset = field_specs[i]
               i += 1
+            else
+              offset = nil
             end
+
+            type = find_field_type(type)
+            builder.add name, type, offset
+
+            current_allocation_unit = nil
           else
-            bits_size = type
+            if type.is_a?(Integer)
+              ffi_type, bits_size = UNSIGNED_NUMBER_TYPES.find {|ffi_type| type <= ffi_type.size * 8}, type
+              raise "Unrecognized format #{type}" unless ffi_type
+            elsif type.is_a?(String)
+              m = /^(?<ffi_type>[\w_]+)\s*:\s*(?<bits_size>\d+)$/.match(type.strip)
+              raise "Unrecognized format #{type}" unless m
+
+              ffi_type, bits_size = find_field_type(m[:ffi_type].to_sym), m[:bits_size].to_i
+              raise "Unrecognized type #{type}" unless UNSIGNED_NUMBER_TYPES.include?(ffi_type) || SIGNED_NUMBER_TYPES.include?(ffi_type)
+            end
+
+            raise "Illegal format #{type}" if bits_size > ffi_type.size * 8
+
+            unless current_allocation_unit
+              current_allocation_unit = {ffi_type: ffi_type, bits_size: bits_size}
+              offset = builder.send(:align, builder.size, [@min_alignment || 1, ffi_type.alignment].max)
+            else
+              # Adjacent bit fields are packed into the same 1-, 2-, or 4-byte allocation unit if the integral types are the same size
+              # and if the next bit field fits into the current allocation unit without crossing the boundary
+              # imposed by the common alignment requirements of the bit fields.
+              if ffi_type.size == current_allocation_unit[:ffi_type].size
+                if current_allocation_unit[:bits_size] + bits_size <= ffi_type.size * 8
+                  current_allocation_unit[:bits_size] += bits_size
+                else
+                  offset = builder.send(:align, builder.size, [@min_alignment || 1, ffi_type.alignment].max)
+                  current_allocation_unit[:bits_size] = bits_size
+                end
+              else
+                offset = builder.send(:align, builder.size, [@min_alignment || 1, ffi_type.alignment].max)
+                current_allocation_unit = {ffi_type: ffi_type, bits_size: bits_size}
+              end
+            end
+
+            builder.add name, find_field_type(bit_field(ffi_type, bits_size, current_allocation_unit[:bits_size] - bits_size)), offset
           end
 
           if field_specs[i].is_a?(Hash)
@@ -96,18 +173,7 @@ module FFI
             descriptors = {}
           end
 
-          @field_specs[field_name] = field_spec_class.new(field_name, type, bits_offset, descriptors)
-          bits_offset += bits_size
-        end
-
-        @has_bit_field = @field_specs.any? {|field_name, field_spec| field_spec.type.is_a?(Integer)}
-
-        if @has_bit_field
-          #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#{(bits_offset + 7) & (-1 << 3)}".to_sym)
-        else
-          super(*field_specs.reject {|field_spec| field_spec.is_a?(Hash)})
+          @field_specs[name] = field_spec_class.new(name, type, descriptors)
         end
       end
     end
@@ -121,25 +187,9 @@ module FFI
       end
     end
 
-    def [](field_name)
-      return super unless self.class.has_bit_field
-
-      field_spec = self.class.field_specs[field_name]
-      mask = ((1 << field_spec.type) - 1) << field_spec.bits_offset
-
-      (self.read & mask) >> field_spec.bits_offset
-    end
-
     # Set field value
     def []=(field_name, value)
-      value = map_field_value(field_name, value)
-
-      return super(field_name, value) unless self.class.has_bit_field
-
-      field_spec = self.class.field_specs[field_name]
-      mask = ((1 << field_spec.type) - 1) << field_spec.bits_offset
-
-      self.write((self.read & (-1 - mask)) | ((value << field_spec.bits_offset) & mask))
+      super(field_name, map_field_value(field_name, value))
     end
 
     def write(value)
@@ -185,7 +235,7 @@ module FFI
       return field_spec.descriptors[descriptor_key] if field_spec.descriptors.has_key?(descriptor_key)
 
       type = field_spec.type
-      return value.to_dec if (type.is_a?(Integer) || FFI::StructLayoutBuilder::NUMBER_TYPES.include?(type)) && value.is_a?(String)
+      return value.to_dec if (type.is_a?(Integer) || type.is_a?(String) || FFI::StructLayoutBuilder::NUMBER_TYPES.include?(type)) && value.is_a?(String)
 
       value
     end

data/lib/ffi/struct_ex/version.rb

@@ -1,5 +1,5 @@
 module Ffi
   module StructEx
-    VERSION = "0.0.3"
+    VERSION = "0.1.0"
   end
 end

data/test/test_struct_ex.rb

@@ -5,11 +5,11 @@ require 'ffi/struct_ex'
 class TestStructEx < Test::Unit::TestCase
   def test_bit_fields
     subject_class = Class.new(FFI::StructEx) do
-      layout :field_0, bit_fields(:bits_0_2, 3,
-                                  :bit_3,    1,
-                                  :bit_4,    1,
-                                  :bits_5_7, 3,
-                                  :bits_8_15, 8),
+      layout :field_0, bit_fields(:bits_0_2, 'uint16: 3',
+                                  :bit_3,    'uint16: 1',
+                                  :bit_4,    'uint16: 1',
+                                  :bits_5_7, 'uint16: 3',
+                                  :bits_8_15, 'uint16: 8'),
              :field_1, :uint8,
              :field_2, :uint8,
              :field_3, :uint8
@@ -23,6 +23,7 @@ class TestStructEx < Test::Unit::TestCase
 
     assert_equal(FFI::StructEx, subject[:field_0].class.superclass)
     assert_equal(2, subject[:field_0].size)
+    assert_equal(2, subject[:field_0].alignment)
 
     subject[:field_0] = 0b0110_1001
     assert_equal(0b0110_1001, subject[:field_0].read)
@@ -122,8 +123,8 @@ class TestStructEx < Test::Unit::TestCase
 
     assert_equal(FFI::StructEx, subject[:field_0].class.superclass)
     assert_equal(1, subject[:field_0].size)
-    assert(subject[:field_0] == 0b0110_1001)
-    assert(subject[:field_1] == subject.map_field_value(:field_1, '0x1'))
+    assert_equal(0b0110_1001, subject[:field_0])
+    assert_equal(subject[:field_1], subject.map_field_value(:field_1, '0x1'))
   end
 
   def test_descriptors
@@ -166,12 +167,181 @@ class TestStructEx < Test::Unit::TestCase
     assert_equal(0x00, subject[:field_1])
   end
 
-  # def test_sizeof
-    # subject_class = Class.new(FFI::StructEx) do
-      # layout :field_0, 2,
-             # :field_1, 31
-    # end
-#
-    # assert_equal(8, subject_class.size)
-  # end
+  def test_sizeof
+    assert_equal(4, Class.new(FFI::StructEx) do
+                      layout :field_0, :short,
+                             :field_1, :char,
+                             :field_2, :char
+                    end.size)
+
+    assert_equal(8, Class.new(FFI::StructEx) do
+                      layout :field_0, 31,
+                             :field_1, 31
+                    end.size)
+
+    assert_equal(8, Class.new(FFI::StructEx) do
+                      layout :field_0, 31,
+                             :field_1, :uint8
+                    end.size)
+
+    assert_equal(8, Class.new(FFI::StructEx) do
+                      layout :field_0, 1,
+                             :field_1, :uint32
+                    end.size)
+
+    assert_equal(3, Class.new(FFI::StructEx) do
+                      layout :field_0, 4,
+                             :field_1, 4,
+                             :field_2, 8,
+                             :field_3, :uint8
+                    end.size)
+
+    assert_equal(2, Class.new(FFI::StructEx) do
+                      layout :field_0, 1,
+                             :field_1, 1,
+                             :field_2, :uint8
+                    end.size)
+
+    assert_equal(3, Class.new(FFI::StructEx) do
+                      layout :field_0, 1,
+                             :field_1, 1,
+                             :field_2, :uint8,
+                             :field_3, 1,
+                             :field_4, 1
+                    end.size)
+
+    assert_equal(6, Class.new(FFI::StructEx) do
+                      layout :field_0, 1,
+                             :field_1, 1,
+                             :field_2, :uint16,
+                             :field_3, 1,
+                             :field_4, 1
+                    end.size)
+
+    assert_equal(6, Class.new(FFI::StructEx) do
+                      layout :field_0, 1,
+                             :field_1, 1,
+                             :field_2, :uint16,
+                             :field_3, 1,
+                             :field_4, 8
+                    end.size)
+
+    assert_equal(4, Class.new(FFI::StructEx) do
+                      layout :field_0, 8,
+                             :field_1, 16
+                    end.size)
+
+    assert_equal(4, Class.new(FFI::StructEx) do
+                      layout :field_0, 16,
+                             :field_1, 8
+                    end.size)
+
+    assert_equal(6, Class.new(FFI::StructEx) do
+                      layout :field_0, 1,
+                             :field_1, 16,
+                             :field_2, 1
+                    end.size)
+
+    assert_equal(1, Class.new(FFI::StructEx) do
+                      layout :field_0, 'uint8: 1'
+                    end.size)
+
+    assert_equal(2, Class.new(FFI::StructEx) do
+                      layout :field_0, 'uint16: 1'
+                    end.size)
+
+    assert_equal(4, Class.new(FFI::StructEx) do
+                      layout :field_0, 'uint32: 1'
+                    end.size)
+
+    assert_equal(2, Class.new(FFI::StructEx) do
+                      layout :bits_0_2, 'uint16: 3',
+                             :bit_3,    'uint16: 1',
+                             :bit_4,    'uint16: 1',
+                             :bits_5_7, 'uint16: 3',
+                             :bits_8_15, 'uint16: 8'
+                    end.size)
+
+    assert_equal(1, Class.new(FFI::StructEx) do
+                      layout :field_0, 'uint8: 1',
+                             :field_1, 'uint8: 1'
+                    end.size)
+
+    assert_equal(1, Class.new(FFI::StructEx) do
+                      layout :field_0, 'uint8: 1',
+                             :field_1, 'int8: 1'
+                    end.size)
+
+    assert_equal(8, Class.new(FFI::StructEx) do
+                      layout :field_0, 'uint32: 1',
+                             :field_1, :uint16
+                    end.size)
+
+    assert_equal(8, Class.new(FFI::StructEx) do
+                      layout :field_0, 'uint8: 1',
+                             :field_1, :uint32
+                    end.size)
+
+    assert_equal(8, Class.new(FFI::StructEx) do
+                      layout :field_0, 'uint8: 1',
+                             :field_1, 'uint32: 1'
+                    end.size)
+
+    assert_equal(4, Class.new(FFI::StructEx) do
+                      layout :field_0, :short,
+                             :field_1, :char
+                    end.size)
+
+    assert_equal(4, Class.new(FFI::StructEx) do
+                      layout :field_0, :short,
+                             :field_1, 'char: 1'
+                    end.size)
+
+    subject_class = Class.new(FFI::StructEx) do
+                      layout :field_0, :char,
+                             :field_1, 'short: 1'
+                    end
+    assert_equal(4, subject_class.size)
+
+    subject_class = Class.new(FFI::StructEx) do
+                      layout :field_0, 'uint: 8',
+                             :field_1, 'int: 1'
+                    end
+    assert_equal(4, subject_class.size)
+    subject = subject_class.new
+    subject[:field_0] = 0b0110_1001
+    assert_equal(0b0110_1001, subject[:field_0])
+    subject[:field_0] = 0b1111_1111
+    assert_equal(0b1111_1111, subject[:field_0])
+
+    subject[:field_1] = 1
+    assert_equal(-1, subject[:field_1])
+    subject[:field_1] = 0
+    assert_equal(0, subject[:field_1])
+    subject[:field_1] = -1
+    assert_equal(-1, subject[:field_1])
+
+    #Check no impact for typedef type
+    FFI.typedef :uint8, :UINT8
+    subject_class = Class.new(FFI::StructEx) do
+                      layout :field_0, 'UINT8: 8',
+                             :field_1, 'int: 1'
+                    end
+
+    subject_class = Class.new(FFI::StructEx) do
+      layout :bits_0_2, 'uint8: 3',
+             :bit_3,    'char: 1',
+             :bit_4,    'uint8: 1',
+             :bits_5_7, 'char: 3'
+    end
+
+    assert_equal(1, subject_class.size)
+
+    subject = subject_class.new(bits_0_2: 0b001, bit_3: 0b1, bit_4: 0b1, bits_5_7: 0b100)
+    assert_equal(1, subject[:bits_0_2])
+    assert_equal(-1, subject[:bit_3])
+    assert_equal(1, subject[:bit_4])
+    assert_equal(-4, subject[:bits_5_7])
+
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ffi-struct_ex
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors:
 - Ruijia Li
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-22 00:00:00.000000000 Z
+date: 2014-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi