gogyou 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c1f4c10b0e249b1b9897b5b1c317e0ef5e535830
-  data.tar.gz: c8ccad916b49f45e18d91bff8538cf1b7e5b6377
+  metadata.gz: ff192352d61629b6bcec6f1f4a3ce798c2cab5ff
+  data.tar.gz: 244710ba81429d85608ed708424971d5c1bcd843
 SHA512:
-  metadata.gz: b73dba83766abfce2f63ba2daad894fdf3b7560ed20bfa613d9d388aa707f053dac67f8133f6fe76002eb0958824d8b6cec23fc1a05b58228244d1ab0cfdb503
-  data.tar.gz: 93b5fb1d45270650ff47c10746ec94ddf0b44c59751b8f035af841902a0fc807f02e2c39820447ca9d055aeafa1abc4ee1ab78a9e2f72383e5d7db0a7e325fd1
+  metadata.gz: b575790ca4b409310f7418dcc4e12220a9dfaeb511f4449756ad9997e83abf1c77953efa2d3dcc33c28e8b5fe92e0f71b66bb65ba296603054ab2639b85904eb
+  data.tar.gz: 3cc09af86d7884cca95aa399c912d19963608399273d45dd96cfbedc239c136f718e87ce2d2a8c6918d5757a0e2ddded0d93ff94afe45840f894de9ded4f003c

data/README.markdown

@@ -77,7 +77,7 @@ end
 obj = MyRuby::RObject.new
 # or obj = MyRuby::RObject.new(File.read("sample.bin", MyRuby::RObject.size, mode: "rb"))
 obj.basic.flags = 0x12345678
-(obj.basic.klass = 0xaaaaaaaa) rescue $!  # => exception! klass field is immutable type
+(obj.basic.klass = 0xaaaaaaaa) rescue p $!  # => exception! klass field is immutable type
 obj.basic.force_modify.klass = 0xaaaaaaaa
 obj.as.heap.numiv = 0x55555555
 p obj.as.ary[0]  # => 0x55555555
@@ -97,37 +97,73 @@ p obj.to_buffer  # => "xV4\x12\0\0\0\0\xaa\xaa\xaa\xaa\0\0\0\0UUUU\0\0\0\0DDDD\0
 
     C に似た構造体・共用体に対応 (入れ子構造も可能)
 
-        struct {
-          struct {
-            ....
-            union {
-              ....
-              struct {
-                ....
-              }
-            }
-            ....
-          }
-        }
+    ``` ruby:ruby
+    X = Gogyou.struct {
+      int :a
+      float :b
+      double :c
+      union {
+        struct -> {
+          float :x, y, z
+        }, :d
+        const struct -> {
+          int :x, :y, :z
+        }, :e
+      }
+    }
+    ```
 
 *   Support multidimensional arrays
 
     多次元配列に対応
 
-        struct {
-          char :name, 64, 4  # => char name[64][4];
-        }
+    ``` ruby:ruby
+    Gogyou.struct {
+      char :name, 64, 4  # => char name[64][4];
+    }
+    ```
 
 *   Alias types by `typedef` (with array)
 
     `typedef` による型の別名定義 (配列も可能)
 
-        typedef :float, :vector3f, 3  # => C: typedef float vector3f[3];
+    ``` ruby:ruby
+    module MyModule
+      extend Gogyou
+
+      typedef :float, :vector3f, 3  # => C: typedef float vector3f[3];
+
+      X = struct {                  #       struct X {
+        vector3f :a                 #           vector3f a;
+        vector3f :b, 4              #           vector3f b[4];
+      }                             #       };
+    end
+    ```
+
+*   Support packed struct liked GCC ``__attribute__((packed))``
+
+    GCC の ``__attribute__((packed))`` に似た、パックされた構造体に対応
+
+    C 言語での記述
+
+    ``` c:c
+    struct X
+    {
+        char a;
+        int b;
+    } __attribute__((packed));
+    ```
+
+    ruby による記述
 
-        X = struct {      # struct X {
-          vector3f :a     #     vector3f a;
-          vector3f :b, 4  #     vector3f b[4];
-        }                 # };
+    ``` ruby:ruby
+    X = Gogyou.struct {
+      packed {
+        char :a
+        int :b
+      }
+    }
+    ```
 
 *   Appended bit operation for Integer
 
