libbin 1.0.7 → 1.0.8

data/ext/libbin/libbin_c.h

@@ -0,0 +1,12 @@
+#ifndef LIBBIN_C_H__
+#define LIBBIN_C_H__
+#include "./half.h"
+#include "./pghalf.h"
+#include "./libbin_endian.h"
+#include "./data_types.h"
+
+
+extern VALUE mLibBin;
+extern VALUE cField;
+
+#endif

data/ext/libbin/libbin_endian.h

@@ -0,0 +1,126 @@
+#ifndef LIBBIN_ENDIAN_H__
+#define LIBBIN_ENDIAN_H__
+
+#include <stdint.h>
+
+static inline void little_big_swap(void *addr, size_t sz) {
+  char *p = (char *)addr;
+  for (size_t i = 0, j = sz - 1; i < (sz >> 1); i++, j--) {
+    char tmp = p[i];
+    p[i] = p[j];
+    p[j] = tmp;
+  }
+}
+#define LITTLE_BIG_SWAP(val) little_big_swap(&(val), sizeof(val))
+
+static inline unsigned is_little_endian(void)
+{
+  const union { unsigned u; unsigned char c[4]; } one = { 1 };
+  return one.c[0];
+}
+
+/* https://stackoverflow.com/a/2182184 */
+static inline uint8_t bswap_uint8(uint8_t x) {
+  return x;
+}
+
+static inline uint16_t bswap_uint16(uint16_t x) {
+  return ((( x  & 0xff00u ) >> 8 ) |
+          (( x  & 0x00ffu ) << 8 ));
+}
+
+static inline uint32_t bswap_uint32(uint32_t x) {
+  return ((( x & 0xff000000u ) >> 24 ) |
+          (( x & 0x00ff0000u ) >> 8  ) |
+          (( x & 0x0000ff00u ) << 8  ) |
+          (( x & 0x000000ffu ) << 24 ));
+}
+
+static inline uint64_t bswap_uint64(uint64_t x) {
+  return ((( x & 0xff00000000000000ull ) >> 56 ) |
+          (( x & 0x00ff000000000000ull ) >> 40 ) |
+          (( x & 0x0000ff0000000000ull ) >> 24 ) |
+          (( x & 0x000000ff00000000ull ) >> 8  ) |
+          (( x & 0x00000000ff000000ull ) << 8  ) |
+          (( x & 0x0000000000ff0000ull ) << 24 ) |
+          (( x & 0x000000000000ff00ull ) << 40 ) |
+          (( x & 0x00000000000000ffull ) << 56 ));
+}
+
+
+
+#define SWAP_CONVERT(TYPE, MAPPED_NAME, MAPPED_TYPE) \
+do {                                                 \
+  union { TYPE t; MAPPED_TYPE m; } v = { .m = x };   \
+  v.m = bswap_ ## MAPPED_NAME(v.m);                  \
+  return v.t;                                        \
+} while (0)
+
+#define CONVERT(TYPE, MAPPED_TYPE)                 \
+do {                                               \
+  union { TYPE t; MAPPED_TYPE m; } v = { .m = x }; \
+  return v.t;                                      \
+} while (0)
+
+#define CONVERT_SWAP(TYPE, MAPPED_NAME, MAPPED_TYPE) \
+do {                                                 \
+  union { TYPE t; MAPPED_TYPE m; } v = { .t = x };   \
+  v.m = bswap_ ## MAPPED_NAME(v.m);                  \
+  return v.m;                                         \
+} while(0)
+
+#define UNPACKER_BE(NAME, TYPE, MAPPED_NAME, MAPPED_TYPE)  \
+static inline TYPE unpack_ ## NAME ## _be(MAPPED_TYPE x) { \
+  if (is_little_endian())                                  \
+    SWAP_CONVERT(TYPE, MAPPED_NAME, MAPPED_TYPE);          \
+  else                                                     \
+    CONVERT(TYPE, MAPPED_TYPE);                            \
+}
+
+#define UNPACKER_LE(NAME, TYPE, MAPPED_NAME, MAPPED_TYPE)  \
+static inline TYPE unpack_ ## NAME ## _le(MAPPED_TYPE x) { \
+  if (is_little_endian())                                  \
+    CONVERT(TYPE, MAPPED_TYPE);                            \
+  else                                                     \
+    SWAP_CONVERT(TYPE, MAPPED_NAME, MAPPED_TYPE);          \
+}
+
+#define PACKER_BE(NAME, TYPE, MAPPED_NAME, MAPPED_TYPE)  \
+static inline MAPPED_TYPE pack_ ## NAME ## _be(TYPE x) { \
+  if (is_little_endian())                                \
+    CONVERT_SWAP(TYPE, MAPPED_NAME, MAPPED_TYPE);        \
+  else                                                   \
+    CONVERT(MAPPED_TYPE, TYPE);                          \
+}
+
+#define PACKER_LE(NAME, TYPE, MAPPED_NAME, MAPPED_TYPE)  \
+static inline MAPPED_TYPE pack_ ## NAME ## _le(TYPE x) { \
+  if (is_little_endian())                                \
+    CONVERT(MAPPED_TYPE, TYPE);                          \
+  else                                                   \
+    CONVERT_SWAP(TYPE, MAPPED_NAME, MAPPED_TYPE);        \
+}
+
+#define CONVERTER_TYPE(NAME, TYPE, MAPPED_NAME, MAPPED_TYPE) \
+  UNPACKER_BE(NAME, TYPE, MAPPED_NAME, MAPPED_TYPE)          \
+  UNPACKER_LE(NAME, TYPE, MAPPED_NAME, MAPPED_TYPE)          \
+  PACKER_BE(NAME, TYPE, MAPPED_NAME, MAPPED_TYPE)            \
+  PACKER_LE(NAME, TYPE, MAPPED_NAME, MAPPED_TYPE)
+
+#define CONVERTER(NAME, TYPE, SIZE)                            \
+  CONVERTER_TYPE(NAME, TYPE, uint ## SIZE, uint ## SIZE ## _t)
+
+CONVERTER(uint8, uint8_t, 8)
+CONVERTER(int8, int8_t, 8)
+CONVERTER(uint16, uint16_t, 16)
+CONVERTER(int16, int16_t, 16)
+CONVERTER(uint32, uint32_t, 32)
+CONVERTER(int32, int32_t, 32)
+CONVERTER(uint64, uint64_t, 64)
+CONVERTER(int64, int64_t, 64)
+CONVERTER(float, float, 32)
+CONVERTER(double, double, 64)
+CONVERTER(half, uint16_t, 16)
+CONVERTER(pghalf, uint16_t, 16)
+
+#endif

data/lib/libbin/data_types.rb

@@ -27,7 +27,11 @@ module LibBin
         @members = nil
       else
         @members = args[0]
-        @range = @members.values.flatten.compact.collect(&:range).reduce(:+)
+        if @members.kind_of?(Hash)
+          @range = @members.values.compact.collect(&:range).reduce(:+)
+        else
+          @range = @members.compact.collect(&:range).reduce(:+)
+        end
       end
     end
 
@@ -53,7 +57,11 @@ module LibBin
       if args.length == 2
         @range = Range::new(args[0], args[1])
       else
-        @range = args[0].values.flatten.compact.collect(&:range).reduce(:+)
+        if args[0].kind_of?(Hash)
+          @range = args[0].values.compact.collect(&:range).reduce(:+)
+        else
+          @range = args[0].compact.collect(&:range).reduce(:+)
+        end
       end
     end
 
@@ -71,58 +79,38 @@ 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 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, number = nil|
-      if number
-        str.unpack(type.to_s+number.to_s)
-      else
-        str.unpack(type.to_s).first
-      end
-    }
-
-    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|
-      [rl.curry[type], sl.curry[type]]
-    }
-
     SCALAR_TYPES = {
       :c => [:Int8, :int8],
       :C => [:UInt8, :uint8],
@@ -160,271 +148,12 @@ module LibBin
       :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,
-      :"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
-      }
-    }
-
-    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"],
-      :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"],
-      :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"],
-      :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"],
-      :half => hl["S<"],
-      :half_le => hl["S<"],
-      :half_be => hl["S>"],
-      :pghalf => pghl["S<"],
-      :pghalf_le => pghl["S<"],
-      :pghalf_be => pghl["S>"]
-    } )
-
-
-    class Scalar
-
-      def self.size(*args)
-        @size
-      end
-
-      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)
-        @symbol = symbol
-        @size = DATA_SIZES[symbol]
-        @rl_be, @sl_be = DATA_ENDIAN[true][symbol]
-        @rl_le, @sl_le = DATA_ENDIAN[false][symbol]
-      end
-
-      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, 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, 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
-
-    end
-
-    class Str < Scalar
-
-      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, length = nil)
-        str = (length ? input.read(length) : input.readline("\x00"))
-        output.write(str)
-        str
-      end
-
-      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 + 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, length: nil, count: nil, offset: nil, sequence: false, condition: nil, relative_offset: false)
       if type.kind_of?(Symbol)
         if type[0] == 'a'
