gogyou 0.2.2 → 0.2.3

data/lib/gogyou/mixin.rb

@@ -320,15 +320,15 @@ module Gogyou
         end
 
         def loadu8(index)
-          getbyte(index.to_i)
+          getbyte(index)
         end
 
         def loadi8(index)
-          loadu8(index).extendsign(8)
+          getbyte(index).extendsign(8)
         end
 
         def loadu16be(index)
-          (loadu8(index) << 8) | loadu8(index + 1)
+          (getbyte(index) << 8) | getbyte(index + 1)
         end
 
         def loadi16be(index)
@@ -336,7 +336,7 @@ module Gogyou
         end
 
         def loadu16le(index)
-          loadu8(index) | (loadu8(index + 1) << 8)
+          getbyte(index) | (getbyte(index + 1) << 8)
         end
 
         def loadi16le(index)
@@ -344,7 +344,7 @@ module Gogyou
         end
 
         def loadu24be(index)
-          (loadu8(index) << 16) | (loadu8(index + 1) << 8) | loadu8(index + 2)
+          (getbyte(index) << 16) | (getbyte(index + 1) << 8) | getbyte(index + 2)
         end
 
         def loadi24be(index)
@@ -352,7 +352,7 @@ module Gogyou
         end
 
         def loadu24le(index)
-          loadu8(index) | (loadu8(index + 1) << 8) | (loadu8(index + 2) << 16)
+          getbyte(index) | (getbyte(index + 1) << 8) | (getbyte(index + 2) << 16)
         end
 
         def loadi24le(index)
@@ -360,7 +360,7 @@ module Gogyou
         end
 
         def loadu32be(index)
-          (loadu8(index) << 24) | (loadu8(index + 1) << 16) | (loadu8(index + 2) << 8) | loadu8(index + 3)
+          (getbyte(index) << 24) | (getbyte(index + 1) << 16) | (getbyte(index + 2) << 8) | getbyte(index + 3)
         end
 
         def loadi32be(index)
@@ -368,7 +368,7 @@ module Gogyou
         end
 
         def loadu32le(index)
-          loadu8(index) | (loadu8(index + 1) << 8) | (loadu8(index + 2) << 16) | (loadu8(index + 3) << 24)
+          getbyte(index) | (getbyte(index + 1) << 8) | (getbyte(index + 2) << 16) | (getbyte(index + 3) << 24)
         end
 
         def loadi32le(index)

data/lib/gogyou/model.rb

@@ -13,14 +13,24 @@ module Gogyou
 
     undef :bytesize=, :bytealign=, :fields=
 
-    def initialize(*args)
-      case
-      when args.size < 3
-        raise ArgumentError, "wrong argument size (#{args.size} for 3+)"
-      when args.size < 4 && args[2].kind_of?(::Array)
+    #
+    # call-seq:
+    #   initialize(bytesize, bytealign, fields, ...)
+    #
+    # [bytesize]
+    #   This is total model size in bytes.
+    #
+    # [bytealign]
+    #   This is model alignment size in bytes.
+    #
+    # [fields ...]
+    #   These are one or more field instance.
+    #
+    def initialize(bytesize, bytealign, field1, *fields)
+      if fields.empty? && field1.kind_of?(::Array)
         super
       else
-        super(args[0], args[1], args.slice(2 .. -1))
+        super bytesize.to_i, bytealign.to_i, [field1, *fields]
       end
     end
 
@@ -85,6 +95,11 @@ module Gogyou
         end
       end
 
+      def bytesize
+        s = type.bytesize
+        vector ? vector.inject(&:*) * s : s
+      end
+
       def const?
         ((flags & CONST_BITMASK) == CONST_BITMASK) ? true : false
       end
@@ -215,7 +230,7 @@ module Gogyou
       end
 
       def maxsize(fields = self.fields)
-        fields.map { |f| s = f.type.bytesize; f.vector ? f.vector.inject(&:*) * s : s }.max
+        fields.map { |f| f.bytesize }.max
       end
 
       def flatten_field(fields = self.fields)
@@ -236,59 +251,15 @@ module Gogyou
         fields2
       end
 