@@ -284,7 +320,7 @@ struct 内の struct の呼び出し方法を示します。union も同様に
 
 例として、MD5 を定義する場合の型情報は次のようになります。
 
-```ruby:ruby
+``` ruby:ruby
 class MD5
   def self.bytesize
     16
@@ -308,6 +344,18 @@ class MD5
 end
 ```
 
+これらのメソッドを一つ一つ定義する代わりに、任意のクラス・モジュールの中で ``Gogyou.define_typeinfo`` を用いることでまとめて定義することも出来ます。
+
+``` ruby:ruby
+class MD5
+  Gogyou.define_typeinfo(16,    # bytesize
+                         1,     # bytealign
+                         false, # extensible?
+                         ->(buffer, offset) { ... snip ... },       # aref
+                         ->(buffer, offset, data) { ... snip ... }) # aset
+end
+```
+
 順を追って説明していきます。
 
 ### `.bytesize`
@@ -413,6 +461,60 @@ class MD5
 end
 ```
 
+## Define packed struct
+
+GCC の ``__attribute__((packed))`` に似たパックされた構造体のフィールドを定義するには、そのフィールドを ``packed`` メソッドのブロックとして囲うことで行います。
+
+構造体自体をパックするには、その構造体のフィールド全体を ``packed`` することで行います。
+
+また、``packed`` の中に ``struct`` や ``union`` を含めることも出来、その入れ子内部で ``packed`` を行うことも出来ます。
+
+ただし ``packed`` を直接入れ子にして呼び出すことは出来ません。
+
+構造体全体を ``packed`` する場合:
+
+``` ruby:ruby
+X = Gogyou.struct {
+  packed {
+    char :a
+    int :b
+    int :c
+  }
+}
+
+p X.bytesize # => 9
+```
+
+``packed`` された入れ子構造体の内部でさらに ``packed`` する場合:
+
+``` ruby:ruby
+Y = Gogyou.struct {
+  char :a
+  packed {
+    struct {
+      int :b
+    }
+  }
+  char :c, 3
+  int :d
+}
+
+p Y.bytesize # => 12
+```
+
+直接入れ子にして ``packed`` して例外が発生する場合:
+
+``` ruby:ruby
+Z = Gogyou.struct {
+  packed {
+    packed {  ## => EXCEPTION!
+      char :a
+      int :b
+    }
+  }
+}
+```
+
 
 ## Demerit (短所)
 
@@ -423,7 +525,3 @@ end
 *   The cost is high for reference/asignment from/to fields
 
     フィールドに対する参照・代入のコストが高い
-
-*   Can't be definition for packed struct
-
-    パックされた構造体の定義が出来ない (常にフィールドは型によるバイト境界に強制配置される)

data/lib/gogyou.rb

@@ -141,7 +141,7 @@
 #
 module Gogyou
   Gogyou = self
-  VERSION = Gem::Version.new("0.2.1")
+  VERSION = Gem::Version.new("0.2.2")
 
   require_relative "gogyou/typespec"
   require_relative "gogyou/mixin"
@@ -196,6 +196,89 @@ module Gogyou
     end
   end
 
