libbin 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c632bd10fef318615e63edccbebd3b161ce7c9e3ccb5a2efec3b43bda3565cde
+  data.tar.gz: cd8853a5ca548a3221710d6388ecbd54f46cf9e3721410af7a1f581d115c738d
+SHA512:
+  metadata.gz: bf807641924427087c89d3f3d89fc91c41a91cf2a6729bba0185592752d071fca322c3655b90912c288c7b3ce98a1a46db6d5471e5e4fd403f7a8570980547e9
+  data.tar.gz: acd847eb8f52ff55c7c1c92fe86fa6bf11cd20845189f6cd13957333b32feeda29bc620d9e8152d835aba2ba9ff45313357f7f75d54a7de126eb7c3d781ab9e9

data/LICENSE

@@ -0,0 +1,25 @@
+BSD 2-Clause License
+
+Copyright (c) 2018, Brice Videau
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/lib/libbin.rb

@@ -0,0 +1,358 @@
+warn_level = $VERBOSE
+$VERBOSE = nil
+require 'float-formats'
+$VERBOSE = warn_level
+
+Flt::IEEE.binary :IEEE_binary16_pg, significand: 9, exponent: 6, bias: 47
+Flt::IEEE.binary :IEEE_binary16_pg_BE, significand: 9, exponent: 6, bias: 47, endianness: :big_endian
+
+require_relative 'libbin/alignment'
+require_relative 'libbin/data_types'
+
+module LibBin
+
+  @__big_architecture = [0x12345678].pack("i") == "\x12\x34\x56\x78"
+  @__big = nil
+
+  def self.default_big?
+    if @__big.nil?
+      @__big_architecture
+    else
+      @__big
+    end
+  end
+
+  class DataConverter
+    include Alignment
+
+    def inspect
+      to_s
+    end
+
+    attr_reader :__parent
+    attr_reader :__index
+    attr_reader :__iterator
+    attr_reader :__position
+    def __set_convert_type(input, output, input_big, output_big, parent, index)
+      @__input_big = input_big
+      @__output_big = output_big
+      @__input = input
+      @__output = output
+      @__parent = parent
+      @__index = index
+      @__position = input.tell
+      @__cur_position = @__position
+    end
+
+    def __set_size_type(position, parent, index)
+      @__parent = parent
+      @__index = index
+      @__position = position
+      @__cur_position = @__position
+    end
+
+    def __set_load_type(input, input_big, parent, index)
+      @__input_big = input_big
+      @__input = input
+      @__parent = parent
+      @__index = index
+      @__position = input.tell
+      @__cur_position = @__position
+    end
+
+    def __set_dump_type(output, output_big, parent, index)
+      @__output_big = output_big
+      @__output = output
+      @__parent = parent
+      @__index = index
+      @__position = output.tell
+      @__cur_position = @__position
+    end
+
+    def __unset_convert_type
+      @__input_big = nil
+      @__output_big = nil
+      @__input = nil
+      @__output = nil
+      @__parent = nil
+      @__index = nil
+      @__position = nil
+      @__cur_position = nil
+    end
+
+    def __unset_size_type
+      @__parent = nil
+      @__index = nil
+      @__position = nil
+      @__cur_position = nil
+    end
+
+    def __unset_load_type
+      @__input_big = nil
+      @__input = nil
+      @__parent = nil
+      @__index = nil
+      @__position = nil
+      @__cur_position = nil
+    end
+
+    def __unset_dump_type
+      @__output_big = nil
+      @__output = nil
+      @__parent = nil
+      @__index = nil
+      @__position = nil
+      @__cur_position = nil
+    end
+
+    def self.inherited(subclass)
+      subclass.instance_variable_set(:@fields, [])
+    end
+
+    def __decode_expression(sym)
+      case sym
+      when Proc
+        return sym.call
+      when String
+        exp = sym.gsub("..","__parent").gsub("\\",".")
+        return eval(exp)
+      else
+        return sym
+      end
+    end
+
+    def __decode_seek_offset(offset)
+      return nil unless offset
+      offset = __decode_expression(offset)
+      return false if offset == 0x0
+      @__cur_position = offset
+      @__input.seek(offset) if @__input
+      @__output.seek(offset) if @__output
+      offset
+    end
+
+    def __decode_condition(condition)
+      return true unless condition
+      __decode_expression(condition)
+    end
+
+    def __decode_count(count)
+      return 1 unless count
+      __decode_expression(count)
+    end
+
+    def __decode_type(type)
+      return __decode_expression(type)
+    end
+
+    def __decode_static_conditions(type, count, offset, sequence, condition)
+      @__offset = nil
+      @__condition = nil
+      @__type = nil
+      @__count = nil
+      unless sequence
+        @__offset = __decode_seek_offset(offset)
+        throw :ignored, nil if @__offset == false
+        @__condition = __decode_condition(condition)
+        throw :ignored, nil unless @__condition
+        @__type = __decode_type(type)
+      end
+      @__count = __decode_count(count)
+    end
+
+    def __decode_dynamic_conditions(type, offset, sequence, condition)
+      return true unless sequence
+      @__offset = nil
+      @__condition = nil
+      @__type = nil
+      @__offset = __decode_seek_offset(offset)
+      return false if @__offset == false
+      @__condition = __decode_condition(condition)
+      return false unless @__condition
+      @__type = __decode_type(type)
+      return true
+    end
+
+    def __restore_context
+      @__iterator = nil
+      @__type = 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)
+      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)
+        else
+          nil
+        end
+      end
+      __restore_context
+      vs = vs.first unless count
+      vs
+    end
+
+    def __load_field(field, type, count, offset, sequence, condition)
+      __decode_static_conditions(type, count, offset, sequence, condition)
+      vs = @__count.times.collect do |it|
+        @__iterator = it
+        if __decode_dynamic_conditions(type, offset, sequence, condition)
+          @__type::load(@__input, @__input_big, self, it)
+        else
+          nil
+        end
+      end
+      __restore_context
+      vs = vs.first unless 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
+      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)
+        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
+      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)
+          @__cur_position = sh.last + 1 if sh.last && sh.last >= 0
+          sh
+        end
+      end
+      __restore_context
+      vs = vs.first unless count
+      vs
+    end
+
+    def __size(previous_offset = 0, parent = nil, index = nil)
+      __shape(previous_offset, parent, index, DataRange).size
+    end
+
+    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|
+        begin
+          vs = send(name)
+          member = catch(:ignored) do
+            __shape_field(vs, previous_offset, kind, name, type, *args)
+          end
+          members[name] = member
+        rescue
+          STDERR.puts "#{self.class}: #{name}(#{type})"
+          raise
+        end
+      }
+      __unset_size_type
+      return nil if members.values.flatten.compact.size <= 0
+      kind::new(members)
+    end
+
+    def __convert_fields
+      self.class.instance_variable_get(:@fields).each { |name, type, *args|
+        begin
+          vs = catch(:ignored) do
+            __convert_field(name, type, *args)
+          end
+          send("#{name}=", vs)
+        rescue
+          STDERR.puts "#{self.class}: #{name}(#{type})"
+          raise
+        end
+      }
+      self
+    end
+
+    def __load_fields
+      self.class.instance_variable_get(:@fields).each { |name, type, *args|
+        begin
+          vs = catch(:ignored) do
+            __load_field(name, type, *args)
+          end
+          send("#{name}=", vs)
+        rescue
+          STDERR.puts "#{self.class}: #{name}(#{type})"
+          raise
+        end
+      }
+      self
+    end
+
+    def __dump_fields
+      self.class.instance_variable_get(:@fields).each { |name, type, *args|
+        begin
+          vs = send(name)
+          catch(:ignored) do
+            __dump_field(vs, name, type, *args)
+          end
+        rescue
+          STDERR.puts "#{self.class}: #{name}(#{type})"
+          raise
+        end
+      }
+      self
+    end
+
+    def __convert(input, output, input_big, output_big, parent = nil, index = nil)
+      __set_convert_type(input, output, input_big, output_big, parent, index)
+      __convert_fields
+      __unset_convert_type
+      self
+    end
+
+    def __load(input, input_big, parent = nil, index = nil)
+      __set_load_type(input, input_big, parent, index)
+      __load_fields
+      __unset_load_type
+      self
+    end
+
+    def __dump(output, output_big, parent = nil, index = nil)
+      __set_dump_type(output, output_big, parent, index)
+      __dump_fields
+      __unset_dump_type
+      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
+    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
+    end
+
+    def self.dump(value, output, output_big = LibBin::default_big?, parent = nil, index = nil)
+      value.__dump(output, output_big, parent, index)
+    end
+
+    def self.size(value, previous_offset = 0, parent = nil, index = nil)
+      value.__shape(previous_offset, parent, index).size
+    end
+
+    def self.shape(value, previous_offset = 0, parent = nil, index = nil, kind = DataShape)
+      value.__shape(previous_offset, parent, index, kind = DataShape)
+    end
+
+  end
+
+end