-      # :nodoc: all
-      class Proxy < Object
-      #class Proxy < BasicObject
-        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, packexp, args); nil })
-            end
-            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); nil })
-            end
-            if creator.respond_to?(:padding)
-              define_method(:padding, ->(bytesize, &block) { creator.padding(bytesize, &block); nil })
-            end
-          end
-        end
-      end
-
       #
       # call-seq:
       #   struct type, name, *vector
       #   struct proc, name, *vector
       #   struct { ... }
       #
-      # 最初の呼び出し方法は、既存の (typedef していない) 型情報を用いる、または構造体をその場で定義するために利用できます。
+      # 最初と二番目の呼び出し方法は、既存の (typedef していない) 型情報を用いる、または構造体をその場で定義するために利用できます。
       #
-      # 二番目の呼び出し方法は、無名構造体を定義するために利用できます。
+      # 三番目の呼び出し方法は、無名構造体を定義するために利用できます。
       #
       # === example (型情報を用いる)
       #
@@ -360,6 +331,28 @@ module Gogyou
         fields.each { |f| f.set_const }
       end
 
+      #
+      # call-seq:
+      #   packed { ... } -> nil
+      #   packed(bytealign) { ... } -> nil
+      #
+      # ブロック内部のフィールドのバイトアライメントを調節します。
+      #
+      # packed を直接の入れ子にして呼び出すことは出来ません。struct や union を挟んで呼び出すことは出来ます。
+      #
+      # 引数無しで呼び出した場合は、bytealign に 1 を与えて呼び出すものと同義となります。
+      #
+      # [bytealign]
+      #   1 以上で2の冪乗となる整数値を指定します。
+      #
+      #   nil を与えた場合、上位階層で指定したパックサイズを無効化して本来のバイトアライメントに配置するようにします。
+      #
+      def packed(bytealign = 1)
+        raise "This method is defined for documentaion. Real implemented is in Gogyou::Model::BasicCreator::Proxy#initialize"
+        yield
+        nil
+      end
+
       #
       # フィールド名の解析
       #
@@ -429,6 +422,53 @@ module Gogyou
 
         tmpfields
       end
+
+      class Proxy < Object # :nodoc: all
+      #class Proxy < BasicObject
+        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, packexp, args); nil })
+            end
+            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
+              if bytealign.nil?
+                exp = Field::PACKSIZE_NOTDEFINE
+              else
+                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
+              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); nil })
+            end
+            if creator.respond_to?(:padding)
+              define_method(:padding, ->(bytesize, &block) { creator.padding(bytesize, &block); nil })
+            end
+          end
+        end
+      end
     end
 
     class Struct < Model

data/lib/gogyou/primitives.rb

@@ -22,26 +22,23 @@ module Gogyou
       end
 
       def to_s
-        "#{self.class}[name=#{name.inspect}, bytesize=#{bytesize.inspect}, bytealign=#{bytealign.inspect}]"
+        "\#<#{self.class}:#{name} bytesize=#{bytesize.inspect}, bytealign=#{bytealign.inspect}>"
       end
 
       alias inspect to_s
 
       def pretty_print(q)
         #name, bytesize, bytealign
-        q.group(1, "#{self.class}[") do
-          q.text "name="
-          q.pp name
-          q.text ", "
-          #q.breakable
+        q.group(1, "\#<#{self.class}:#{name}") do
+          q.breakable " "
           q.text "bytesize="
           q.pp bytesize
-          q.text ", "
-          #q.breakable
+          q.text ","
+          q.breakable " "
           q.text "bytealign="
           q.pp bytealign
         end
-        q.text "]"
+        q.text ">"
       end
     end
 
@@ -69,24 +66,12 @@ module Gogyou
     UINT16_T  = Primitive[:uint16_t, 2, 2,
                           ->(buf, offset, num) { buf.store16(offset, num) },
                           ->(buf, offset) { buf.loadu16(offset) }].freeze