+  #
+  # call-seq:
+  #   define_typeinfo(type, bytesize, bytealign, extensible, aref, aset) -> type
+  #
+  # ``type`` に対して、型情報子とするための特異メソッドである ``#bytesize`` ``#bytealign`` ``#extensible?`` ``#aref`` ``#aset`` を定義します。
+  #
+  # ``bytesize`` と ``bytealign`` には整数値、文字列、nil を与えます。
+  #
+  # ``extensible`` には真偽値、文字列、nil を与えます。
+  #
+  # ``aref`` には、引数として ``(buffer, offset)`` を受け取る Proc オブジェクト、文字列、nil を与えます。
+  #
+  # ``aset`` には、引数として ``(buffer, offset, value)`` を受け取る Proc オブジェクト、文字列、nil を与えます。
+  #
+  # これらの引数に文字列を与えた場合、メソッド定義コードとして直接埋め込まれます。
+  #
+  # ``bytesize`` と ``bytealign``、``extensible`` の引数はありません。
+  #
+  # ``aref`` の文字列内部で利用できる引数は ``buffer`` ``offset`` です。
+  #
+  # ``aset`` の文字列内部で利用できる引数は ``buffer`` ``offset`` ``value`` です。
+  #
+  # また nil を与えた場合は、対応するメソッドの定義を省略します。
+  #
+  # 常に ``type`` を返します。
+  #
+  def self.define_typeinfo(type, bytesize, bytealign, extensible, aref, aset)
+    type.instance_eval do
+      unless bytesize.nil?
+        bytesize = bytesize.to_i unless bytesize.kind_of?(String)
+        eval <<-EOM
+          def bytesize
+            #{bytesize}
+          end
+        EOM
+      end
+
+      unless bytealign.nil?
+        bytealign = bytealign.to_i unless bytealign.kind_of?(String)
+        eval <<-EOM
+          def bytealign
+            #{bytealign}
+          end
+        EOM
+      end
+
+      unless extensible.nil?
+        extensible = (!!extensible).inspect unless extensible.kind_of?(String)
+        eval <<-EOM
+          def extensible?
+            #{extensible}
+          end
+        EOM
+      end
+
+      unless aref.nil?
+        if aref.kind_of?(String)
+          eval <<-EOM
+            def aref(buffer, offset)
+              #{aref}
+            end
+          EOM
+        else
+          define_singleton_method(:aref, aref)
+        end
+      end
+
+      unless aset.nil?
+        if aset.kind_of?(String)
+          eval <<-EOM
+            def aset(buffer, offset, value)
+              #{aset}
+            end
+          EOM
+        else
+          define_singleton_method(:aset, aset)
+        end
+      end
+    end
+
+    type
+  end
+
   #
   # 構造体 (もどき) を定義します。
   #

data/lib/gogyou/accessor.rb

@@ -90,7 +90,7 @@ module Gogyou
 
     def inspect
       "#<%s buffer=%p, offset=%p>" % [self.class,
-                                      buffer__GOGYOU__,
+                                      buffer__GOGYOU__.inspect,
                                       offset__GOGYOU__]
     end
 
@@ -337,7 +337,7 @@ module Gogyou
         case value
         when ::String
           raise ArgumentError, "buffer size too small" unless value.bytesize < self::BYTESIZE
-          buffer.setbinary(offset, value, self::BYTESIZE, 0)
+          buffer.setbinary(offset, value, 0, self::BYTESIZE)
         when ::Array
           raise NotImplementedError
         when self::SUBTYPE

data/lib/gogyou/mixin.rb

@@ -231,7 +231,7 @@ module Gogyou
           self
         end
 
-        def setbinary(index, str, bytesize = str.bytesize, offset = 0)
+        def setbinary(index, str, offset = 0, bytesize = str.bytesize)
           offset = offset.to_i
           bytesize = bytesize.to_i
           size1 = str.bytesize - offset

data/lib/gogyou/model.rb

@@ -66,13 +66,14 @@ module Gogyou
                                :name,   # field name
                                :vector, # 要素数。任意数配列の場合は 0。配列でないならば nil。
                                :type,   # type specification (or model object) of this field
-                               :flags)  # 0x01: const / 0x02: packed (not aligned)
+                               :flags)  # LSB-0+8: packed size exponent (not aligned) / LSB-16: const
       BasicStruct = superclass
 
-      FLAG_CONST  = 0x01
-      FLAG_PACKED = 0x02
+      CONST_BITMASK  = 1 << 16
+      PACKSIZE_BITMASK = 0xff
+      PACKSIZE_NOTDEFINE = 20 # = (1 << 20) = 1 MiB # 事実上の無限
 
-      def initialize(offset, name, vector, type, flags = 0)
+      def initialize(offset, name, vector, type, flags = 0 | PACKSIZE_NOTDEFINE)
         super(offset, name, vector, type, flags)
       end
 
@@ -85,25 +86,30 @@ module Gogyou
       end
 
       def const?
-        ((flags & FLAG_CONST) == FLAG_CONST) ? true : false
+        ((flags & CONST_BITMASK) == CONST_BITMASK) ? true : false
       end
 
       def packed?
