gogyou 0.2.3 → 0.2.4

data/lib/gogyou.rb

@@ -1,8 +1,8 @@
 #vim: set fileencoding:utf-8
 
 # gogyou.rb
-# - AUTHOR: dearblue <dearblue@users.sourceforge.jp>
-# - WEBSIZE: http://sourceforge.jp/projects/rutsubo/
+# - AUTHOR: dearblue <dearblue@users.osdn.me>
+# - WEBSIZE: https://osdn.jp/projects/rutsubo/
 # - LICENSE: same as 2-clause BSD License
 
 #--
@@ -24,42 +24,61 @@
 #
 # 原始的な型情報は Gogyou::Primitives で定義してあり、struct や union メソッド内で利用できる型を次の表に示します:
 #
-# ==== C 標準型
-#                           符号あり    符号なし
-#                           ----        ----
-#   char 型                 char        uchar
-#                                       unsigned_char
-#   short 型                short       ushort
-#                                       unsigned_short
-#   int 型                  int         uint
-#                                       unsigned_int
-#   long 型                 long        ulong
-#                                       unsigned_long
-#   long long 型            longlong    ulonglong
-#                           long_long   unsigned_long_long
-#   sizeof 型               ssize_t     size_t
-#   ポインタ整数型          intptr_t    uintptr_t
-#
-#                           バイトオーダー環境依存  バイトオーダー反転
-#                           符号あり  符号なし      符号あり    符号なし
-#                           ----      ----          ----        ----
-#   8ビット整数型           int8_t    uint8_t       N/A         N/A
-#   16ビット整数型          int16_t   uint16_t      int16_swap  uint16_swap
-#   32ビット整数型          int32_t   uint32_t      int32_swap  uint32_swap
-#   64ビット整数型          int64_t   uint64_t      int64_swap  uint64_swap
-#   32ビット浮動小数点数型  float     N/A           float_swap  N/A
-#   64ビット浮動小数点数型  double    N/A           double_swap N/A
-#
-#                           ビッグエンディアン    リトルエンディアン
-#                           符号あり  符号なし    符号あり  符号なし
-#                           ----      ----        ----      ----
-#   16ビット整数型          int16_be  uint16_be   int16_le  uint16_le
-#   24ビット整数型          int24_be  uint24_be   int24_le  uint24_le
-#   32ビット整数型          int32_be  uint32_be   int32_le  uint32_le
-#   48ビット整数型          int48_be  uint48_be   int48_le  uint48_le
-#   64ビット整数型          int64_be  uint64_be   int64_le  uint64_le
-#   32ビット浮動小数点数型  float_be  N/A         float_le  N/A
-#   64ビット浮動小数点数型  double_be N/A         double_le N/A
+# ==== 型名
+#
+# * C の型名
+#                               符号あり    符号なし
+#                               ----        ----
+#       char 型                 char        uchar
+#                                           unsigned_char
+#       short 型                short       ushort
+#                                           unsigned_short
+#       int 型                  int         uint
+#                                           unsigned_int
+#       long 型                 long        ulong
+#                                           unsigned_long
+#       long long 型            longlong    ulonglong
+#                               long_long   unsigned_long_long
+#       sizeof 型               ssize_t     size_t
+#       ポインタ整数型          intptr_t    uintptr_t
+#       float                   float       N/A
+#       double                  double      N/A
+#
+# * バイトオーダー環境依存・ビット数環境非依存
+#                                 バイトオーダー環境依存  バイトオーダー反転
+#                                 符号あり    符号なし    符号あり      符号なし
+#                                 ----        ----        ----          ----
+#       8ビット整数型             int8_t      uint8_t     N/A           N/A
+#       16ビット整数型            int16_t     uint16_t    int16_swap    uint16_swap
+#       32ビット整数型            int32_t     uint32_t    int32_swap    uint32_swap
+#       64ビット整数型            int64_t     uint64_t    int64_swap    uint64_swap
+#       16ビット浮動小数点実数型  float16_t   N/A         float16_swap  N/A
+#       32ビット浮動小数点実数型  float32_t   N/A         float32_swap  N/A
+#       64ビット浮動小数点実数型  float64_t   N/A         float64_swap  N/A
+#
+# * バイトオーダー・ビット数環境非依存
+#                                 ビッグエンディアン      リトルエンディアン
+#                                 符号あり    符号なし    符号あり      符号なし
+#                                 ----        ----        ----          ----
+#       16ビット整数型            int16_be    uint16_be   int16_le      uint16_le
+#       24ビット整数型            int24_be    uint24_be   int24_le      uint24_le
+#       32ビット整数型            int32_be    uint32_be   int32_le      uint32_le
+#       48ビット整数型            int48_be    uint48_be   int48_le      uint48_le
+#       64ビット整数型            int64_be    uint64_be   int64_le      uint64_le
+#       16ビット浮動小数点実数型  float16_be  N/A         float16_le    N/A
+#       32ビット浮動小数点実数型  float32_be  N/A         float32_le    N/A
+#       64ビット浮動小数点実数型  float64_be  N/A         float64_le    N/A
+#
+# * 固定小数点実数型 (ビット数環境非依存)
+#
+#                                               バイトオーダー環境依存          バイトオーダー環境非依存
+#
+#     16ビット固定小数点実数型(小数部8ビット)   fixed16q8_t   fixed16q8_swap    fixed16q8_be  fixed16q8_le
+#     32ビット固定小数点実数型(小数部6ビット)   fixed32q6_t   fixed32q6_swap    fixed32q6_be  fixed32q6_le
+#     32ビット固定小数点実数型(小数部8ビット)   fixed32q8_t   fixed32q8_swap    fixed32q8_be  fixed32q8_le
+#     32ビット固定小数点実数型(小数部12ビット)  fixed32q12_t  fixed32q12_swap   fixed32q12_be fixed32q12_le
+#     32ビット固定小数点実数型(小数部16ビット)  fixed32q16_t  fixed32q16_swap   fixed32q16_be fixed32q16_le
+#     32ビット固定小数点実数型(小数部24ビット)  fixed32q24_t  fixed32q24_swap   fixed32q24_be fixed32q24_le
 #
 #
 # ==== 利用者定義の型情報
