libbin 1.0.2 → 1.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a839d4dfb7966a79a1319812d1228919978b7ad98bffa0d99f8375b6d1756318
-  data.tar.gz: dddf34d95677e7eec57f42dab96d278d0af6672d59a44126afa7ace584edbb14
+  metadata.gz: d3a9557a12a5d4ef9ed048592358290c19bebb42cb55d5dacf5d234e62aee6c0
+  data.tar.gz: 319fffa88af207c7613209e632b10e1c16a70bea0b5ddfbf7de6b1f54bb74cbf
 SHA512:
-  metadata.gz: 4aa40ec6641631c60fbc11231a40519a42519f854496f74994a46f95e858e3d49bedf2c95cd88a317d9efd5174c16417562ba05533d2f90f4006fd6c52050663
-  data.tar.gz: 9cdea5cac5feb7f7a5816bbc0670fefc77adb3f8febe9a3b2be7f8c85b95cd51426a8d668688a5b46c9dc45eb7b1d61f2fd6b23ca9fb20df0d5ceaab9126ac66
+  metadata.gz: a07e150714b61ea44cb2a7df3442e6ed7257d4b601bc8e2353e2329fc9eaaddcef56318dac85c2277a1eff3e8f6407919b4f43320e4e9d02506cce2bcea6bf35
+  data.tar.gz: 2d4ef297ce1c616ce464d2b3a667061959965ba8ca63113e699348e6313f3ab8ba15165c3041cc84cded5dc70ba5b5e5f31bcf338221f5a2a4bb725440636fad

data/ext/libbin/libbin_c.c