-        ((flags & FLAG_PACKED) == FLAG_PACKED) ? true : false
+        ((flags & PACKSIZE_BITMASK) == PACKSIZE_NOTDEFINE) ? false : true
       end
 
-      def mark_const
-        self.flags |= FLAG_CONST
+      def set_const
+        self.flags |= CONST_BITMASK
         self
       end
 
-      def mark_packed
-        self.flags |= FLAGS_PACKED
+      def set_packsize(pack_exponent)
+        pack_exponent = PACKSIZE_NOTDEFINE if pack_exponent > PACKSIZE_NOTDEFINE
+        self.flags = flags.setbit(0, 8, pack_exponent)
         self
       end
 
+      def packsize
+        1 << flags.getbit(0, 8)
+      end
+
       def strflags
-        set = [const? ? "const" : nil, packed? ? "packed" : nil]
+        set = [const? ? "const" : nil, packed? ? "packed(#{packsize})" : nil]
         set.compact!
         return nil if set.empty?
         set.join(",")
@@ -145,12 +151,12 @@ module Gogyou
       end
     end
 
-    def self.struct(typemap, &block)
-      define_container(typemap, Model::Struct, &block)
+    def self.struct(typemap, packexp = Field::PACKSIZE_NOTDEFINE, &block)
+      define_container(typemap, packexp, Model::Struct, &block)
     end
 
-    def self.union(typemap, &block)
-      define_container(typemap, Model::Union, &block)
+    def self.union(typemap, packexp = Field::PACKSIZE_NOTDEFINE, &block)
+      define_container(typemap, packexp, Model::Union, &block)
     end
 
     def self.typedef(typemap, type, aliasname, *elements)
@@ -178,9 +184,9 @@ module Gogyou
       nil
     end
 
-    def self.define_container(typemap, model_type, &block)
+    def self.define_container(typemap, packexp, model_type, &block)
       creator = model_type::Creator.new(typemap, 0, [])
-      proxy = model_type::Creator::Proxy.new(creator)
+      proxy = model_type::Creator::Proxy.new(creator, packexp)
       proxy.instance_exec(&block)
       model = creator.to_model
       model
@@ -205,7 +211,7 @@ module Gogyou
 
     class BasicCreator
       def maxalign(fields = self.fields)
-        fields.map { |f| f.type.bytealign }.max
+        fields.map { |f| f.packed? ? f.packsize : f.type.bytealign }.max
       end
 
       def maxsize(fields = self.fields)
@@ -223,7 +229,7 @@ module Gogyou
           else
             raise "BUG? : field.type is not a Model (%p)" % f.type unless f.type.kind_of?(Model)
             fs = flatten_field(f.type.fields)
-            fs.each { |ff| ff.offset += f.offset; ff.mark_const if f.const? }
+            fs.each { |ff| ff.offset += f.offset; ff.set_const if f.const? }
             fields2.concat fs
           end
         end
@@ -233,23 +239,42 @@ module Gogyou
       # :nodoc: all
       class Proxy < Object
       #class Proxy < BasicObject
-        def initialize(creator)
+        def initialize(creator, packexp = Field::PACKSIZE_NOTDEFINE)
           #singleton_class = (class << proxy; self; end)
           singleton_class.class_eval do
             latest_fields = nil
             #define_method(:method_missing, ->(type, *args) { latest_fields = creator.addfield(type, args); nil })
             creator.typemap.each_key do |t|
-              define_method(t, ->(*args) { latest_fields = creator.addfield(t, args); nil })
+              define_method(t, ->(*args) { latest_fields = creator.addfield(t, packexp, args); nil })
             end
-            define_method(:struct, ->(*args, &block) { latest_fields = creator.struct(args, &block); nil })
-            define_method(:union, ->(*args, &block) { latest_fields = creator.union(args, &block); nil })
+            define_method(:struct, ->(*args, &block) { latest_fields = creator.struct(args, packexp, &block); nil })
+            define_method(:union, ->(*args, &block) { latest_fields = creator.union(args, packexp, &block); nil })
             define_method(:const, ->(dummy_fields) { creator.const(latest_fields); latest_fields = nil; nil })
             define_method(:typedef, ->(*args, &block) { creator.typedef(args, &block) })