@@ -134,12 +153,19 @@
 #     * #\<field> / #\<field>= - 構造体・共用体のフィールドへの参照・代入メソッド。配列の場合は定義されない。
 #     * #[] / []= - 配列の要素への参照・代入メソッド。構造体・共用体の場合は定義されない。
 #
+# * 構造体のメモリイメージとなるバッファオブジェクト
+#
+#   構造体のバイト列を表現するオブジェクトのことです。
+#
+#   * String
+#   * Fiddle::Pointer
+#
 module Gogyou
   Gogyou = self
 
   require_relative "gogyou/version"
   require_relative "gogyou/typespec"
-  require_relative "gogyou/mixin"
+  require_relative "gogyou/extensions"
   require_relative "gogyou/model"
   require_relative "gogyou/primitives"
   require_relative "gogyou/accessor"
@@ -149,7 +175,7 @@ module Gogyou
 
     Gogyou::Primitives.constants.each do |n|
       prim = Gogyou::Primitives.const_get(n)
-      next unless prim.kind_of?(Gogyou::Primitives::Primitive)
+      next unless prim.kind_of?(Gogyou::Primitive)
       TYPEMAP[prim.name.to_sym] = prim
     end
 

data/lib/gogyou/accessor.rb

@@ -50,10 +50,12 @@ module Gogyou
       @buffer__GOGYOU__
     end
 
-    def to_ptr
-      @buffer__GOGYOU__.to_ptr
+    def to_address
+      @buffer__GOGYOU__.to_address + @offset__GOGYOU__
     end
 
+    alias to_ptr to_address
+
     #
     # call-seq:
     #   slide() -> new_accessor or nil
@@ -182,7 +184,8 @@ module Gogyou
         define_method(:size__GOGYOU__, -> { fieldsize })
         alias_method(:elementsize, :size__GOGYOU__)
         alias_method(:size, :size__GOGYOU__)
-        model.fields.each do |field|
+        const_set(:GOGYOU_FIELD_TYPES, types = [])
+        model.fields.each_with_index do |field, ifield|
           name = field.name
           name = name.intern
           raise NameError, "already exist field name - #{name}" if namecheck[name]
@@ -190,24 +193,26 @@ module Gogyou
 
           if field.vector
             subarray = define_subarray(field)
-            type = subarray
+            types << subarray
           else
             subarray = nil
-            type = field.type
+            types << field.type
           end
 