-          real_type = Class::new(Str) do init(sym) end
+          real_type = Str
         else
           real_type = const_get(SCALAR_TYPES[type][0])
         end
@@ -435,13 +164,9 @@ module LibBin
       attr_accessor field
     end
 
-    def self.create_scalar_type(symbol)
+    def self.create_scalar_accessor(symbol)
       klassname, name = SCALAR_TYPES[symbol]
       eval <<EOF
-    class #{klassname} < Scalar
-      init(#{symbol.inspect})
-    end
-
     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
@@ -449,45 +174,23 @@ module LibBin
 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)
+    [:c,
+     :C,
+     :s, :"s<", :"s>",
+     :S, :"S<", :"S>",
+     :l, :"l<", :"l>",
+     :L, :"L<", :"L>",
+     :q, :"q<", :"q>",
+     :Q, :"Q<", :"Q>",
+     :F, :e, :g,
+     :D, :E, :G,
+     :half, :half_le, :half_be,
+     :pghalf, :pghalf_le, :pghalf_be].each { |c|
+      create_scalar_accessor(c)
+    }
 
     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::new(field, c, length, count, offset, sequence, condition, relative_offset))
+      @fields.push(Field::new(field, Str, length, count, offset, sequence, condition, relative_offset))
       attr_accessor field
     end