+            packexp0 = nil
+            define_method(:packed, ->(bytealign = 1, &block) {
+              raise "wrong nested ``packed''" if packexp0
+              exp = Math.log(bytealign, 2)
+              # exp が Nan Infinity -Infinity の場合は例外が発生するので、それに対する処置も行う
+              unless ((exp = exp.to_i) rescue nil) && (1 << exp) == bytealign
+                raise ArgumentError, "shall be given power of two (but #{bytealign})"
+              end
+
+              begin
+                packexp0 = packexp
+                packexp = exp
+                self.instance_exec(&block)
+              ensure
+                (packexp, packexp0) = packexp0, nil
+              end
+
+              nil
+            })
             if creator.respond_to?(:bytealign)
-              define_method(:bytealign, ->(bytesize, &block) { creator.bytealign(bytesize, &block) })
+              define_method(:bytealign, ->(bytesize, &block) { creator.bytealign(bytesize, &block); nil })
             end
             if creator.respond_to?(:padding)
-              define_method(:padding, ->(bytesize, &block) { creator.padding(bytesize, &block) })
+              define_method(:padding, ->(bytesize, &block) { creator.padding(bytesize, &block); nil })
             end
           end
         end
@@ -287,8 +312,8 @@ module Gogyou
       #     }
       #   }
       #
-      def struct(args, &block)
-        define_container(args, block, Model.method(:struct))
+      def struct(args, packexp, &block)
+        define_container(args, packexp, block, Model.method(:struct))
       end
 
       #
@@ -306,24 +331,24 @@ module Gogyou
       # この記述ができる唯一の理由は、人間が見てわかりやすくすることを意図しています
       # (ただし、ミスリードを誘う手口にも利用されてしまうのが最大の欠点です)。
       #
-      def union(args, &block)
-        define_container(args, block, Model.method(:union))
+      def union(args, packexp, &block)
+        define_container(args, packexp, block, Model.method(:union))
       end
 
-      def define_container(args, anonymblock, container)
+      def define_container(args, packexp, anonymblock, container)
         if anonymblock
           raise ArgumentError, "given block and arguments" unless args.empty?
-          model = container.(typemap.dup, &anonymblock)
+          model = container.(typemap.dup, packexp, &anonymblock)
           raise "BUG - object is not a Model (#{model.class})" unless model.kind_of?(Model)
           #p model: model, superclass: model.superclass
           self.offset = offset.align_ceil(model.bytealign) unless kind_of?(Model::Union::Creator)
-          fields << f = Field[offset, nil, nil, model, 0]
+          fields << f = Field[offset, nil, nil, model, packexp]
           self.offset += model.bytesize unless kind_of?(Model::Union::Creator)
           [f]
         else
           type = args.shift
-          type = container.(typemap.dup, &type) if type.kind_of?(::Proc)
-          addfield!(type, args)
+          type = container.(typemap.dup, packexp, &type) if type.kind_of?(::Proc)
+          addfield!(type, packexp, args)
         end
       end
 
@@ -332,7 +357,7 @@ module Gogyou
       end
 
       def const(fields)
-        fields.each { |f| f.mark_const }
+        fields.each { |f| f.set_const }
       end
 
       #
@@ -371,16 +396,16 @@ module Gogyou
         nil
       end
 
-      def addfield(type, args)
+      def addfield(type, packexp, args)
         typeobj = typemap[type.intern]
         unless typeobj
           raise NoMethodError, "typename or method is missing (#{type})"
         end
 
-        addfield!(typeobj, args)
+        addfield!(typeobj, packexp, args)
       end
 
-      def addfield!(typeobj, args)
+      def addfield!(typeobj, packexp, args)
         #p typeobj
         # check extensible field  >>>  creator.fields[-1].vector[-1]
         if (x = fields[-1]) && (x = x.vector) && x[-1] == 0
@@ -388,13 +413,13 @@ module Gogyou
         end
 
         typesize = typeobj.bytesize
-        typealign = typeobj.bytealign
+        typealign = [typeobj.bytealign, 1 << packexp].min
 
         tmpfields = []
 
         parse!(args) do |name, vect|
           self.offset = offset.align_ceil(typealign) unless kind_of?(Model::Union::Creator)