-          define_method(field.name, -> {
-            v = type.aref(@buffer__GOGYOU__, @offset__GOGYOU__ + field.offset)
-            v.infect_from(self, buffer) unless v.frozen?
-            v.freeze if frozen? || buffer.frozen? || field.const?
-            v
-          })
-
-          define_method("#{field.name}=", ->(value) {
-            raise TypeError, "immutable object (#<%s:0x%08X>.%s)" % [self.class, __id__, field.name], caller(2) if frozen?
-            raise TypeError, "immutable field (#<%s:0x%08X>.%s)" % [self.class, __id__, field.name], caller(2) if field.const?
-            type.aset(@buffer__GOGYOU__, @offset__GOGYOU__ + field.offset, value)
-          })
+          class_eval <<-EOS, __FILE__, __LINE__ + 1
+            def #{field.name}
+              v = GOGYOU_FIELD_TYPES[#{ifield}].aref(@buffer__GOGYOU__, @offset__GOGYOU__ + #{field.offset})
+              v.taint if !v.frozen? && (tainted? || @buffer__GOGYOU__.tainted?)
+              v.freeze if #{field.const?} || frozen? || @buffer__GOGYOU__.frozen?
+              v
+            end
+
+            def #{field.name}=(value)
+              raise TypeError, "immutable object (#<%s:0x%08X>)" % [self.class, __id__], caller(1) if frozen?
+              raise TypeError, "immutable field (#<%s:0x%08X>.%s)" % [self.class, __id__, #{field.name.inspect}], caller(1) if #{field.const?}
+              GOGYOU_FIELD_TYPES[#{ifield}].aset(@buffer__GOGYOU__, @offset__GOGYOU__ + #{field.offset}, value)
+            end
+          EOS
         end
       end
     end
@@ -270,6 +275,8 @@ module Gogyou
     end
 
     class Array < BasicArray
+      include Enumerable
+
       def self.elements
         self::ELEMENTS
       end
@@ -300,32 +307,34 @@ module Gogyou
           bytesize = type.bytesize
 
           if model.bytesize == 0
-            define_method(:check_index, ->(index) {
-              index = index.to_i
-              unless index >= 0 && index < self.elementsize
-                raise IndexError, "out of element size (index #{index} for 0 ... #{self.elementsize})", caller(2)
+            class_eval <<-EOS, __FILE__, __LINE__ + 1
+              def check_index(index)
+                index = index.to_i
+                unless index >= 0 && index < elementsize
+                  raise IndexError, "out of element size (index \#{index} for 0 ... \#{elementsize})", caller
+                end
+                index
+              end
+
+              def <<(value)
+                raise TypeError, "immutable object (#<%s:0x%08X>)" % [self.class, __id__], caller if frozen?
+                voff = (@buffer__GOGYOU__.bytesize - @offset__GOGYOU__).align_floor(SUBTYPE.bytesize)
+                expandsize = @offset__GOGYOU__ + voff + SUBTYPE.bytesize
+                @buffer__GOGYOU__.resize(expandsize)
+                SUBTYPE.aset(@buffer__GOGYOU__, @offset__GOGYOU__ + voff, value)
+                self
+              end
+
+              def elementsize
+                (@buffer__GOGYOU__.bytesize - @offset__GOGYOU__).unit_floor(SUBTYPE.bytesize)
               end
-              index
-            })
-
-            define_method(:<<, ->(value) {
-              raise TypeError, "immutable object (#<%s:0x%08X>)" % [self.class, __id__], caller(2) if frozen?
-              voff = (@buffer__GOGYOU__.bytesize - @offset__GOGYOU__).align_floor(type.bytesize)
-              expandsize = @offset__GOGYOU__ + voff + type.bytesize
-              @buffer__GOGYOU__.resize(expandsize)
-              type.aset(@buffer__GOGYOU__, @offset__GOGYOU__ + voff, value)
-              self
-            })
-
-            define_method(:elementsize, -> {
-              (@buffer__GOGYOU__.bytesize - @offset__GOGYOU__).unit_floor(type.bytesize)
-            })
-
-            alias_method(:size, :elementsize)
-
-            define_method(:bytesize, -> {
-              (@buffer__GOGYOU__.bytesize - @offset__GOGYOU__).align_floor(type.bytesize)
-            })
+
+              alias size elementsize
+
+              def bytesize
+                (@buffer__GOGYOU__.bytesize - @offset__GOGYOU__).align_floor(SUBTYPE.bytesize)
+              end
+            EOS
           else
             eval <<-EOS
               def check_index(index)
@@ -348,21 +357,23 @@ module Gogyou
             EOS
           end
 
-          define_method(:to_s, -> {
-            @buffer__GOGYOU__.byteslice(@offset__GOGYOU__, self.bytesize)
-          })
-
-          define_method(:[], ->(index) {
-            v = type.aref(@buffer__GOGYOU__, @offset__GOGYOU__ + check_index(index) * bytesize)
-            v.infect_from(self, buffer) unless v.frozen?
-            v.freeze if frozen? || buffer.frozen? || field.const?
-            v
-          })
-
-          define_method(:[]=, ->(index, value) {
-            raise TypeError, "immutable object (#<%s:0x%08X>)" % [self.class, __id__, index], caller(2) if frozen? || field.const?
-            type.aset(@buffer__GOGYOU__, @offset__GOGYOU__ + check_index(index) * bytesize, value)
-          })
+          class_eval <<-EOS, __FILE__, __LINE__ + 1
+            def to_s
+              @buffer__GOGYOU__.byteslice(@offset__GOGYOU__, bytesize)
+            end
+
+            def [](index)
+              v = SUBTYPE.aref(@buffer__GOGYOU__, @offset__GOGYOU__ + check_index(index) * #{bytesize})
+              v.infect_from(self, @buffer__GOGYOU__) unless v.frozen?
+              v.freeze if #{field.const?} || frozen? || @buffer__GOGYOU__.frozen?
+              v
+            end
+
+            def []=(index, value)
+              raise TypeError, "immutable object (#<%s:0x%08X>)" % [self.class, __id__, index], caller if #{field.const?} || frozen?
+              SUBTYPE.aset(@buffer__GOGYOU__, @offset__GOGYOU__ + check_index(index) * #{bytesize}, value)
+            end
+          EOS
         end
         klass
       end
@@ -388,6 +399,18 @@ module Gogyou
         self.class::BYTESIZE * @buffer__GOGYOU__.bytesize.unit_floor(self.class::SUBTYPE)
       end
 
+      def each
+        return to_enum unless block_given?
+        elementsize.times { |i| yield self[i] }
+        self
+      end
+
+      def each_with_index
+        return to_enum(:each_with_index) unless block_given?
+        elementsize.times { |i| yield self[i], i }
+        self
+      end
+
       def inspect
         text = "["
         elementsize.times.with_index do |n, i|

data/lib/gogyou/bytearray.rb

@@ -0,0 +1,856 @@
+module Gogyou
+  module Extensions
+    #
+    # .bytesize・.byteslice・.setbinary・.getbyte・.setbyte メソッドを用いて
+    # 整数値・実数値を埋め込む・取り出すメソッドを定義します。
+    #
+    # gogyou は ruby の String や Fiddle::Pointer、FFI::AbstractPointer
+    # クラスにこのモジュールを include しています。
+    #
+    module ByteArray
+      def swapbyte(index, bytesize)
+        i = index.to_i
+        j = i + bytesize.to_i - 1
+        while i < j
+          w = getbyte(i)
+          setbyte(i, getbyte(j))
+          setbyte(j, w)
+          i += 1
+          j -= 1
+        end
+
+        self
+      end
+
+      def storebe(index, num, bytesize)
+        raise RangeError unless index >= 0 &&
+          index < bytesize &&
+          index + bytesize <= bytesize() &&
+          index + bytesize >= 0
+        while bytesize > 0
+          bytesize -= 1
+          setbyte(index, 0xff & (num >> (bytesize * BITS_PER_BYTE)))
+          index += 1
+        end
+
+        self
+      end
+
+      def storele(index, num, bytesize)
+        raise RangeError unless index >= 0 &&
+                                index < bytesize() &&
+                                index + bytesize <= bytesize() &&
+                                index + bytesize >= 0
+        while bytesize > 0
+          bytesize -= 1
+          setbyte(index, 0xff & num)
+          num >>= BITS_PER_BYTE
+          index += 1
+        end
+
+        self
+      end
+
+      def loadube(index, bytesize)
+        n = 0
+        while bytesize > 0
+          bytesize -= 1
+          n <<= BITS_PER_BYTE
+          n |= getbyte(index)
+          index += 1
+        end
+        n
+      end
+
+      def loadibe(index, bytesize)
+        loadube(index, bytesize).extendsign(bytesize * BITS_PER_BYTE)
+      end
+
+      def loadule(index, bytesize)
+        n = 0
+        c = 0
+        while bytesize > 0
+          bytesize -= 1
+          n |= getbyte(index) << (BITS_PER_BYTE * c)
+          index += 1
+          c += 1
+        end
+        n
+      end
+
+      def loadile(index, bytesize)
+        loadule(index, bytesize).extendsign(bytesize * BITS_PER_BYTE)
+      end
+
+      def store8(index, num)
+        setbyte(index.to_i, 0xff & num.to_i)
+      end
+
+      def loadu8(index)
+        getbyte(index)
+      end
+
+      def loadi8(index)
+        getbyte(index).extendsign_char
+      end
+
+      def store16(index, num)
+        setbinary(index, [num].pack("S"))
+      end
+
+      def loadi16(index)
+        byteslice(index, 2).unpack("s")[0]
+      end
+
+      def loadu16(index)
+        byteslice(index, 2).unpack("S")[0]
+      end
+
+      def store16swap(index, num)
+        setbinary(index, [num.swap16].pack("S"))
+      end
+
+      def loadi16swap(index)
+        byteslice(index, 2).unpack("s")[0].swap16s
+      end
+
+      def loadu16swap(index)
+        byteslice(index, 2).unpack("S")[0].swap16
+      end
+
+      def store16be(index, num)
+        index = index.to_i
+        num = 0xffff & num.to_i
+        setbyte(index    , num >>  8)
+        setbyte(index + 1, num      )
+      end
+
+      def loadu16be(index)
+        (getbyte(index) << 8) |
+          (getbyte(index + 1))
+      end
+
+      def loadi16be(index)
+        (getbyte(index).extendsign_char << 8) |
+          (getbyte(index + 1))
+      end
+
+      def store16le(index, num)
+        index = index.to_i
+        num = 0xffff & num.to_i
+        setbyte(index    , num      )
+        setbyte(index + 1, num >>  8)
+      end
+
+      def loadu16le(index)
+        (getbyte(index)) |
+          (getbyte(index + 1) << 8)
+      end
+
+      def loadi16le(index)
+        (getbyte(index)) |
+          (getbyte(index + 1).extendsign_char << 8)
+      end
+
+      def store24be(index, num)
+        index = index.to_i
+        num = 0xffffff & num.to_i
+        setbyte(index    , num >> 16)
+        setbyte(index + 1, num >>  8)
+        setbyte(index + 2, num      )
+      end
+
+      def loadu24be(index)
+        (getbyte(index) << 16) |
+          (getbyte(index + 1) << 8) |
+          (getbyte(index + 2))
+      end
+
+      def loadi24be(index)
+        (getbyte(index).extendsign_char << 16) |
+          (getbyte(index + 1) << 8) |
+          (getbyte(index + 2))
+      end
+
+      def store24le(index, num)
+        index = index.to_i
+        num = 0xffffff & num.to_i
+        setbyte(index    , num      )
+        setbyte(index + 1, num >>  8)
+        setbyte(index + 2, num >> 16)
+      end
+
+      def loadu24le(index)
+        (getbyte(index)) |
+          (getbyte(index + 1) << 8) |
+          (getbyte(index + 2) << 16)
+      end
+
+      def loadi24le(index)
+        (getbyte(index)) |
+          (getbyte(index + 1) << 8) |
+          (getbyte(index + 2).extendsign_char << 16)
+      end
+
+      def store32(index, num)
+        setbinary(index, [num].pack("L"))
+      end
+
+      def loadi32(index)
+        byteslice(index, 4).unpack("l")[0]
+      end
+
+      def loadu32(index)
+        byteslice(index, 4).unpack("L")[0]
+      end
+
+      def store32swap(index, num)
+        setbinary(index, [num.swap32].pack("L"))
+      end
+
+      def loadi32swap(index)
+        byteslice(index, 4).unpack("l")[0].swap32s
+      end
+
+      def loadu32swap(index)
+        byteslice(index, 4).unpack("L")[0].swap32
+      end
+
+      def store32be(index, num)
+        index = index.to_i
+        num = 0xffffffff & num.to_i
+        setbyte(index    , num >> 24)
+        setbyte(index + 1, num >> 16)
+        setbyte(index + 2, num >>  8)
+        setbyte(index + 3, num & 0xff)
+      end
+
+      def loadu32be(index)
+        (getbyte(index) << 24) |
+          (getbyte(index + 1) << 16) |
+          (getbyte(index + 2) << 8) |
+          (getbyte(index + 3))
+      end
+
+      def loadi32be(index)
+        (getbyte(index).extendsign_char << 24) |
+          (getbyte(index + 1) << 16) |
+          (getbyte(index + 2) << 8) |
+          (getbyte(index + 3))
+      end
+
+      def store32le(index, num)
+        index = index.to_i
+        num = 0xffffffff & num.to_i
+        setbyte(index    , num & 0xff)
+        setbyte(index + 1, num >>  8)
+        setbyte(index + 2, num >> 16)
+        setbyte(index + 3, num >> 24)
+      end
+
+      def loadu32le(index)
+        (getbyte(index)) |
+          (getbyte(index + 1) << 8) |
+          (getbyte(index + 2) << 16) |
+          (getbyte(index + 3) << 24)
+      end
+
+      def loadi32le(index)
+        (getbyte(index)) |
+          (getbyte(index + 1) << 8) |
+          (getbyte(index + 2) << 16) |
+          (getbyte(index + 3).extendsign_char << 24)
+      end
+
+      def store48be(index, num)
+        num = num.to_i
+        store24be(index    , num >> 24)
+        store24be(index + 3, num      )
+      end
+
+      def loadu48be(index)
+        (loadu24be(index) << 24) | loadu24be(index + 3)
+      end
+
+      def loadi48be(index)
+        (loadi24be(index) << 24) | loadu24be(index + 3)
+      end
+
+      def store48le(index, num)
+        num = num.to_i
+        store24le(index    , num      )
+        store24le(index + 3, num >> 24)
+      end
+
+      def loadu48le(index)
+        loadu24le(index) | (loadu24le(index + 3) << 24)
+      end
+
+      def loadi48le(index)
+        loadu24le(index) | (loadi24le(index + 3) << 24)
+      end
+
+      def store64(index, num)
+        setbinary(index, [num].pack("Q"))
+      end
+
+      def loadi64(index)
+        byteslice(index, 8).unpack("q")[0]
+      end
+
+      def loadu64(index)
+        byteslice(index, 8).unpack("Q")[0]
+      end
+
+      def store64swap(index, num)
+        setbinary(index, [num.swap64].pack("Q"))
+      end
+
+      def loadi64swap(index)
+        byteslice(index, 8).unpack("q")[0].swap64s
+      end
+
+      def loadu64swap(index)
+        byteslice(index, 8).unpack("Q")[0].swap64
+      end
+
+      def store64be(index, num)
+        num = num.to_i
+        store32be(index    , num >> 32)
+        store32be(index + 4, num      )
+      end
+
+      def loadu64be(index)
+        (loadu32be(index) << 32) | loadu32be(index + 4)
+      end
+
+      def loadi64be(index)
+        (loadi32be(index) << 32) | loadu32be(index + 4)
+      end
+
+      def store64le(index, num)
+        num = num.to_i
+        store32le(index    , num      )
+        store32le(index + 4, num >> 32)
+      end
+
+      def loadu64le(index)
+        loadu32le(index) | (loadu32le(index + 4) << 32)
+      end
+
+      def loadi64le(index)
+        loadu32le(index) | (loadi32le(index + 4) << 32)
+      end
+
+      def storef16(index, num)
+        store16(index, num.pack_binary16)
+      end
+
+      def loadf16(index)
+        loadu16(index).unpack_binary16
+      end
+
+      def storef16swap(index, num)
+        store16swap(index, num.pack_binary16)
+      end
+
+      def loadf16swap(index)
+        loadu16swap(index).unpack_binary16
+      end
+
+      def storef16be(index, num)
+        store16be(index, num.pack_binary16)
+      end
+
+      def loadf16be(index)
+        loadu16be(index).unpack_binary16
+      end
+
+      def storef16le(index, num)
+        store16le(index, num.pack_binary16)
+      end
+
+      def loadf16le(index)
+        loadu16le(index).unpack_binary16
+      end
+
+      def storef32(index, num)
+        store32(index, num.pack_binary32)
+      end
+
+      def loadf32(index)
+        loadu32(index).unpack_binary32
+      end
+
+      def storef32swap(index, num)
+        store32swap(index, num.pack_binary32)
+      end
+
+      def loadf32swap(index)
+        loadu32swap(index).unpack_binary32
+      end
+
+      def storef32be(index, num)
+        store32be(index, num.pack_binary32)
+      end
+
+      def loadf32be(index)
+        loadu32be(index).unpack_binary32
+      end
+
+      def storef32le(index, num)
+        store32le(index, num.pack_binary32)
+      end
+
+      def loadf32le(index)
+        loadu32le(index).unpack_binary32
+      end
+
+      def storef64(index, num)
+        store64(index, num.pack_binary64)
+      end
+
+      def loadf64(index)
+        loadu64(index).unpack_binary64
+      end
+
+      def storef64swap(index, num)
+        store64swap(index, num.pack_binary64)
+      end
+
+      def loadf64swap(index)
+        loadu64swap(index).unpack_binary64
+      end
+
+      def storef64be(index, num)
+        store64be(index, num.pack_binary64)
+      end
+
+      def loadf64be(index)
+        loadu64be(index).unpack_binary64
+      end
+
+      def storef64le(index, num)
+        store64le(index, num.pack_binary64)
+      end
+
+      def loadf64le(index)
+        loadu64le(index).unpack_binary64
+      end
+
+      def store16q8(index, num)
+        store16(index, num * 256)
+      end
+
+      def loadi16q8(index)
+        loadi16(index) / 256.0
+      end
+
+      def loadu16q8(index)
+        loadu16(index) / 256.0
+      end
+
+      def store16q8swap(index, num)
+        store16swap(index, num * 256)
+      end
+
+      def loadi16q8swap(index)
+        loadi16swap(index) / 256.0
+      end
+
+      def loadu16q8swap(index)
+        loadu16swap(index) / 256.0
+      end
+
+      def store16q8be(index, num)
+        store16be(index, num * 256)
+      end
+
+      def loadi16q8be(index)
+        loadi16be(index) / 256.0
+      end
+
+      def loadu16q8be(index)
+        loadu16be(index) / 256.0
+      end
+
+      def store16q8le(index, num)
+        store16le(index, num * 256)
+      end
+
+      def loadi16q8le(index)
+        loadi16le(index) / 256.0
+      end
+
+      def loadu16q8le(index)
+        loadu16le(index) / 256.0
+      end
+
+      def store32q6(index, num)
+        store32(index, num * 64)
+      end
+
+      def loadi32q6(index)
+        loadi32(index) / 64.0
+      end
+
+      def loadu32q6(index)
+        loadu32(index) / 64.0
+      end
+
+      def store32q6swap(index, num)
+        store32swap(index, num * 64)
+      end
+
+      def loadi32q6swap(index)
+        loadi32swap(index) / 64.0
+      end
+
+      def loadu32q6swap(index)
+        loadu32swap(index) / 64.0
+      end
+
+      def store32q6be(index, num)
+        store32be(index, num * 64)
+      end
+
+      def loadi32q6be(index)
+        loadi32be(index) / 64.0
+      end
+
+      def loadu32q6be(index)
+        loadu32be(index) / 64.0
+      end
+
+      def store32q6le(index, num)
+        store32le(index, num * 64)
+      end
+
+      def loadi32q6le(index)
+        loadi32le(index) / 64.0
+      end
+
+      def loadu32q6le(index)
+        loadu32le(index) / 64.0
+      end
+
+      def store32q8(index, num)
+        store32(index, num * 256)
+      end
+
+      def loadi32q8(index)
+        loadi32(index) / 256.0
+      end
+
+      def loadu32q8(index)
+        loadu32(index) / 256.0
+      end
+
+      def store32q8swap(index, num)
+        store32swap(index, num * 256)
+      end
+
+      def loadi32q8swap(index)
+        loadi32swap(index) / 256.0
+      end
+
+      def loadu32q8swap(index)
+        loadu32swap(index) / 256.0
+      end
+
+      def store32q8be(index, num)
+        store32be(index, num * 256)
+      end
+
+      def loadi32q8be(index)
+        loadi32be(index) / 256.0
+      end
+
+      def loadu32q8be(index)
+        loadu32be(index) / 256.0
+      end
+
+      def store32q8le(index, num)
+        store32le(index, num * 256)
+      end
+
+      def loadi32q8le(index)
+        loadi32le(index) / 256.0
+      end
+
+      def loadu32q8le(index)
+        loadu32le(index) / 256.0
+      end
+
+      def store32q12(index, num)
+        store32(index, num * 4096)
+      end
+
+      def loadi32q12(index)
+        loadi32(index) / 4096.0
+      end
+
+      def loadu32q12(index)
+        loadu32(index) / 4096.0
+      end
+
+      def store32q12swap(index, num)
+        store32swap(index, num * 4096)
+      end
+
+      def loadi32q12swap(index)
+        loadi32swap(index) / 4096.0
+      end
+
+      def loadu32q12swap(index)
+        loadu32swap(index) / 4096.0
+      end
+
+      def store32q12be(index, num)
+        store32be(index, num * 4096)
+      end
+
+      def loadi32q12be(index)
+        loadi32be(index) / 4096.0
+      end
+
+      def loadu32q12be(index)
+        loadu32be(index) / 4096.0
+      end
+
+      def store32q12le(index, num)
+        store32le(index, num * 4096)
+      end
+
+      def loadi32q12le(index)
+        loadi32le(index) / 4096.0
+      end
+
+      def loadu32q12le(index)
+        loadu32le(index) / 4096.0
+      end
+
+      def store32q16(index, num)
+        store32(index, num * 65536)
+      end
+
+      def loadi32q16(index)
+        loadi32(index) / 65536.0
+      end
+
+      def loadu32q16(index)
+        loadu32(index) / 65536.0
+      end
+
+      def store32q16swap(index, num)
+        store32swap(index, num * 65536)
+      end
+
+      def loadi32q16swap(index)
+        loadi32swap(index) / 65536.0
+      end
+
+      def loadu32q16swap(index)
+        loadu32swap(index) / 65536.0
+      end
+
+      def store32q16be(index, num)
+        store32be(index, num * 65536)
+      end
+
+      def loadi32q16be(index)
+        loadi32be(index) / 65536.0
+      end
+
+      def loadu32q16be(index)
+        loadu32be(index) / 65536.0
+      end
+
+      def store32q16le(index, num)
+        store32le(index, num * 65536)
+      end
+
+      def loadi32q16le(index)
+        loadi32le(index) / 65536.0
+      end
+
+      def loadu32q16le(index)
+        loadu32le(index) / 65536.0
+      end
+
+      def store32q24(index, num)
+        store32(index, num * 16777216)
+      end
+
+      def loadi32q24(index)
+        loadi32(index) / 16777216.0
+      end
+
+      def loadu32q24(index)
+        loadu32(index) / 16777216.0
+      end
+
+      def store32q24swap(index, num)
+        store32swap(index, num * 16777216)
+      end
+
+      def loadi32q24swap(index)
+        loadi32swap(index) / 16777216.0
+      end
+
+      def loadu32q24swap(index)
+        loadu32swap(index) / 16777216.0
+      end
+
+      def store32q24be(index, num)
+        store32be(index, num * 16777216)
+      end
+
+      def loadi32q24be(index)
+        loadi32be(index) / 16777216.0
+      end
+
+      def loadu32q24be(index)
+        loadu32be(index) / 16777216.0
+      end
+
+      def store32q24le(index, num)
+        store32le(index, num * 16777216)
+      end
+
+      def loadi32q24le(index)
+        loadi32le(index) / 16777216.0
+      end
+
+      def loadu32q24le(index)
+        loadu32le(index) / 16777216.0
+      end
+
+
+      def store_char(index, num)
+        setbinary(index, [num].pack("S!"))
+      end
+
+      def load_char(index)
+        byteslice(index, TypeSpec::SIZEOF_CHAR).unpack("c!")[0]
+      end
+
+      def load_uchar(index)
+        byteslice(index, TypeSpec::SIZEOF_CHAR).unpack("C!")[0]
+      end
+
+      def store_short(index, num)
+        setbinary(index, [num].pack("S!"))
+      end
+
+      def load_short(index)
+        byteslice(index, TypeSpec::SIZEOF_SHORT).unpack("s!")[0]
+      end
+
+      def load_ushort(index)
+        byteslice(index, TypeSpec::SIZEOF_SHORT).unpack("S!")[0]
+      end
+
+      def store_int(index, num)
+        setbinary(index, [num].pack("I!"))
+      end
+
+      def load_int(index)
+        byteslice(index, TypeSpec::SIZEOF_INT).unpack("i!")[0]
+      end
+
+      def load_uint(index)
+        byteslice(index, TypeSpec::SIZEOF_INT).unpack("I!")[0]
+      end
+
+      def store_long(index, num)
+        setbinary(index, [num].pack("L!"))
+      end
+
+      def load_long(index)
+        byteslice(index, TypeSpec::SIZEOF_LONG).unpack("l!")[0]
+      end
+
+      def load_ulong(index)
+        byteslice(index, TypeSpec::SIZEOF_LONG).unpack("L!")[0]
+      end
+
+      def store_longlong(index, num)
+        setbinary(index, [num].pack("Q"))
+      end
+
+      def load_longlong(index)
+        byteslice(index, TypeSpec::SIZEOF_LONGLONG).unpack("q")[0]
+      end
+
+      def load_ulonglong(index)
+        byteslice(index, TypeSpec::SIZEOF_LONGLONG).unpack("Q")[0]
+      end
+
+      def store_float(index, num)
+        setbinary(index, [num].pack("f"))
+      end
+
+      def load_float(index)
+        byteslice(index, TypeSpec::SIZEOF_FLOAT).unpack("f")[0]
+      end
+
+      def store_double(index, num)
+        setbinary(index, [num].pack("d"))
+      end
+
+      def load_double(index)
+        byteslice(index, TypeSpec::SIZEOF_DOUBLE).unpack("d")[0]
+      end
+
+
+      case "\0\1\2\3".unpack("I")[0]
+      when 0x00010203 # big endian (network byte order)
+        alias store storebe
+        alias loadi loadibe
+        alias loadu loadube
+
+        alias storeswap storele
+        alias loadiswap loadile
+        alias loaduswap loadule
+      when 0x03020100 # little endian (vax byte order)
+        alias store storele
+        alias loadi loadile
+        alias loadu loadule
+
+        alias storeswap storebe
+        alias loadiswap loadibe
+        alias loaduswap loadube
+      else
+        # any byte order...
+      end
+
+      case TypeSpec::SIZEOF_SIZE_T
+      when TypeSpec::SIZEOF_LONGLONG
+        alias store_sizet store_longlong
+        alias load_sizet load_ulonglong
+        alias load_ssizet load_longlong
+      when TypeSpec::SIZEOF_LONG
+        alias store_sizet store_long
+        alias load_sizet load_ulong
+        alias load_ssizet load_long
+      when TypeSpec::SIZEOF_INT
+        alias store_sizet store_int
+        alias load_sizet load_uint
+        alias load_ssizet load_int
+      else
+        def store_sizet(o, v)
+          raise NotImplementedError, "unsupported system (expected sizeof(void *) to 4 or 8, but #{TypeSpec::SIZEOF_SIZE_T})"
+        end
+
+        def load_ssizet(o)
+          raise NotImplementedError, "unsupported system (expected sizeof(void *) to 4 or 8, but #{TypeSpec::SIZEOF_SIZE_T})"
+        end
+
+        def load_sizet(o)
+          raise NotImplementedError, "unsupported system (expected sizeof(void *) to 4 or 8, but #{TypeSpec::SIZEOF_SIZE_T})"
+        end
+      end
+    end
+  end
+end