@@ -11,7 +11,7 @@ static VALUE pghalf_from_string_p(VALUE self, VALUE str, VALUE pack_str) {
 	Check_Type(str, T_STRING);
 	Check_Type(pack_str, T_STRING);
 	VALUE arr = rb_funcall(str, rb_intern("unpack"), 1, pack_str);
-        uint16_t val = NUM2USHORT(rb_funcall(arr, rb_intern("first"), 0));
+	uint16_t val = NUM2USHORT(rb_funcall(arr, rb_intern("first"), 0));
 	union float_u res;
 
 	res.i = pghalf_to_float(val);
@@ -22,7 +22,7 @@ static VALUE half_from_string_p(VALUE self, VALUE str, VALUE pack_str) {
 	Check_Type(str, T_STRING);
 	Check_Type(pack_str, T_STRING);
 	VALUE arr = rb_funcall(str, rb_intern("unpack"), 1, pack_str);
-        uint16_t val = NUM2USHORT(rb_funcall(arr, rb_intern("first"), 0));
+	uint16_t val = NUM2USHORT(rb_funcall(arr, rb_intern("first"), 0));
 	union float_u res;
 
 	res.i = half_to_float(val);
@@ -32,25 +32,25 @@ static VALUE half_from_string_p(VALUE self, VALUE str, VALUE pack_str) {
 static VALUE pghalf_to_string_p(VALUE self, VALUE number, VALUE pack_str) {
 	Check_Type(number, T_FLOAT);
 	union float_u val;
-        uint16_t res;
+	uint16_t res;
 
 	val.f = NUM2DBL(number);
 	res = pghalf_from_float(val.i);
-        VALUE arr = rb_ary_new3(1, UINT2NUM(res) );
+	VALUE arr = rb_ary_new3(1, UINT2NUM(res) );
 
-        return rb_funcall(arr, rb_intern("pack"), 1, pack_str);
+	return rb_funcall(arr, rb_intern("pack"), 1, pack_str);
 }
 
 static VALUE half_to_string_p(VALUE self, VALUE number, VALUE pack_str) {
 	Check_Type(number, T_FLOAT);
 	union float_u val;
-        uint16_t res;
+	uint16_t res;
 
 	val.f = NUM2DBL(number);
 	res = half_from_float(val.i);
-        VALUE arr = rb_ary_new3(1, UINT2NUM(res) );
+	VALUE arr = rb_ary_new3(1, UINT2NUM(res) );
 
-        return rb_funcall(arr, rb_intern("pack"), 1, pack_str);
+	return rb_funcall(arr, rb_intern("pack"), 1, pack_str);
 }
 
 void Init_libbin_c() {

data/ext/libbin/pghalf.c

@@ -339,22 +339,22 @@ uint16_t
 pghalf_from_float( uint32_t f )
 {
   const uint32_t one                        = _uint32_li( 0x00000001 );
-  const uint32_t f_s_mask                   = _uint32_li( 0x80000000 );
-  const uint32_t f_e_mask                   = _uint32_li( 0x7f800000 );
-  const uint32_t f_m_mask                   = _uint32_li( 0x007fffff );
-  const uint32_t f_m_hidden_bit             = _uint32_li( 0x00800000 );
-  const uint32_t f_m_round_bit              = _uint32_li( 0x00001000 );
-  const uint32_t f_snan_mask                = _uint32_li( 0x7fc00000 );
-  const uint32_t f_e_pos                    = _uint32_li( 0x00000017 );
-  const uint32_t h_e_pos                    = _uint32_li( 0x00000009 );
-  const uint32_t h_e_mask                   = _uint32_li( 0x00007e00 );
-  const uint32_t h_snan_mask                = _uint32_li( 0x00007f00 );
-  const uint32_t h_e_mask_value             = _uint32_li( 0x0000003f );
-  const uint32_t f_h_s_pos_offset           = _uint32_li( 0x00000010 );
-  const uint32_t f_h_bias_offset            = _uint32_li( 0x00000050 );
-  const uint32_t f_h_m_pos_offset           = _uint32_li( 0x0000000e );
-  const uint32_t h_nan_min                  = _uint32_li( 0x00007e01 );
-  const uint32_t f_h_e_biased_flag          = _uint32_li( 0x000000af );
+  const uint32_t f_s_mask                   = _uint32_li( 0x80000000 ); //bit 31
+  const uint32_t f_e_mask                   = _uint32_li( 0x7f800000 ); //bits 30-23
+  const uint32_t f_m_mask                   = _uint32_li( 0x007fffff ); //bits 22-0
+  const uint32_t f_m_hidden_bit             = _uint32_li( 0x00800000 ); //1<<f_e_pos
+  const uint32_t f_m_round_bit              = _uint32_li( 0x00002000 ); //1<<(f_e_pos - h_e_pos - 1)
+  const uint32_t f_snan_mask                = _uint32_li( 0x7fc00000 ); //f_e_mask + 1 << (f_e_pos - 1)
+  const uint32_t f_e_pos                    = _uint32_li( 0x00000017 ); //23
+  const uint32_t h_e_pos                    = _uint32_li( 0x00000009 ); //9
+  const uint32_t h_e_mask                   = _uint32_li( 0x00007e00 ); //bits 14-9
+  const uint32_t h_snan_mask                = _uint32_li( 0x00007f00 ); //h_e_mask + 1 << (h_e_pos - 1)
+  const uint32_t h_e_mask_value             = _uint32_li( 0x0000003f ); //h_e_mask >> 9
+  const uint32_t f_h_s_pos_offset           = _uint32_li( 0x00000010 ); //f_s_pos - h_s_pos
+  const uint32_t f_h_bias_offset            = _uint32_li( 0x00000050 ); //f_bias - h_bias
+  const uint32_t f_h_m_pos_offset           = _uint32_li( 0x0000000e ); //f_e_pos - h_e_pos
+  const uint32_t h_nan_min                  = _uint32_li( 0x00007e01 ); //h_e_mask + 1
+  const uint32_t f_h_e_biased_flag          = _uint32_li( 0x000000af ); //f_bias + h_bias + 1
   const uint32_t f_s                        = _uint32_and( f,               f_s_mask         );
   const uint32_t f_e                        = _uint32_and( f,               f_e_mask         );
   const uint16_t h_s                        = _uint32_srl( f_s,             f_h_s_pos_offset );
@@ -403,18 +403,18 @@ pghalf_from_float( uint32_t f )
 uint32_t 
 pghalf_to_float( uint16_t h )
 {
-  const uint32_t h_e_mask              = _uint32_li( 0x00007e00 );
-  const uint32_t h_m_mask              = _uint32_li( 0x000001ff );
-  const uint32_t h_s_mask              = _uint32_li( 0x00008000 );
-  const uint32_t h_f_s_pos_offset      = _uint32_li( 0x00000010 );
-  const uint32_t h_f_e_pos_offset      = _uint32_li( 0x0000000e );
-  const uint32_t h_f_bias_offset       = _uint32_li( 0x0000a000 );
-  const uint32_t f_e_mask              = _uint32_li( 0x7f800000 );
-  const uint32_t f_m_mask              = _uint32_li( 0x007fffff );
-  const uint32_t h_f_e_denorm_bias     = _uint32_li( 0x0000005f );
-  const uint32_t h_f_m_denorm_sa_bias  = _uint32_li( 0x00000008 );
-  const uint32_t f_e_pos               = _uint32_li( 0x00000017 );
-  const uint32_t h_e_mask_minus_one    = _uint32_li( 0x00007dff );
+  const uint32_t h_e_mask              = _uint32_li( 0x00007e00 ); //bits 14-9
+  const uint32_t h_m_mask              = _uint32_li( 0x000001ff ); //bits 8-0
+  const uint32_t h_s_mask              = _uint32_li( 0x00008000 ); //bit 15
+  const uint32_t h_f_s_pos_offset      = _uint32_li( 0x00000010 ); //f_s_pos - h_s_pos
+  const uint32_t h_f_e_pos_offset      = _uint32_li( 0x0000000e ); //f_m_bitcount - h_m_bitcount
+  const uint32_t h_f_bias_offset       = _uint32_li( 0x0000a000 ); //(f_bias - h_bias) << 9
+  const uint32_t f_e_mask              = _uint32_li( 0x7f800000 ); //bits 30-23
+  const uint32_t f_m_mask              = _uint32_li( 0x007fffff ); //bits 22-0
+  const uint32_t h_f_e_denorm_bias     = _uint32_li( 0x0000005f ); //h_f_e_pos_offset + 1 + (f_bias - h_bias)
+  const uint32_t h_f_m_denorm_sa_bias  = _uint32_li( 0x00000008 ); //float exp bit count
+  const uint32_t f_e_pos               = _uint32_li( 0x00000017 ); //23
+  const uint32_t h_e_mask_minus_one    = _uint32_li( 0x00007dff ); //h_e_mask + h_m_mask - 1<<h_e_pos
   const uint32_t h_e                   = _uint32_and( h, h_e_mask );
   const uint32_t h_m                   = _uint32_and( h, h_m_mask );
   const uint32_t h_s                   = _uint32_and( h, h_s_mask );

data/lib/libbin/data_types.rb

@@ -70,14 +70,52 @@ module LibBin
 
   end
 
+  class Field
+    attr_reader :name,
+                :type,
+                :length,
+                :count,
+                :offset,
+                :sequence,
+                :condition
+
+    def sequence?
+      @sequence
+    end
+
+    def relative_offset?
+      @relative_offset
+    end
+
+    def initialize(name, type, length, count, offset, sequence, condition, relative_offset)
+      @name = name
+      @type = type
+      @length = length
+      @count = count
+      @offset = offset
+      @sequence = sequence
+      @condition = condition
+      @relative_offset = relative_offset
+    end
+
+  end
+
   class DataConverter
 
-    rl = lambda { |type, str|
-      str.unpack(type.to_s).first
+    rl = lambda { |type, str, number = nil|
+      if number
+        str.unpack(type.to_s+number.to_s)
+      else
+        str.unpack(type.to_s).first
+      end
     }
 
-    sl = lambda { |type, value|
-      [value].pack(type.to_s)
+    sl = lambda { |type, value, number = nil|
+      if number
+        value.pack(type.to_s+number.to_s)
+      else
+        [value].pack(type.to_s)
+      end
     }
 
     l = lambda { |type|
@@ -161,6 +199,7 @@ module LibBin
       :D => 8,
       :E => 8,
       :G => 8,
+      :a => 1,
       :"a*" => -1,
       :half => 2,
       :half_le => 2,
@@ -186,6 +225,50 @@ module LibBin
       }
     }
 
+    rhl = lambda { |type, str, number = nil|
+      if number
+        number.times.collect { |i| LibBin::half_from_string(str[i*2,2], type) }
+      else
+        LibBin::half_from_string(str, type)
+      end
+    }
+
+    shl = lambda { |type, value, number = nil|
+      if number
+        str = ""
+        number.times { |i| str << LibBin::half_to_string(value[i], type) }
+        str
+      else
+        LibBin::half_to_string(value, type)
+      end
+    }
+
+    hl = lambda { |type|
+      [rhl.curry[type], shl.curry[type]]
+    }
+
+    rpghl = lambda { |type, str, number = nil|
+      if number
+        number.times.collect { |i| LibBin::pghalf_from_string(str[i*2,2], type) }
+      else
+        LibBin::pghalf_from_string(str, type)
+      end
+    }
+
+    spghl = lambda { |type, value, number = nil|
+      if number
+        str = ""
+        number.times { |i| str << LibBin::pghalf_to_string(value[i], type) }
+        str
+      else
+        LibBin::pghalf_to_string(value, type)
+      end
+    }
+
+    pghl = lambda { |type|
+      [rpghl.curry[type], spghl.curry[type]]
+    }
+
     DATA_ENDIAN[true].merge!( {
       :c => l["c"],
       :C => l["C"],
@@ -217,19 +300,12 @@ module LibBin
       :D => l["G"],
       :E => l["E"],
       :G => l["G"],
-      :"a*" => l["a*"],
-      :half => [ lambda { |str| LibBin::half_from_string(str, "S>") },
-                 lambda { |v| LibBin::half_to_string(v, "S>") } ],
-      :half_le => [ lambda { |str| LibBin::half_from_string(str, "S<") },
-                    lambda { |v| LibBin::half_to_string(v, "S<") } ],
-      :half_be => [ lambda { |str| LibBin::half_from_string(str, "S>") },
-                    lambda { |v| LibBin::half_to_string(v, "S>") } ],
-      :pghalf => [ lambda { |str| LibBin::pghalf_from_string(str, "S>") },
-                   lambda { |v| LibBin::pghalf_to_string(v, "S>") } ],
-      :pghalf_le => [ lambda { |str| LibBin::pghalf_from_string(str, "S<") },
-                      lambda { |v| LibBin::pghalf_to_string(v, "S<") } ],
-      :pghalf_be => [ lambda { |str| LibBin::pghalf_from_string(str, "S>") },
-                      lambda { |v| LibBin::pghalf_to_string(v, "S>") } ]
+      :half => hl["S>"],
+      :half_le => hl["S<"],
+      :half_be => hl["S>"],
+      :pghalf => pghl["S>"],
+      :pghalf_le => pghl["S<"],
+      :pghalf_be => pghl["S>"]
     } )
     DATA_ENDIAN[false].merge!( {
       :c => l["c"],
@@ -262,19 +338,12 @@ module LibBin
       :D => l["E"],
       :E => l["E"],
       :G => l["G"],
-      :"a*" => l["a*"],
-      :half => [ lambda { |str| LibBin::half_from_string(str, "S<") },
-                 lambda { |v| LibBin::half_to_string(v, "S<") } ],
-      :half_le => [ lambda { |str| LibBin::half_from_string(str, "S<") },
-                    lambda { |v| LibBin::half_to_string(v, "S<") } ],
-      :half_be => [ lambda { |str| LibBin::half_from_string(str, "S>") },
-                    lambda { |v| LibBin::half_to_string(v, "S>") } ],
-      :pghalf => [ lambda { |str| LibBin::pghalf_from_string(str, "S<") },
-                   lambda { |v| LibBin::pghalf_to_string(v, "S<") } ],
-      :pghalf_le => [ lambda { |str| LibBin::pghalf_from_string(str, "S<") },
-                      lambda { |v| LibBin::pghalf_to_string(v, "S<") } ],
-      :pghalf_be => [ lambda { |str| LibBin::pghalf_from_string(str, "S>") },
-                      lambda { |v| LibBin::pghalf_to_string(v, "S>") } ]
+      :half => hl["S<"],
+      :half_le => hl["S<"],
+      :half_be => hl["S>"],
+      :pghalf => pghl["S<"],
+      :pghalf_le => pghl["S<"],
+      :pghalf_be => pghl["S>"]
     } )
 
 
@@ -284,8 +353,9 @@ module LibBin
         @size
       end
 
-      def self.shape(value, previous_offset = 0, _ = nil, _ = nil, kind = DataShape)
-        kind::new(previous_offset, previous_offset + @size - 1)
+      def self.shape(value, previous_offset = 0, _ = nil, _ = nil, kind = DataShape, length = nil)
+        length = 1 unless length
+        kind::new(previous_offset, previous_offset - 1 + length * @size)
       end
 
       def self.init(symbol)
@@ -295,20 +365,22 @@ module LibBin
         @rl_le, @sl_le = DATA_ENDIAN[false][symbol]
       end
 
-      def self.load(input, input_big = LibBin::default_big?, _ = nil, _ = nil)
-        str = input.read(@size)
-        input_big ? @rl_be[str] : @rl_le[str]
+      def self.load(input, input_big = LibBin::default_big?, _ = nil, _ = nil, length = nil)
+        l = (length ? length : 1)
+        str = input.read(@size*l)
+        input_big ? @rl_be[str, length] : @rl_le[str, length]
       end
 
-      def self.dump(value, output, output_big = LibBin::default_big?, _ = nil, _ = nil)
-        str = (output_big ? @sl_be[value] : @sl_le[value])
+      def self.dump(value, output, output_big = LibBin::default_big?, _ = nil, _ = nil, length = nil)
+        str = (output_big ? @sl_be[value, length] : @sl_le[value, length])
         output.write(str)
       end
 
-      def self.convert(input, output, input_big = LibBin::default_big?, output_big = !input_big, _ = nil, _ = nil)
-        str = input.read(@size)
-        value = (input_big ? @rl_be[str] : @rl_le[str])
-        str = (output_big ? @sl_be[value] : @sl_le[value])
+      def self.convert(input, output, input_big = LibBin::default_big?, output_big = !input_big, _ = nil, _ = nil, length = nil)
+        l = (length ? length : 1)
+        str = input.read(@size*l)
+        value = (input_big ? @rl_be[str, length] : @rl_le[str, length])
+        str = (output_big ? @sl_be[value, length] : @sl_le[value, length])
         output.write(str)
         value
       end
@@ -317,40 +389,48 @@ module LibBin
 
     class Str < Scalar
 
-      def self.load(input,  input_big = LibBin::default_big?, _ = nil, _ = nil)
-        str = (@size < 0 ? input.readline("\x00") : input.read(@size))
-        input_big ? @rl_be[str] : @rl_le[str]
+      def self.size(value, previous_offset = 0, parent = nil, index = nil, length = nil)
+        length ? length : value.size
+      end
+
+      def self.load(input,  input_big = LibBin::default_big?, _ = nil, _ = nil, length = nil)
+        str = (length ? input.read(length) : input.readline("\x00"))
       end
 
-      def self.convert(input, output, input_big = LibBin::default_big?, output_big = !LibBin::default_big, _ = nil, _ = nil)
-        str = (@size < 0 ? input.readline("\x00") : input.read(@size))
-        value = (input_big ? @rl_be[str] : @rl_le[str])
-        str = (output_big ? @sl_be[value] : @sl_le[value])
+      def self.convert(input, output, input_big = LibBin::default_big?, output_big = !LibBin::default_big, _ = nil, _ = nil, length = nil)
+        str = (length ? input.read(length) : input.readline("\x00"))
         output.write(str)
-        value
+        str
       end
 
-      def self.shape(value, previous_offset = 0, _ = nil, _ = nil, kind = DataShape)
-        if @size < 0
-          kind::new(previous_offset, previous_offset + value.size - 1)
+      def self.shape(value, previous_offset = 0, _ = nil, _ = nil, kind = DataShape, length = nil)
+        if length
+          kind::new(previous_offset, previous_offset + length - 1)
         else
-          kind::new(previous_offset, previous_offset + @size - 1)
+          kind::new(previous_offset, previous_offset + value.size - 1)
         end
       end
 
+      def self.dump(value, output, output_big = LibBin::default_big?, _ = nil, _ = nil, length = nil)
+        if length
+          output.write([value].pack("Z#{length}"))
+        else
+          output.write(value)
+        end
+      end
     end
 
-    def self.register_field(field, type, count: nil, offset: nil, sequence: false, condition: nil)
+    def self.register_field(field, type, length: nil, count: nil, offset: nil, sequence: false, condition: nil, relative_offset: false)
       if type.kind_of?(Symbol)
         if type[0] == 'a'
-          c = Class::new(Str) do init(sym) end
-          @fields.push([field, c, count, offset, sequence, condition])
+          real_type = Class::new(Str) do init(sym) end
         else
-          @fields.push([field, const_get(SCALAR_TYPES[type][0]), count, offset, sequence, condition])
+          real_type = const_get(SCALAR_TYPES[type][0])
         end
       else
-        @fields.push([field, type, count, offset, sequence, condition])
+        real_type = type
       end
+      @fields.push(Field::new(field, real_type, length, count, offset, sequence, condition, relative_offset))
       attr_accessor field
     end
 
@@ -361,8 +441,8 @@ module LibBin
       init(#{symbol.inspect})
     end
 
-    def self.#{name}(field, count: nil, offset: nil, sequence: false, condition: nil)
-      @fields.push([field, #{klassname}, count, offset, sequence, condition])
+    def self.#{name}(field, length: nil, count: nil, offset: nil, sequence: false, condition: nil, relative_offset: false)
+      @fields.push(Field::new(field, #{klassname}, length, count, offset, sequence, condition, relative_offset))
       attr_accessor field
     end
 EOF
@@ -401,16 +481,15 @@ EOF
     create_scalar_type(:pghalf_le)
     create_scalar_type(:pghalf_be)
 
-    def self.string( field, length = nil, count: nil, offset: nil, sequence: false, condition: nil)
-      sym = (length ? :"a#{length}" : :"a*")
+    def self.string( field, length = nil, count: nil, offset: nil, sequence: false, condition: nil, relative_offset: false)
+      sym = (length ? :"a" : :"a*")
       c = Class::new(Str) do
         init(sym)
       end
-      @fields.push([field, c, count, offset, sequence, condition])
+      @fields.push(Field::new(field, c, length, count, offset, sequence, condition, relative_offset))
       attr_accessor field
     end
 
-
   end
 
 end

data/lib/libbin.rb

@@ -117,10 +117,11 @@ module LibBin
       end
     end
 
-    def __decode_seek_offset(offset)
+    def __decode_seek_offset(offset, relative_offset)
       return nil unless offset
       offset = __decode_expression(offset)
       return false if offset == 0x0
+      offset += @__position if relative_offset
       @__cur_position = offset
       @__input.seek(offset) if @__input
       @__output.seek(offset) if @__output
@@ -141,97 +142,106 @@ module LibBin
       return __decode_expression(type)
     end
 
-    def __decode_static_conditions(type, count, offset, sequence, condition)
+    def __decode_length(length)
+      __decode_expression(length)
+    end
+
+    def __decode_static_conditions(field)
       @__offset = nil
       @__condition = nil
       @__type = nil
+      @__length = nil
       @__count = nil
-      unless sequence
-        @__offset = __decode_seek_offset(offset)
+      unless field.sequence?
+        @__offset = __decode_seek_offset(field.offset, field.relative_offset?)
         throw :ignored, nil if @__offset == false
-        @__condition = __decode_condition(condition)
+        @__condition = __decode_condition(field.condition)
         throw :ignored, nil unless @__condition
-        @__type = __decode_type(type)
+        @__type = __decode_type(field.type)
+        @__length = __decode_length(field.length)
       end
-      @__count = __decode_count(count)
+      @__count = __decode_count(field.count)
     end
 
-    def __decode_dynamic_conditions(type, offset, sequence, condition)
-      return true unless sequence
+    def __decode_dynamic_conditions(field)
+      return true unless field.sequence?
       @__offset = nil
       @__condition = nil
       @__type = nil
-      @__offset = __decode_seek_offset(offset)
+      @__length = nil
+      @__offset = __decode_seek_offset(field.offset, field.relative_offset?)
       return false if @__offset == false
-      @__condition = __decode_condition(condition)
+      @__condition = __decode_condition(field.condition)
       return false unless @__condition
-      @__type = __decode_type(type)
+      @__type = __decode_type(field.type)
+      @__length = __decode_length(field.length)
       return true
     end
 
     def __restore_context
       @__iterator = nil
       @__type = nil
+      @__length = nil
       @__count = nil
       @__offset = nil
       @__condition = nil
     end
 
-    def __convert_field(field, type, count, offset, sequence, condition)
-      __decode_static_conditions(type, count, offset, sequence, condition)
+    def __convert_field(field)
+      __decode_static_conditions(field)
       vs = @__count.times.collect do |it|
         @__iterator = it
-        if __decode_dynamic_conditions(type, offset, sequence, condition)
-          @__type::convert(@__input, @__output, @__input_big, @__output_big, self, it)
+        if __decode_dynamic_conditions(field)
+          @__type::convert(@__input, @__output, @__input_big, @__output_big, self, it, @__length)
         else
           nil
         end
       end
       __restore_context
-      vs = vs.first unless count
+      vs = vs.first unless field.count
       vs
     end
 
-    def __load_field(field, type, count, offset, sequence, condition)
-      __decode_static_conditions(type, count, offset, sequence, condition)
+    def __load_field(field)
+      __decode_static_conditions(field)
       vs = @__count.times.collect do |it|
         @__iterator = it
-        if __decode_dynamic_conditions(type, offset, sequence, condition)
-          @__type::load(@__input, @__input_big, self, it)
+        if __decode_dynamic_conditions(field)
+          @__type::load(@__input, @__input_big, self, it, @__length)
         else
           nil
         end
       end
       __restore_context
-      vs = vs.first unless count
+      vs = vs.first unless field.count
       vs
     end
 
-    def __dump_field(vs, field, type, count, offset, sequence, condition)
-      __decode_static_conditions(type, count, offset, sequence, condition)
-      vs = [vs] unless count
+    def __dump_field(vs, field)
+      __decode_static_conditions(field)
+      vs = [vs] unless field.count
       vs.each_with_index do |v, it|
         @__iterator = it
-        if __decode_dynamic_conditions(type, offset, sequence, condition)
-          @__type::dump(v, @__output, @__output_big, self, it)
+        if __decode_dynamic_conditions(field)
+          @__type::dump(v, @__output, @__output_big, self, it, @__length)
         end
       end
       __restore_context
     end
 
-    def __shape_field(vs, previous_offset, kind, field, type, count, offset, sequence, condition)
-      __decode_static_conditions(type, count, offset, sequence, condition)
-      vs = [vs] unless count
+    def __shape_field(vs, previous_offset, kind, field)
+      __decode_static_conditions(field)
+      vs = [vs] unless field.count
       vs = vs.each_with_index.collect do |v, it|
         @__iterator = it
-        if __decode_dynamic_conditions(type, offset, sequence, condition)
-          sh = @__type::shape(v, @__cur_position, self, it, kind)
+        if __decode_dynamic_conditions(field)
+          sh = @__type::shape(v, @__cur_position, self, it, kind, @__length)
           @__cur_position = sh.last + 1 if sh.last && sh.last >= 0
           sh
         end
       end
       __restore_context
-      vs = vs.first unless count
+      vs = vs.first unless field.count
       vs
     end
 
@@ -242,15 +252,15 @@ module LibBin
     def __shape(previous_offset = 0, parent = nil, index = nil, kind = DataShape)
       __set_size_type(previous_offset, parent, index)
       members = {}
-      self.class.instance_variable_get(:@fields).each { |name, type, *args|
+      self.class.instance_variable_get(:@fields).each { |field|
         begin
-          vs = send(name)
+          vs = send(field.name)
           member = catch(:ignored) do
-            __shape_field(vs, previous_offset, kind, name, type, *args)
+            __shape_field(vs, previous_offset, kind, field)
           end
-          members[name] = member
+          members[field.name] = member
         rescue
-          STDERR.puts "#{self.class}: #{name}(#{type})"
+          STDERR.puts "#{self.class}: #{field.name}(#{field.type})"
           raise
         end
       }
@@ -260,14 +270,14 @@ module LibBin
     end
 
     def __convert_fields
-      self.class.instance_variable_get(:@fields).each { |name, type, *args|
+      self.class.instance_variable_get(:@fields).each { |field|
         begin
           vs = catch(:ignored) do
-            __convert_field(name, type, *args)
+            __convert_field(field)
           end
-          send("#{name}=", vs)
+          send("#{field.name}=", vs)
         rescue
-          STDERR.puts "#{self.class}: #{name}(#{type})"
+          STDERR.puts "#{self.class}: #{field.name}(#{field.type})"
           raise
         end
       }
@@ -275,14 +285,14 @@ module LibBin
     end
 
     def __load_fields
-      self.class.instance_variable_get(:@fields).each { |name, type, *args|
+      self.class.instance_variable_get(:@fields).each { |field|
         begin
           vs = catch(:ignored) do
-            __load_field(name, type, *args)
+            __load_field(field)
           end
-          send("#{name}=", vs)
+          send("#{field.name}=", vs)
         rescue
-          STDERR.puts "#{self.class}: #{name}(#{type})"
+          STDERR.puts "#{self.class}: #{field.name}(#{field.type})"
           raise
         end
       }
@@ -290,14 +300,14 @@ module LibBin
     end
 
     def __dump_fields
-      self.class.instance_variable_get(:@fields).each { |name, type, *args|
+      self.class.instance_variable_get(:@fields).each { |field|
         begin
-          vs = send(name)
+          vs = send(field.name)
           catch(:ignored) do
-            __dump_field(vs, name, type, *args)
+            __dump_field(vs, field)
           end
         rescue
-          STDERR.puts "#{self.class}: #{name}(#{type})"
+          STDERR.puts "#{self.class}: #{field.name}(#{field.type})"
           raise
         end
       }
@@ -325,28 +335,57 @@ module LibBin
       self
     end
       
-    def self.convert(input, output, input_big = LibBin::default_big?, output_big = !LibBin::default_big?, parent = nil, index = nil)
-      h = self::new
-      h.__convert(input, output, input_big, output_big, parent, index)
-      h
+    def self.convert(input, output, input_big = LibBin::default_big?, output_big = !LibBin::default_big?, parent = nil, index = nil, length = nil)
+      if length
+        length.times.collect {
+          h = self::new
+          h.__load(input, input_big, parent, index)
+        }
+      else
+        h = self::new
+        h.__convert(input, output, input_big, output_big, parent, index)
+      end
     end
 
-    def self.load(input, input_big = LibBin::default_big?, parent = nil, index = nil)
-      h = self::new
-      h.__load(input, input_big, parent, index)
-      h
+    def self.load(input, input_big = LibBin::default_big?, parent = nil, index = nil, length = nil)
+      if length
+        length.times.collect {
+          h = self::new
+          h.__load(input, input_big, parent, index)
+        }
+      else
+        h = self::new
+        h.__load(input, input_big, parent, index)
+      end
     end
 
-    def self.dump(value, output, output_big = LibBin::default_big?, parent = nil, index = nil)
-      value.__dump(output, output_big, parent, index)
+    def self.dump(value, output, output_big = LibBin::default_big?, parent = nil, index = nil, length = nil)
+      if length
+        length.times.collect { |i|
+          value[i].__dump(output, output_big, parent, index)
+        }
+        value
+      else
+        value.__dump(output, output_big, parent, index)
+      end
     end
 
-    def self.size(value, previous_offset = 0, parent = nil, index = nil)
-      value.__shape(previous_offset, parent, index).size
+    def self.size(value, previous_offset = 0, parent = nil, index = nil, length = nil)
+      if length
+        shape(value, previous_offset, parent, index, length).size
+      else
+        value.__shape(previous_offset, parent, index).size
+      end
     end
 
-    def self.shape(value, previous_offset = 0, parent = nil, index = nil, kind = DataShape)
-      value.__shape(previous_offset, parent, index, kind = DataShape)
+    def self.shape(value, previous_offset = 0, parent = nil, index = nil, kind = DataShape, length = nil)
+      if length
+        kind::new(length.times.collect { |i|
+          value[i].__shape(previous_offset, parent, index, kind)
+        })
+      else
+        value.__shape(previous_offset, parent, index, kind)
+      end
     end
 
   end

data/libbin.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'libbin'
-  s.version = "1.0.2"
+  s.version = "1.0.6"
   s.author = "Brice Videau"
   s.email = "brice.videau@imag.fr"
   s.homepage = "https://github.com/kerilk/libbin"
@@ -8,7 +8,6 @@ Gem::Specification.new do |s|
   s.description = "Read, write and convert Binary data in Ruby."
   s.files =  Dir[ 'libbin.gemspec', 'LICENSE', 'lib/**/*.rb', 'ext/libbin/extconf.rb', 'ext/libbin/*.c', 'ext/libbin/*.h' ]
   s.extensions << 'ext/libbin/extconf.rb'
-  s.has_rdoc = false
   s.license = 'BSD-2-Clause'
   s.required_ruby_version = '>= 2.0.0'
   s.add_dependency 'float-formats', '~> 0.3', '>=0.3.0'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: libbin
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.6
 platform: ruby
 authors:
 - Brice Videau
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-02-04 00:00:00.000000000 Z
+date: 2021-10-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: float-formats
@@ -67,8 +67,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Library for loading and converting binary files