-          fields << f = Field[offset, name, vect, typeobj, 0]
+          fields << f = Field[offset, name, vect, typeobj, 0 | packexp]
           tmpfields << f
           unless kind_of?(Model::Union::Creator)
             elements = vect ? vect.inject(1, &:*) : 1

data/spec/gogyou_spec.rb

@@ -35,8 +35,8 @@ describe Gogyou::Model do
 
     reference = Gogyou::Model::Union[
       4, 4,
-      Gogyou::Model::Field[0, :a, nil, Gogyou::Primitives::INT32_T, 0x00],
-      Gogyou::Model::Field[0, :b, nil, Gogyou::Primitives::UINT32_T, 0x00]
+      Gogyou::Model::Field[0, :a, nil, Gogyou::Primitives::INT32_T],
+      Gogyou::Model::Field[0, :b, nil, Gogyou::Primitives::UINT32_T]
     ]
 
     expect(x::MODEL).to eq reference
@@ -57,11 +57,11 @@ describe Gogyou::Model do
 
     ref = Gogyou::Model::Struct[
       32, 8,
-      Gogyou::Model::Field[0, :a, nil, Gogyou::Primitives::CHAR, 0],
-      Gogyou::Model::Field[8, :b, nil, Gogyou::Primitives::INT, 0],
-      Gogyou::Model::Field[8, :c, nil, Gogyou::Primitives::INT64_T, 0],
-      Gogyou::Model::Field[16, :d, nil, Gogyou::Primitives::INT32_T, 0],
-      Gogyou::Model::Field[24, :e, nil, Gogyou::Primitives::CHAR, 0]
+      Gogyou::Model::Field[0, :a, nil, Gogyou::Primitives::CHAR],
+      Gogyou::Model::Field[8, :b, nil, Gogyou::Primitives::INT],
+      Gogyou::Model::Field[8, :c, nil, Gogyou::Primitives::INT64_T],
+      Gogyou::Model::Field[16, :d, nil, Gogyou::Primitives::INT32_T],
+      Gogyou::Model::Field[24, :e, nil, Gogyou::Primitives::CHAR]
     ]
 
     expect(x::MODEL).to eq ref
@@ -81,12 +81,12 @@ describe Gogyou::Model do
 
     ref = Gogyou::Model::Struct[
       72, 8,
-      Gogyou::Model::Field[0, :a, nil, Gogyou::Primitives::CHAR, 0x00],
-      Gogyou::Model::Field[8, :b, nil, Gogyou::Primitives::INT, 0x00],
+      Gogyou::Model::Field[0, :a, nil, Gogyou::Primitives::CHAR],
+      Gogyou::Model::Field[8, :b, nil, Gogyou::Primitives::INT],
       Gogyou::Model::Field[8, :e, [4], Gogyou::Model::Struct[
         16, 8,
-        Gogyou::Model::Field[0, :c, nil, Gogyou::Primitives::INT64_T, 0x00],
-        Gogyou::Model::Field[8, :d, nil, Gogyou::Primitives::INT32_T, 0x00]], 0x00]]
+        Gogyou::Model::Field[0, :c, nil, Gogyou::Primitives::INT64_T],
+        Gogyou::Model::Field[8, :d, nil, Gogyou::Primitives::INT32_T]]]]
     expect(x::MODEL).to eq ref
   end
 
@@ -108,8 +108,8 @@ describe Gogyou::Model do
 
     ref = Gogyou::Model::Union[
       24, 8,
-      Gogyou::Model::Field[0, :a, nil, x, 0x00],
-      Gogyou::Model::Field[0, :b, nil, x, 0x00]]
+      Gogyou::Model::Field[0, :a, nil, x],
+      Gogyou::Model::Field[0, :b, nil, x]]
     expect(y::MODEL).to eq ref
   end
 end
@@ -163,4 +163,144 @@ describe Gogyou::Accessor do
     obj = type.new
     expect(obj.bytesize).to eq 20
   end