-    INT24_T   = Primitive[:int24_t, 3, 1,
-                          ->(buf, offset, num) { buf.store24(offset, num) },
-                          ->(buf, offset) { buf.loadi24(offset) }].freeze
-    UINT24_T  = Primitive[:uint24_t, 3, 1,
-                          ->(buf, offset, num) { buf.store24(offset, num) },
-                          ->(buf, offset) { buf.loadu24(offset) }].freeze
     INT32_T   = Primitive[:int32_t, 4, 4,
                           ->(buf, offset, num) { buf.store32(offset, num) },
                           ->(buf, offset) { buf.loadi32(offset) }].freeze
     UINT32_T  = Primitive[:uint32_t, 4, 4,
                           ->(buf, offset, num) { buf.store32(offset, num) },
                           ->(buf, offset) { buf.loadu32(offset) }].freeze
-    INT48_T   = Primitive[:int48_t, 6, 2,
-                          ->(buf, offset, num) { buf.store48(offset, num) },
-                          ->(buf, offset) { buf.loadi48(offset) }].freeze
-    UINT48_T  = Primitive[:uint48_t, 6, 2,
-                          ->(buf, offset, num) { buf.store48(offset, num) },
-                          ->(buf, offset) { buf.loadu48(offset) }].freeze
     INT64_T   = Primitive[:int64_t, 8, 8,
                           ->(buf, offset, num) { buf.store64(offset, num) },
                           ->(buf, offset) { buf.loadi64(offset) }].freeze
@@ -159,24 +144,12 @@ module Gogyou
     UINT16_SWAP = Primitive[:uint16_swap, 2, 2,
                           ->(buf, offset, num) { buf.store16swap(offset, num) },
                           ->(buf, offset) { buf.loadu16swap(offset) }].freeze
-    INT24_SWAP = Primitive[:int24_swap, 3, 1,
-                          ->(buf, offset, num) { buf.store24swap(offset, num) },
-                          ->(buf, offset) { buf.loadi24swap(offset) }].freeze
-    UINT24_SWAP = Primitive[:uint24_swap, 3, 1,
-                          ->(buf, offset, num) { buf.store24swap(offset, num) },
-                          ->(buf, offset) { buf.loadu24swap(offset) }].freeze
     INT32_SWAP = Primitive[:int32_swap, 4, 4,
                           ->(buf, offset, num) { buf.store32swap(offset, num) },
                           ->(buf, offset) { buf.loadi32swap(offset) }].freeze
     UINT32_SWAP = Primitive[:uint32_swap, 4, 4,
                           ->(buf, offset, num) { buf.store32swap(offset, num) },
                           ->(buf, offset) { buf.loadu32swap(offset) }].freeze
-    INT48_SWAP = Primitive[:int48_swap, 6, 2,
-                          ->(buf, offset, num) { buf.store48swap(offset, num) },
-                          ->(buf, offset) { buf.loadi48swap(offset) }].freeze
-    UINT48_SWAP = Primitive[:uint48_swap, 6, 2,
-                          ->(buf, offset, num) { buf.store48swap(offset, num) },
-                          ->(buf, offset) { buf.loadu48swap(offset) }].freeze
     INT64_SWAP = Primitive[:int64_swap, 8, 8,
                           ->(buf, offset, num) { buf.store64swap(offset, num) },
                           ->(buf, offset) { buf.loadi64swap(offset) }].freeze
@@ -238,80 +211,4 @@ module Gogyou
                           ->(buf, offset, num) { buf.storef64swap(offset, num) },
                           ->(buf, offset) { buf.loadf64swap(offset) }].freeze
   end