data/lib/libbin/alignment.rb

@@ -0,0 +1,14 @@
+module LibBin
+
+  module Alignment
+
+    def align(val, alignment)
+      remainder = val % alignment
+      val += alignment - remainder if remainder > 0
+      val
+    end
+    private :align
+
+  end
+
+end

data/lib/libbin/data_types.rb

@@ -0,0 +1,416 @@
+module LibBin
+
+  module RangeRefinement
+    refine Range do
+      def +(other)
+        Range::new(first <= other.first ? first : other.first,
+                   last >= other.last ? last : other.last,
+                   exclude_end?)
+      end
+    end
+  end
+
+  class DataShape
+    using RangeRefinement
+    attr_reader :range
+    attr_reader :members
+
+    def method_missing(m, *arg, &block)
+      return @members[m] if @members && @members[m]
+      super
+    end
+
+    def initialize(*args)
+      if args.length == 2
+        @range = Range::new(args[0], args[1])
+        @members = nil
+      else
+        @members = args[0]
+        @range = @members.values.flatten.compact.collect(&:range).reduce { |memo, obj| memo + obj }
+      end
+    end
+
+    def first
+      @range.first
+    end
+
+    def last
+      @range.last
+    end
+
+    def size
+      @range.size
+    end
+
+  end
+
+  class DataRange
+    using RangeRefinement
+    attr_reader :range
+
+    def initialize(*args)
+      if args.length == 2
+        @range = Range::new(args[0], args[1])
+      else
+        @range = args[0].values.flatten.compact.collect(&:range).reduce { |memo, obj| memo + obj }
+      end
+    end
+
+    def first
+      @range.first
+    end
+
+    def last
+      @range.last
+    end
+
+    def size
+      @range.size
+    end
+
+  end
+
+  class DataConverter
+
+    rl = lambda { |type, str|
+      str.unpack(type.to_s).first
+    }
+
+    sl = lambda { |type, value|
+      [value].pack(type.to_s)
+    }
+
+    l = lambda { |type|
+      [rl.curry[type], sl.curry[type]]
+    }
+
+    SCALAR_TYPES = {
+      :c => [:Int8, :int8],
+      :C => [:UInt8, :uint8],
+      :s => [:Int16, :int16],
+      :"s<" => [:Int16_LE, :int16_le],
+      :"s>" => [:Int16_BE, :int16_be],
+      :S => [:UInt16, :uint16],
+      :"S<" => [:UInt16_LE, :uint16_le],
+      :"S>" => [:UInt16_BE, :uint16_be],
+      :v => [:UInt16_LE, :uint16_le],
+      :n => [:UInt16_BE, :uint16_be],
+      :l => [:Int32, :int32],
+      :"l<" => [:Int32_LE, :int32_le],
+      :"l>" => [:Int32_BE, :int32_be],
+      :L => [:UInt32, :uint32],
+      :"L<" => [:UInt32_LE, :uint32_le],
+      :"L>" => [:UInt32_BE, :uint32_be],
+      :V => [:UInt32_LE, :uint32_le],
+      :N => [:UInt32_BE, :uint32_be],
+      :q => [:Int64, :int64],
+      :"q<" => [:Int64_LE, :int64_le],
+      :"q>" => [:Int64_BE, :int64_be],
+      :Q => [:UInt64, :uint64],
+      :"Q<" => [:UInt64_LE, :uint64_le],
+      :"Q>" => [:UInt64_BE, :uint64_be],
+      :F => [:Flt, :float],
+      :e => [:Flt_LE, :float_le],
+      :g => [:Flt_BE, :float_be],
+      :D => [:Double, :double],
+      :E => [:Double_LE, :double_le],
+      :G => [:Double_BE, :double_be],
+      :half => [:Half, :half],
+      :half_le => [:Half_LE, :half_le],
+      :half_be => [:Half_BE, :half_be],
+      :pghalf => [:PGHalf, :pghalf],
+      :pghalf_le => [:PGHalf_LE, :pghalf_le],
+      :pghalf_be => [:PGHalf_BE, :pghalf_be]
+     }
+
+    DATA_SIZES = Hash::new { |h,k|
+      if k.kind_of?(Symbol) && m = k.match(/a(\d+)/)
+        m[1].to_i
+      else
+        nil
+      end
+    }
+    DATA_SIZES.merge!( {
+      :c => 1,
+      :C => 1,
+      :s => 2,
+      :"s<" => 2,
+      :"s>" => 2,
+      :S => 2,
+      :"S<" => 2,
+      :"S>" => 2,
+      :v => 2,
+      :n => 2,
+      :l => 4,
+      :"l<" => 4,
+      :"l>" => 4,
+      :L => 4,
+      :"L<" => 4,
+      :"L>" => 4,
+      :V => 4,
+      :N => 4,
+      :q => 8,
+      :"q<" => 8,
+      :"q>" => 8,
+      :Q => 8,
+      :"Q<" => 8,
+      :"Q>" => 8,
+      :F => 4,
+      :e => 4,
+      :g => 4,
+      :D => 8,
+      :E => 8,
+      :G => 8,
+      :"a*" => -1,
+      :half => 2,
+      :half_le => 2,
+      :half_be => 2,
+      :pghalf => 2,
+      :pghalf_le => 2,
+      :pghalf_be => 2
+    } )
+    DATA_ENDIAN = {
+      true => Hash::new { |h,k|
+        if k.kind_of?(Symbol) && m = k.match(/a(\d+)/)
+          l[k]
+        else
+          nil
+        end
+      },
+      false => Hash::new { |h,k|
+        if k.kind_of?(Symbol) && m = k.match(/a(\d+)/)
+          l[k]
+        else
+          nil
+        end
+      }
+    }
+
+    DATA_ENDIAN[true].merge!( {
+      :c => l["c"],
+      :C => l["C"],
+      :s => l["s>"],
+      :"s<" => l["s<"],
+      :"s>" => l["s>"],
+      :S => l["S>"],
+      :"S<" => l["S<"],
+      :"S>" => l["S>"],
+      :v => l["v"],
+      :n => l["n"],
+      :l => l["l>"],
+      :"l<" => l["l<"],
+      :"l>" => l["l>"],
+      :L => l["L>"],
+      :"L<" => l["L<"],
+      :"L>" => l["L>"],
+      :V => l["V"],
+      :N => l["N"],
+      :q => l["q>"],
+      :"q<" => l["q<"],
+      :"q>" => l["q>"],
+      :Q => l["Q>"],
+      :"Q<" => l["Q<"],
+      :"Q>" => l["Q>"],
+      :F => l["g"],
+      :e => l["e"],
+      :g => l["g"],
+      :D => l["G"],
+      :E => l["E"],
+      :G => l["G"],
+      :"a*" => l["a*"],
+      :half => [ lambda { |str| Flt::IEEE_binary16_BE::from_bytes(str).to(Float) },
+                 lambda { |v| Flt::IEEE_binary16_BE::new(v).to_bytes } ],
+      :half_le => [ lambda { |str| Flt::IEEE_binary16_LE::from_bytes(str).to(Float) },
+                    lambda { |v| Flt::IEEE_binary16_LE::new(v).to_bytes } ],
+      :half_be => [ lambda { |str| Flt::IEEE_binary16_BE::from_bytes(str).to(Float) },
+                    lambda { |v| Flt::IEEE_binary16_BE::new(v).to_bytes } ],
+      :pghalf => [ lambda { |str| Flt::IEEE_binary16_pg_BE::from_bytes(str).to(Float) },
+                   lambda { |v| Flt::IEEE_binary16_pg_BE::new(v).to_bytes } ],
+      :pghalf_le => [ lambda { |str| Flt::IEEE_binary16_pg_LE::from_bytes(str).to(Float) },
+                      lambda { |v| Flt::IEEE_binary16_pg_LE::new(v).to_bytes } ],
+      :pghalf_be => [ lambda { |str| Flt::IEEE_binary16_pg_BE::from_bytes(str).to(Float) },
+                      lambda { |v| Flt::IEEE_binary16_pg_BE::new(v).to_bytes } ]
+    } )
+    DATA_ENDIAN[false].merge!( {
+      :c => l["c"],
+      :C => l["C"],
+      :s => l["s<"],
+      :"s<" => l["s<"],
+      :"s>" => l["s>"],
+      :S => l["S<"],
+      :"S<" => l["S<"],
+      :"S>" => l["S>"],
+      :v => l["v"],
+      :n => l["n"],
+      :l => l["l<"],
+      :"l<" => l["l<"],
+      :"l>" => l["l>"],
+      :L => l["L<"],
+      :"L<" => l["L<"],
+      :"L>" => l["L>"],
+      :V => l["V"],
+      :N => l["N"],
+      :q => l["q<"],
+      :"q<" => l["q<"],
+      :"q>" => l["q>"],
+      :Q => l["Q<"],
+      :"Q<" => l["Q<"],
+      :"Q>" => l["Q>"],
+      :F => l["e"],
+      :e => l["e"],
+      :g => l["g"],
+      :D => l["E"],
+      :E => l["E"],
+      :G => l["G"],
+      :"a*" => l["a*"],
+      :half => [ lambda { |str| Flt::IEEE_binary16::from_bytes(str).to(Float) },
+                 lambda { |v| Flt::IEEE_binary16::new(v).to_bytes } ],
+      :half_le => [ lambda { |str| Flt::IEEE_binary16_LE::from_bytes(str).to(Float) },
+                    lambda { |v| Flt::IEEE_binary16_LE::new(v).to_bytes } ],
+      :half_be => [ lambda { |str| Flt::IEEE_binary16_BE::from_bytes(str).to(Float) },
+                    lambda { |v| Flt::IEEE_binary16_BE::new(v).to_bytes } ],
+      :pghalf => [ lambda { |str| Flt::IEEE_binary16_pg::from_bytes(str).to(Float) },
+                   lambda { |v| Flt::IEEE_binary16_pg::new(v).to_bytes } ],
+      :pghalf_le => [ lambda { |str| Flt::IEEE_binary16_pg_LE::from_bytes(str).to(Float) },
+                      lambda { |v| Flt::IEEE_binary16_pg_LE::new(v).to_bytes } ],
+      :pghalf_be => [ lambda { |str| Flt::IEEE_binary16_pg_BE::from_bytes(str).to(Float) },
+                      lambda { |v| Flt::IEEE_binary16_pg_BE::new(v).to_bytes } ]
+    } )
+
+
+    class Scalar
+
+      def self.size(*args)
+        @size
+      end
+
+      def self.shape(value, previous_offset = 0, _ = nil, _ = nil, kind = DataShape)
+        kind::new(previous_offset, previous_offset + @size - 1)
+      end
+
+      def self.init(symbol)
+        @symbol = symbol
+        @size = DATA_SIZES[symbol]
+        @rl_be, @sl_be = DATA_ENDIAN[true][symbol]
+        @rl_le, @sl_be = 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]
+      end
+
+      def self.dump(value, output, output_big = LibBin::default_big?, _ = nil, _ = nil)
+        str = (output_big ? @sl_be[value] : @sl_le[value])
+        output.write(str)
+      end
+
+      def self.convert(input, output, input_big = LibBin::default_big?, output_big = !LibBin::default_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])
+        output.write(str)
+        value
+      end
+
+    end
+
+    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]
+      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])
+        output.write(str)
+        value
+      end
+
+      def self.shape(value, previous_offset = 0, _ = nil, _ = nil, kind = DataShape)
+        if @size < 0
+          kind::new(previous_offset, previous_offset + value.size - 1)
+        else
+          kind::new(previous_offset, previous_offset + @size - 1)
+        end
+      end
+
+    end
+
+    def self.register_field(field, type, count: nil, offset: nil, sequence: false, condition: nil)
+      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])
+        else
+          @fields.push([field, const_get(SCALAR_TYPES[type][0]), count, offset, sequence, condition])
+        end
+      else
+        @fields.push([field, type, count, offset, sequence, condition])
+      end
+      attr_accessor field
+    end
+
+    def self.create_scalar_type(symbol)
+      klassname, name = SCALAR_TYPES[symbol]
+      eval <<EOF
+    class #{klassname} < Scalar
+      init(#{symbol.inspect})
+    end
+
+    def self.#{name}(field, count: nil, offset: nil, sequence: false, condition: nil)
+      @fields.push([field, #{klassname}, count, offset, sequence, condition])
+      attr_accessor field
+    end
+EOF
+    end
+
+    create_scalar_type(:c)
+    create_scalar_type(:C)
+    create_scalar_type(:s)
+    create_scalar_type(:"s<")
+    create_scalar_type(:"s>")
+    create_scalar_type(:S)
+    create_scalar_type(:"S<")
+    create_scalar_type(:"S>")
+    create_scalar_type(:l)
+    create_scalar_type(:"l<")
+    create_scalar_type(:"l>")
+    create_scalar_type(:L)
+    create_scalar_type(:"L<")
+    create_scalar_type(:"L>")
+    create_scalar_type(:q)
+    create_scalar_type(:"q<")
+    create_scalar_type(:"q>")
+    create_scalar_type(:Q)
+    create_scalar_type(:"Q<")
+    create_scalar_type(:"Q>")
+    create_scalar_type(:F)
+    create_scalar_type(:e)
+    create_scalar_type(:g)
+    create_scalar_type(:D)
+    create_scalar_type(:E)
+    create_scalar_type(:G)
+    create_scalar_type(:half)
+    create_scalar_type(:half_le)
+    create_scalar_type(:half_be)
+    create_scalar_type(:pghalf)
+    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*")
+      c = Class::new(Str) do
+        init(sym)
+      end
+      @fields.push([field, c, count, offset, sequence, condition])
+      attr_accessor field
+    end
+
+
+  end
+
+end

data/libbin.gemspec

@@ -0,0 +1,14 @@
+Gem::Specification.new do |s|
+  s.name = 'libbin'
+  s.version = "0.9.0"
+  s.author = "Brice Videau"
+  s.email = "brice.videau@imag.fr"
+  s.homepage = "https://github.com/kerilk/libbin"
+  s.summary = "Library for loading and converting binary files"
+  s.description = "Read, write and convert Binary data in Ruby."
+  s.files =  Dir[ 'libbin.gemspec', 'LICENSE', 'lib/**/*.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'
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: libbin
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+platform: ruby
+authors:
+- Brice Videau
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-12-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: float-formats
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+description: Read, write and convert Binary data in Ruby.
+email: brice.videau@imag.fr
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- lib/libbin.rb
+- lib/libbin/alignment.rb
+- lib/libbin/data_types.rb
+- libbin.gemspec
+homepage: https://github.com/kerilk/libbin
+licenses:
+- BSD-2-Clause
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Library for loading and converting binary files
+test_files: []