+
+  it "packed struct" do
+    type1 = Gogyou.struct {
+      packed(1) {
+        char :a
+        int32_t :b
+      }
+    }
+
+    expect(type1.bytesize).to eq 5
+    expect(type1.bytealign).to eq 1
+    expect(type1.extensible?).to eq false
+    expect(type1.new.bytesize).to eq 5
+
+    type2 = Gogyou.struct {
+      packed(2) {
+        char :a
+        int32_t :b
+      }
+    }
+
+    expect(type2.bytesize).to eq 6
+    expect(type2.bytealign).to eq 2
+    expect(type2.extensible?).to eq false
+    expect(type2.new.bytesize).to eq 6
+  end
+
+  it "packed and nested struct" do
+    type1 = Gogyou.struct {
+      struct {
+        packed(1) {
+          char :a
+          int32_t :b
+        }
+      }
+    }
+
+    expect(type1.bytesize).to eq 5
+    expect(type1.bytealign).to eq 1
+    expect(type1.extensible?).to eq false
+    expect(type1.new.bytesize).to eq 5
+
+    type2 = Gogyou.struct {
+      packed(1) {
+        struct {
+          char :a
+          int32_t :b
+        }
+      }
+    }
+
+    expect(type2.bytesize).to eq 5
+    expect(type2.bytealign).to eq 1
+    expect(type2.extensible?).to eq false
+    expect(type2.new.bytesize).to eq 5
+
+    type3 = Gogyou.struct {
+      packed(1) {
+        struct -> {
+          char :a
+          int32_t :b
+        }, :x
+      }
+    }
+
+    expect(type3.bytesize).to eq 5
+    expect(type3.bytealign).to eq 1
+    expect(type3.extensible?).to eq false
+    expect(type3.new.bytesize).to eq 5
+  end
+
+  it "packed and nested struct" do
+    type1 = Gogyou.struct {
+      packed(2) {
+        struct {
+          packed(1) {
+            char :a
+            int32_t :b
+          }
+        }
+      }
+    }
+
+    expect(type1.bytesize).to eq 6
+    expect(type1.bytealign).to eq 2
+    expect(type1.extensible?).to eq false
+    expect(type1.new.bytesize).to eq 6
+
+    expect {
+      Gogyou.struct {
+        packed(1) {
+          packed(2) {
+            struct {
+              char :a
+              int32_t :b
+            }
+          }
+        }
+      }
+    }.to raise_error RuntimeError
+  end
+end
+
+describe "user typeinfo" do
+  it "definition and use" do
+    x1 = Object.new
+    Gogyou.define_typeinfo(x1, 8.0, Rational(5, 2), false,
+                           ->(buffer, offset) { buffer.byteslice(offset, 8) },
+                           ->(buffer, offset, value) { buffer.setbinary(offset, value, 0, 16) })
+    expect(x1.bytesize).to eq 8
+    expect(x1.bytealign).to eq 2
+    expect(x1.extensible?).to eq false
+
+    x2 = Object.new
+    Gogyou.define_typeinfo(x2, "16", "4", "false",
+                           "buffer.byteslice(offset, 16)",
+                           "buffer.setbinary(offset, value.downcase, 0, 16)")
+    expect(x2.bytesize).to eq 16
+    expect(x2.bytealign).to eq 4
+    expect(x2.extensible?).to eq false
+
+    type = Gogyou.struct {
+      struct x1, :a
+      struct x2, :b
+    }
+
+    expect(type.bytesize).to eq 24
+    expect(type.bytealign).to eq 4
+    expect(type.extensible?).to eq false
+
+    v = type.bind("abcdefghijklmnopqrstuvwx")
+    expect(v.bytesize).to eq 24
+    expect(v.size).to eq 2
+    expect(v.a).to eq "abcdefgh"
+    v.a = "ABCDEFGH"
+    expect(v.buffer).to eq "ABCDEFGHijklmnopqrstuvwx"
+    expect(v.b).to eq "ijklmnopqrstuvwx"
+    v.b = "0ijklmnopqrstuv9wx"
+    expect(v.buffer).to eq "ABCDEFGH0ijklmnopqrstuv9"
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gogyou
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - dearblue
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-11 00:00:00.000000000 Z
+date: 2014-09-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -57,8 +57,8 @@ extra_rdoc_files:
 - lib/gogyou/accessor.rb
 - lib/gogyou/mixin.rb
 - lib/gogyou/model.rb
-- lib/gogyou/primitives.rb
 - lib/gogyou/typespec.rb
+- lib/gogyou/primitives.rb
 files:
 - LICENSE.markdown
 - README.markdown