-
-  class Model
-    TYPEMAP = {
-      size_t:           Primitives::SIZE_T,
-      ssize_t:          Primitives::SSIZE_T,
-      intptr_t:         Primitives::INTPTR_T,
-      uintptr_t:        Primitives::UINTPTR_T,
-      int8_t:           Primitives::INT8_T,
-      uint8_t:          Primitives::UINT8_T,
-      int16_t:          Primitives::INT16_T,
-      uint16_t:         Primitives::UINT16_T,
-      int24_t:          Primitives::INT24_T,
-      uint24_t:         Primitives::UINT24_T,
-      int32_t:          Primitives::INT32_T,
-      uint32_t:         Primitives::UINT32_T,
-      int48_t:          Primitives::INT48_T,
-      uint48_t:         Primitives::UINT48_T,
-      int64_t:          Primitives::INT64_T,
-      uint64_t:         Primitives::UINT64_T,
-      int16_be:         Primitives::INT16_BE,
-      uint16_be:        Primitives::UINT16_BE,
-      int24_be:         Primitives::INT24_BE,
-      uint24_be:        Primitives::UINT24_BE,
-      int32_be:         Primitives::INT32_BE,
-      uint32_be:        Primitives::UINT32_BE,
-      int48_be:         Primitives::INT48_BE,
-      uint48_be:        Primitives::UINT48_BE,
-      int64_be:         Primitives::INT64_BE,
-      uint64_be:        Primitives::UINT64_BE,
-      int16_le:         Primitives::INT16_LE,
-      uint16_le:        Primitives::UINT16_LE,
-      int24_le:         Primitives::INT24_LE,
-      uint24_le:        Primitives::UINT24_LE,
-      int32_le:         Primitives::INT32_LE,
-      uint32_le:        Primitives::UINT32_LE,
-      int48_le:         Primitives::INT48_LE,
-      uint48_le:        Primitives::UINT48_LE,
-      int64_le:         Primitives::INT64_LE,
-      uint64_le:        Primitives::UINT64_LE,
-      int16_swap:       Primitives::INT16_SWAP,
-      uint16_swap:      Primitives::UINT16_SWAP,
-      int24_swap:       Primitives::INT24_SWAP,
-      uint24_swap:      Primitives::UINT24_SWAP,
-      int32_swap:       Primitives::INT32_SWAP,
-      uint32_swap:      Primitives::UINT32_SWAP,
-      int48_swap:       Primitives::INT48_SWAP,
-      uint48_swap:      Primitives::UINT48_SWAP,
-      int64_swap:       Primitives::INT64_SWAP,
-      uint64_swap:      Primitives::UINT64_SWAP,
-      char:             Primitives::CHAR,
-      uchar:            Primitives::UCHAR,
-      short:            Primitives::SHORT,
-      ushort:           Primitives::USHORT,
-      int:              Primitives::INT,
-      uint:             Primitives::UINT,
-      long:             Primitives::LONG,
-      ulong:            Primitives::ULONG,
-      longlong:         Primitives::LONGLONG,
-      ulonglong:        Primitives::ULONGLONG,
-      float:            Primitives::FLOAT,
-      double:           Primitives::DOUBLE,
-      float_be:         Primitives::FLOAT_BE,
-      double_be:        Primitives::DOUBLE_BE,
-      float_le:         Primitives::FLOAT_LE,
-      double_le:        Primitives::DOUBLE_LE,
-      float_swap:       Primitives::FLOAT_SWAP,
-      double_swap:      Primitives::DOUBLE_SWAP,
-    }
-
-    TYPEMAP[:unsigned_char] = TYPEMAP[:uchar]
-    TYPEMAP[:unsigned_short] = TYPEMAP[:ushort]
-    TYPEMAP[:unsigned_int] = TYPEMAP[:uint]
-    TYPEMAP[:unsigned_long] = TYPEMAP[:ulong]
-    TYPEMAP[:unsigned_long_long] = TYPEMAP[:ulonglong]
-    TYPEMAP[:long_long] = TYPEMAP[:longlong]
-  end
 end

data/lib/gogyou/typespec.rb

@@ -1,10 +1,10 @@
 module Gogyou
   module TypeSpec
     SIZEOF_CHAR     = [0].pack("C").bytesize
-    SIZEOF_SHORT    = [0].pack("S").bytesize
-    SIZEOF_INT      = [0].pack("I").bytesize
-    SIZEOF_LONG     = [0].pack("L").bytesize
-    SIZEOF_LONGLONG = [0].pack("Q").bytesize
+    SIZEOF_SHORT    = [0].pack("S!").bytesize
+    SIZEOF_INT      = [0].pack("I!").bytesize
+    SIZEOF_LONG     = [0].pack("L!").bytesize
+    SIZEOF_LONGLONG = [0].pack("Q!").bytesize
     SIZEOF_SIZE_T   = [nil].pack("P").bytesize
     SIZEOF_FLOAT    = [0].pack("F").bytesize
     SIZEOF_DOUBLE   = [0].pack("D").bytesize

data/lib/gogyou/version.rb

@@ -0,0 +1,3 @@
+module Gogyou
+  VERSION = "0.2.3"
+end

data/mkprims.rb

@@ -12,12 +12,8 @@ int8_t    1 1 store8    loadi8
 uint8_t   1 1 store8    loadu8
 int16_t   2 2 store16   loadi16
 uint16_t  2 2 store16   loadu16
-int24_t   3 1 store24   loadi24
-uint24_t  3 1 store24   loadu24
 int32_t   4 4 store32   loadi32
 uint32_t  4 4 store32   loadu32
-int48_t   6 2 store48   loadi48
-uint48_t  6 2 store48   loadu48
 int64_t   8 8 store64   loadi64
 uint64_t  8 8 store64   loadu64
 int16_be  2 2 store16be loadi16be
@@ -42,12 +38,8 @@ int64_le  8 8 store64le loadi64le
 uint64_le 8 8 store64le loadu64le
 int16_swap  2 2 store16swap loadi16swap
 uint16_swap 2 2 store16swap loadu16swap
-int24_swap  3 1 store24swap loadi24swap
-uint24_swap 3 1 store24swap loadu24swap
 int32_swap  4 4 store32swap loadi32swap
 uint32_swap 4 4 store32swap loadu32swap
-int48_swap  6 2 store48swap loadi48swap
-uint48_swap 6 2 store48swap loadu48swap
 int64_swap  8 8 store64swap loadi64swap
 uint64_swap 8 8 store64swap loadu64swap
 char      1 1 store8   loadi8
@@ -96,26 +88,23 @@ module Gogyou
       end
 
       def to_s
-        "\#{self.class}[name=\#{name.inspect}, bytesize=\#{bytesize.inspect}, bytealign=\#{bytealign.inspect}]"
+        "\\\#<\#{self.class}:\#{name} bytesize=\#{bytesize.inspect}, bytealign=\#{bytealign.inspect}>"
       end
 
       alias inspect to_s
 
       def pretty_print(q)
         #name, bytesize, bytealign
-        q.group(1, "\#{self.class}[") do
-          q.text "name="
-          q.pp name
-          q.text ", "
-          #q.breakable
+        q.group(1, "\\\#<\#{self.class}:\#{name}") do
+          q.breakable " "
           q.text "bytesize="
           q.pp bytesize
-          q.text ", "
-          #q.breakable
+          q.text ","
+          q.breakable " "
           q.text "bytealign="
           q.pp bytealign
         end
-        q.text "]"
+        q.text ">"
       end
     end
 
@@ -123,7 +112,7 @@ module Gogyou
 
   records = records.split(/\n/)
   records.map! { |r| r.split(/\s+/) }
-  
+
   records.each do |typename, bytesize, bytealign, aset, aref|
     name = typename.upcase
     f.puts <<-EOS
@@ -135,38 +124,6 @@ module Gogyou
 
   f.puts <<-EOS
   end
-
-  class Model
-    TYPEMAP = {
-  EOS
-
-  records.each do |typename, bytesize, bytealign, aset, aref|
-    sym = typename.to_sym.inspect
-    f.puts <<-EOS % ["#{typename}:".ljust(17, " "), typename.upcase]
-      %s Primitives::%s,
-    EOS
-  end
-
-  f.puts <<-EOS
-    }
-
-  EOS
-
-  [
-    %w(unsigned_char uchar),
-    %w(unsigned_short ushort),
-    %w(unsigned_int uint),
-    %w(unsigned_long ulong),
-    %w(unsigned_long_long ulonglong),
-    %w(long_long longlong),
-  ].each do |link, name|
-    f.puts <<-EOS
-    TYPEMAP[:#{link}] = TYPEMAP[:#{name}]
-    EOS
-  end
-
-  f.puts <<-EOS
-  end
 end
   EOS
 end