gogyou 0.2.3 → 0.2.4

data/test/test_loadstore.rb

@@ -0,0 +1,65 @@
+#!ruby
+
+require "test-unit"
+require "gogyou"
+
+class TestLoadStore < Test::Unit::TestCase
+  @@str = [0, 0, 0, 0, 0, 0, 0, 0, 160, 164, 221, 186, 248, 213, 191, 215, 137, 242, 225, 169, 153, 224, 148, 134].pack("C*")
+
+  def test_load
+    16.times do |i|
+      assert_equal @@str.unpack("@#{i}C")[0], @@str.loadu8(i)
+      assert_equal @@str.unpack("@#{i}S")[0], @@str.loadu16(i)
+      assert_equal @@str.unpack("@#{i}L")[0], @@str.loadu32(i)
+      assert_equal @@str.unpack("@#{i}Q")[0], @@str.loadu64(i)
+      assert_equal @@str.unpack("@#{i}c")[0], @@str.loadi8(i)
+      assert_equal @@str.unpack("@#{i}s")[0], @@str.loadi16(i)
+      assert_equal @@str.unpack("@#{i}l")[0], @@str.loadi32(i)
+      assert_equal @@str.unpack("@#{i}q")[0], @@str.loadi64(i)
+      assert_equal @@str.unpack("@#{i}s!")[0], @@str.load_short(i)
+      assert_equal @@str.unpack("@#{i}i!")[0], @@str.load_int(i)
+      assert_equal @@str.unpack("@#{i}l!")[0], @@str.load_long(i)
+      assert_equal @@str.unpack("@#{i}q")[0], @@str.load_longlong(i)
+      assert_equal @@str.unpack("@#{i}S!")[0], @@str.load_ushort(i)
+      assert_equal @@str.unpack("@#{i}I!")[0], @@str.load_uint(i)
+      assert_equal @@str.unpack("@#{i}L!")[0], @@str.load_ulong(i)
+      assert_equal @@str.unpack("@#{i}Q")[0], @@str.load_ulonglong(i)
+      assert_equal @@str.unpack("@#{i}f")[0], @@str.loadf32(i)
+      assert_equal @@str.unpack("@#{i}d")[0], @@str.loadf64(i)
+      assert_equal @@str.unpack("@#{i}n")[0].unpack_binary16, @@str.loadf16be(i)
+      assert_equal @@str.unpack("@#{i}N")[0].unpack_binary32, @@str.loadf32be(i)
+      assert_equal @@str.unpack("@#{i}Q>")[0].unpack_binary64, @@str.loadf64be(i)
+      assert_equal @@str.unpack("@#{i}v")[0].unpack_binary16, @@str.loadf16le(i)
+      assert_equal @@str.unpack("@#{i}V")[0].unpack_binary32, @@str.loadf32le(i)
+      assert_equal @@str.unpack("@#{i}Q<")[0].unpack_binary64, @@str.loadf64le(i)
+    end
+  end
+end
+
+class TestSwap < Test::Unit::TestCase
+  def test_swap
+    assert_equal 0x0011, 0x1100.swap16
+    assert_equal 0x001122, 0x221100.swap24
+    assert_equal 0x00112233, 0x33221100.swap32
+    assert_equal 0x001122334455, 0x554433221100.swap48
+    assert_equal 0x0011223344556677, 0x7766554433221100.swap64
+
+    assert_equal 0xffee, 0xeeff.swap16
+    assert_equal 0xffeedd, 0xddeeff.swap24
+    assert_equal 0xffeeddcc, 0xccddeeff.swap32
+    assert_equal 0xffeeddccbbaa, 0xaabbccddeeff.swap48
+    assert_equal 0xffeeddccbbaa9988, 0x8899aabbccddeeff.swap64
+
+    assert_equal 0x0011, 0x1100.swap16s
+    assert_equal 0x001122, 0x221100.swap24s
+    assert_equal 0x00112233, 0x33221100.swap32s
+    assert_equal 0x001122334455, 0x554433221100.swap48s
+    assert_equal 0x0011223344556677, 0x7766554433221100.swap64s
+
+    assert_equal ~0x0011, 0xeeff.swap16s
+    assert_equal ~0x001122, 0xddeeff.swap24s
+    assert_equal ~0x00112233, 0xccddeeff.swap32s
+    assert_equal ~0x001122334455, 0xaabbccddeeff.swap48s
+    assert_equal ~0x0011223344556677, 0x8899aabbccddeeff.swap64s
+  end
+end

data/test/test_packbin.rb

@@ -0,0 +1,65 @@
+#!ruby
+
+require "test-unit"
+require "gogyou"
+
+class TestBinaryPacker < Test::Unit::TestCase
+  def test_pack_binary16
+    assert_equal 0x0000, 0.0.pack_binary16
+    assert_equal 0x8000, -0.0.pack_binary16
+    assert_equal 0x3800, 0.5.pack_binary16
+    assert_equal 0x3c00, 1.0.pack_binary16
+    assert_equal 0x4000, 2.0.pack_binary16
+    assert_equal 0x7c00, (+Float::INFINITY).pack_binary16
+    assert_equal 0xfc00, (-Float::INFINITY).pack_binary16
+    assert_equal 0x7e00, Float::NAN.pack_binary16
+    assert_equal 0x7c00, 65536.pack_binary16 # infinity
+  end
+
+  def test_unpack_binary16
+    assert_equal +Float::INFINITY, 0x7c00.unpack_binary16
+    assert_equal -Float::INFINITY, 0xfc00.unpack_binary16
+    assert_equal "NaN", 0x7e00.unpack_binary16.to_s
+    assert_equal "NaN", 0xfe00.unpack_binary16.to_s
+    assert_equal "-0.0", 0x8000.unpack_binary16.to_s
+    assert_equal 0.0, 0x0000.unpack_binary16
+    assert_equal 0.5, 0x3800.unpack_binary16
+    assert_equal 1.0, 0x3c00.unpack_binary16
+    assert_equal 2.0, 0x4000.unpack_binary16
+    assert_equal 0x07ff / 0x0400.to_f, 0x3fff.unpack_binary16
+  end
+
+  def test_unpack_binary32
+    assert_equal +Float::INFINITY, 0x7f800000.unpack_binary32
+    assert_equal -Float::INFINITY, 0xff800000.unpack_binary32
+    assert_equal "NaN", 0x7fc00000.unpack_binary32.to_s
+    assert_equal "NaN", 0xffc00000.unpack_binary32.to_s
+    assert_equal "-0.0", 0x80000000.unpack_binary32.to_s
+    assert_equal 0.0, 0x00000000.unpack_binary32
+    assert_equal 0.5, 0x3f000000.unpack_binary32
+    assert_equal 1.0, 0x3f800000.unpack_binary32
+    assert_equal 2.0, 0x40000000.unpack_binary32
+    assert_equal 0x00ffffff / 0x00800000.to_f, 0x3fffffff.unpack_binary32
+  end
+
+  def test_unpack_binary64
+    assert_equal +Float::INFINITY, 0x7ff0000000000000.unpack_binary64
+    assert_equal -Float::INFINITY, 0xfff0000000000000.unpack_binary64
+    assert_equal "NaN", 0x7ff8000000000000.unpack_binary64.to_s
+    assert_equal "NaN", 0xfff8000000000000.unpack_binary64.to_s
+    assert_equal "-0.0", 0x8000000000000000.unpack_binary64.to_s
+    assert_equal 0.0, 0x0000000000000000.unpack_binary64
+    assert_equal 0.5, 0x3fe0000000000000.unpack_binary64
+    assert_equal 1.0, 0x3ff0000000000000.unpack_binary64
+    assert_equal 2.0, 0x4000000000000000.unpack_binary64
+  end
+
+  def test_pack_and_unpack_32
+    200.times do
+      n = [rand].pack("g").unpack("g")[0]
+      assert_equal n, [n].pack("g").unpack("N")[0].unpack_binary32
+      n = [1 / n].pack("g").unpack("g")[0]
+      assert_equal n, [n].pack("g").unpack("N")[0].unpack_binary32
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gogyou
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors:
 - dearblue
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-17 00:00:00.000000000 Z
+date: 2015-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -48,7 +48,7 @@ description: |
   * Available const field.
   * Available packed field.
   * Available user definition types.
-email: dearblue@users.sourceforge.jp
+email: dearblue@users.osdn.me
 executables: []
 extensions: []
 extra_rdoc_files:
@@ -57,7 +57,10 @@ extra_rdoc_files:
 - README.md
 - lib/gogyou.rb
 - lib/gogyou/accessor.rb
-- lib/gogyou/mixin.rb
+- lib/gogyou/bytearray.rb
+- lib/gogyou/extensions.rb
+- lib/gogyou/ffi.rb
+- lib/gogyou/fiddle.rb
 - lib/gogyou/model.rb
 - lib/gogyou/primitives.rb
 - lib/gogyou/typespec.rb
@@ -70,19 +73,28 @@ files:
 - gemstub.rb
 - lib/gogyou.rb
 - lib/gogyou/accessor.rb
-- lib/gogyou/mixin.rb
+- lib/gogyou/bytearray.rb
+- lib/gogyou/extensions.rb
+- lib/gogyou/ffi.rb
+- lib/gogyou/fiddle.rb
 - lib/gogyou/model.rb
 - lib/gogyou/primitives.rb
 - lib/gogyou/typespec.rb
 - lib/gogyou/version.rb
 - mkprims.rb
 - spec/gogyou_spec.rb
-homepage: http://sourceforge.jp/projects/rutsubo/
+- test/test_loadstore.rb
+- test/test_packbin.rb
+homepage: https://osdn.jp/projects/rutsubo/
 licenses:
 - 2-clause BSD License
 metadata: {}
 post_install_message: 
-rdoc_options: []
+rdoc_options:
+- "--charset"
+- UTF-8
+- "-m"
+- README.md
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
@@ -97,8 +109,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: binary data operation library with the C liked struct and union
 test_files: []
+has_rdoc: 

data/lib/gogyou/mixin.rb

@@ -1,640 +0,0 @@
-#vim set fileencoding:utf-8
-
-require_relative "typespec"
-
-module Gogyou
-  module Extensions
-    module Object
-      module Mixin
-        def infect_from(*obj)
-          obj.each { |o| taint if o.tainted? }
-          self
-        end
-      end
-    end
-
-    class ::Object
-      extend Gogyou::Extensions::Object
-      include Gogyou::Extensions::Object::Mixin
-    end
-
-    UNIT_B   = 1 << 0
-    UNIT_KiB = 1 << 10
-    UNIT_MiB = 1 << 20
-    UNIT_GiB = 1 << 30
-    UNIT_TiB = 1 << 40
-    UNIT_PiB = 1 << 50
-    UNIT_EiB = 1 << 60
-    UNIT_ZiB = 1 << 70
-    UNIT_YiB = 1 << 80
-
-    module Numeric
-      module Mixin
-        def B
-          UNIT_B * self
-        end
-
-        def KiB
-          UNIT_KiB * self
-        end
-
-        def MiB
-          UNIT_MiB * self
-        end
-
-        def GiB
-          UNIT_GiB * self
-        end
-
-        def TiB
-          UNIT_TiB * self
-        end
-
-        def PiB
-          UNIT_PiB * self
-        end
-
-        def EiB
-          UNIT_EiB * self
-        end
-
-        def ZiB
-          UNIT_ZiB * self
-        end
-
-        def YiB
-          UNIT_YiB * self
-        end
-
-        def unit_floor(unit)
-          (self / unit).to_i
-        end
-
-        def unit_ceil(unit)
-          ((self + (unit - 1)) / unit).to_i
-        end
-
-        def align_floor(unit)
-          ((self / unit).to_i * unit).to_i
-        end
-
-        def align_ceil(unit)
-          (((self + (unit - 1)) / unit).to_i * unit).to_i
-        end
-      end
-    end
-
-    class ::Numeric
-      extend Gogyou::Extensions::Numeric
-      include Gogyou::Extensions::Numeric::Mixin
-    end
-
-    module Integer
-      module_function
-      def bitmask(shift, bits)
-        ~(~0 << bits) << shift
-      end
-
-      public_class_method :bitmask
-
-      module Mixin
-        def getbit(shift, bits)
-          (self >> shift) & Integer.bitmask(0, bits)
-        end
-
-        def getbits(shift, bits)
-          getbit(shift, bits).extendsign(bits)
-        end
-
-        def getbitset(*bitsize)
-          shift = 0
-          list = []
-          bitsize.each do |bits|
-            if bits > 0
-              list << getbit(shift, bits)
-              shift += bits
-            else
-              list << 0
-            end
-          end
-          list
-        end
-
-        def setbit(shift, bits, num)
-          mask = Integer.bitmask(shift, bits)
-          (self & ~mask) | ((num << shift) & mask)
-        end
-
-        def extendsign(bits)
-          n = self & Integer.bitmask(0, bits)
-          if (n >> (bits - 1)) == 0
-            n
-          else
-            n | (~0 << bits)
-          end
-        end
-
-        def swapbyte(bytesize)
-          num = 0
-          bytesize.times do |i|
-            num <<= 8
-            num |= (self >> (i * 8)) & 0xff
-          end
-          num
-        end
-
-        def swap16
-          ((self >> 8) & 0xff) | ((self & 0xff) << 8)
-        end
-
-        def swap24
-          ((self >> 16) & 0xff) |
-            (self & 0xff00) |
-            ((self & 0xff) << 16)
-        end
-
-        def swap32
-          ((self >> 24) & 0xff) |
-            ((self >> 8) & 0xff00) |
-            ((self & 0xff00) << 8) |
-            ((self & 0xff) << 24)
-        end
-
-        def swap48
-          ((self >> 40) & 0xff) |
-            ((self >> 24) & 0xff00) |
-            ((self >> 8) & 0xff0000) |
-            ((self & 0xff0000) << 8) |
-            ((self & 0xff00) << 24) |
-            ((self & 0xff) << 40)
-        end
-
-        def swap64
-          ((self >> 56) & 0xff) |
-            ((self >> 40) & 0xff00) |
-            ((self >> 24) & 0xff0000) |
-            ((self >> 8) & 0xff000000) |
-            ((self & 0xff000000) << 8) |
-            ((self & 0xff0000) << 24) |
-            ((self & 0xff00) << 40) |
-            ((self & 0xff) << 56)
-        end
-      end
-    end
-
-    class ::Integer
-      extend Gogyou::Extensions::Integer
-      include Gogyou::Extensions::Integer::Mixin
-    end
-
-    module String
-      BITS_PER_BYTE = 8
-
-      module_function
-      def alloc(bytesize)
-        ?\0.force_encoding(Encoding::BINARY) * bytesize
-      end
-
-      public :alloc
-
-      ZERO_BUFFER = alloc(64.KiB).freeze
-
-      module Mixin
-        def to_ptr
-          [self].pack("p").load_sizet(0)
-        end
-
-        def binary_operation
-          enc = encoding
-          force_encoding(Encoding::BINARY) rescue (enc = nil; raise)
-          yield
-        ensure
-          force_encoding(enc) rescue nil if enc
-        end
-
-        def resize(newsize)
-          binary_operation do
-            left = newsize - bytesize
-            case
-            when left > 0
-              while left >= ZERO_BUFFER.bytesize
-                concat(ZERO_BUFFER)
-                left -= ZERO_BUFFER.bytesize
-              end
-              concat(ZERO_BUFFER[ZERO_BUFFER.bytesize - left, left]) # make shared string
-            when left < 0
-              left = - left
-              self[bytesize - left, left] = ""
-            end
-          end
-
-          self
-        end
-
-        def setbinary(index, str, offset = 0, bytesize = str.bytesize)
-          offset = offset.to_i
-          bytesize = bytesize.to_i
-          size1 = str.bytesize - offset
-          bytesize = size1 if bytesize > size1
-          if bytesize > 0
-            binary_operation do
-              self[index.to_i, bytesize] = str.byteslice(offset, bytesize)
-            end
-          end
-
-          self
-        end
-
-        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 loadu8(index)
-          getbyte(index)
-        end
-
-        def loadi8(index)
-          getbyte(index).extendsign(8)
-        end
-
-        def loadu16be(index)
-          (getbyte(index) << 8) | getbyte(index + 1)
-        end
-
-        def loadi16be(index)
-          loadu16be(index).extendsign(16)
-        end
-
-        def loadu16le(index)
-          getbyte(index) | (getbyte(index + 1) << 8)
-        end
-
-        def loadi16le(index)
-          loadu16le(index).extendsign(16)
-        end
-
-        def loadu24be(index)
-          (getbyte(index) << 16) | (getbyte(index + 1) << 8) | getbyte(index + 2)
-        end
-
-        def loadi24be(index)
-          loadu24be(index).extendsign(24)
-        end
-
-        def loadu24le(index)
-          getbyte(index) | (getbyte(index + 1) << 8) | (getbyte(index + 2) << 16)
-        end
-
-        def loadi24le(index)
-          loadu24le(index).extendsign(24)
-        end
-
-        def loadu32be(index)
-          (getbyte(index) << 24) | (getbyte(index + 1) << 16) | (getbyte(index + 2) << 8) | getbyte(index + 3)
-        end
-
-        def loadi32be(index)
-          loadu32be(index).extendsign(32)
-        end
-
-        def loadu32le(index)
-          getbyte(index) | (getbyte(index + 1) << 8) | (getbyte(index + 2) << 16) | (getbyte(index + 3) << 24)
-        end
-
-        def loadi32le(index)
-          loadu32le(index).extendsign(32)
-        end
-
-        def loadu48be(index)
-          (loadu24be(index) << 24) | loadu24be(index + 3)
-        end
-
-        def loadi48be(index)
-          loadu48be(index).extendsign(48)
-        end
-
-        def loadu48le(index)
-          loadu24le(index) | (loadu24le(index + 3) << 24)
-        end
-
-        def loadi48le(index)
-          loadu48le(index).extendsign(48)
-        end
-
-        def loadu64be(index)
-          (loadu32be(index) << 32) | loadu32be(index + 4)
-        end
-
-        def loadi64be(index)
-          loadu64be(index).extendsign(64)
-        end
-
-        def loadu64le(index)
-          loadu32le(index) | (loadu32le(index + 4) << 32)
-        end
-
-        def loadi64le(index)
-          loadu64le(index).extendsign(64)
-        end
-
-        def loadf32be(index)
-          unpack("@#{index.to_i}g")[0]
-        end
-
-        def loadf32le(index)
-          unpack("@#{index.to_i}e")[0]
-        end
-
-        def loadf64be(index)
-          unpack("@#{index.to_i}G")[0]
-        end
-
-        def loadf64le(index)
-          unpack("@#{index.to_i}E")[0]
-        end
-
-        def store8(index, num)
-          setbyte(index.to_i, num.to_i & 0xff)
-        end
-
-        def store16be(index, num)
-          store8(index, num >> 8)
-          store8(index + 1, num)
-        end
-
-        def store16le(index, num)
-          store8(index, num)
-          store8(index + 1, num >> 8)
-        end
-
-        def store24be(index, num)
-          store8(index, num >> 16)
-          store8(index + 1, num >> 8)
-          store8(index + 2, num)
-        end
-
-        def store24le(index, num)
-          store8(index, num)
-          store8(index + 1, num >> 8)
-          store8(index + 2, num >> 16)
-        end
-
-        def store32be(index, num)
-          store8(index, num >> 24)
-          store8(index + 1, num >> 16)
-          store8(index + 2, num >> 8)
-          store8(index + 3, num)
-        end
-
-        def store32le(index, num)
-          store8(index, num)
-          store8(index + 1, num >> 8)
-          store8(index + 2, num >> 16)
-          store8(index + 3, num >> 24)
-        end
-
-        def store48be(index, num)
-          store24be(index, num >> 24)
-          store24be(index + 3, num)
-        end
-
-        def store48le(index, num)
-          store24le(index, num)
-          store24le(index + 3, num >> 24)
-        end
-
-        def store64be(index, num)
-          store32be(index, num >> 32)
-          store32be(index + 4, num)
-        end
-
-        def store64le(index, num)
-          store32le(index, num)
-          store32le(index + 4, num >> 32)
-        end
-
-        def storef32be(index, num)
-          setbinary(index, [num].pack("g"))
-        end
-
-        def storef32le(index, num)
-          setbinary(index, [num].pack("e"))
-        end
-
-        def storef64be(index, num)
-          setbinary(index, [num].pack("G"))
-        end
-
-        def storef64le(index, num)
-          setbinary(index, [num].pack("E"))
-        end
-
-        #---
-        ## native byte order operations
-        #+++
-
-        def loadf32(index)
-          unpack("@#{index.to_i}f")[0]
-        end
-
-        def loadf64(index)
-          unpack("@#{index.to_i}d")[0]
-        end
-
-        def storef32(index, num)
-          setbinary(index, [num].pack("f"))
-        end
-
-        def storef64(index, num)
-          setbinary(index, [num].pack("d"))
-        end
-
-        case "\0\1\2\3".unpack("I")[0]
-        when 0x00010203 # big endian (network byte order)
-          alias store storebe
-          alias store16 store16be
-          alias store24 store24be
-          alias store32 store32be
-          alias store48 store48be
-          alias store64 store64be
-          alias loadi loadibe
-          alias loadi16 loadi16be
-          alias loadi24 loadi24be
-          alias loadi32 loadi32be
-          alias loadi48 loadi48be
-          alias loadi64 loadi64be
-          alias loadu loadube
-          alias loadu16 loadu16be
-          alias loadu24 loadu24be
-          alias loadu32 loadu32be
-          alias loadu48 loadu48be
-          alias loadu64 loadu64be
-
-          alias storeswap storele
-          alias store16swap store16le
-          alias store24swap store24le
-          alias store32swap store32le
-          alias store48swap store48le
-          alias store64swap store64le
-          alias loadiswap loadile
-          alias loadi16swap loadi16le
-          alias loadi24swap loadi24le
-          alias loadi32swap loadi32le
-          alias loadi48swap loadi48le
-          alias loadi64swap loadi64le
-          alias loaduswap loadule
-          alias loadu16swap loadu16le
-          alias loadu24swap loadu24le
-          alias loadu32swap loadu32le
-          alias loadu48swap loadu48le
-          alias loadu64swap loadu64le
-          alias loadf32swap loadf32le
-          alias loadf64swap loadf64le
-        when 0x03020100 # little endian (vax byte order)
-          alias store storele
-          alias store16 store16le
-          alias store24 store24le
-          alias store32 store32le
-          alias store48 store48le
-          alias store64 store64le
-          alias loadi loadile
-          alias loadi16 loadi16le
-          alias loadi24 loadi24le
-          alias loadi32 loadi32le
-          alias loadi48 loadi48le
-          alias loadi64 loadi64le
-          alias loadu loadule
-          alias loadu16 loadu16le
-          alias loadu24 loadu24le
-          alias loadu32 loadu32le
-          alias loadu48 loadu48le
-          alias loadu64 loadu64le
-
-          alias storeswap storebe
-          alias store16swap store16be
-          alias store24swap store24be
-          alias store32swap store32be
-          alias store48swap store48be
-          alias store64swap store64be
-          alias loadiswap loadibe
-          alias loadi16swap loadi16be
-          alias loadi24swap loadi24be
-          alias loadi32swap loadi32be
-          alias loadi48swap loadi48be
-          alias loadi64swap loadi64be
-          alias loaduswap loadube
-          alias loadu16swap loadu16be
-          alias loadu24swap loadu24be
-          alias loadu32swap loadu32be
-          alias loadu48swap loadu48be
-          alias loadu64swap loadu64be
-          alias loadf32swap loadf32be
-          alias loadf64swap loadf64be
-        else
-          raise NotImplementedError
-        end
-
-        case TypeSpec::SIZEOF_SIZE_T
-        when 4
-          alias store_sizet store32
-          alias load_sizet loadu32
-          alias load_ssizet loadi32
-        when 8
-          alias store_sizet store64
-          alias load_sizet loadu64
-          alias load_ssizet loadi64
-        else
-          raise NotImplementedError
-        end
-
-        case TypeSpec::SIZEOF_LONG
-        when 4
-          alias store_long store32
-          alias load_long loadi32
-          alias load_ulong loadu32
-        when 8
-          alias store_long store64
-          alias load_long loadi64
-          alias load_ulong loadu64
-        else
-          raise NotImplementedError
-        end
-      end
-    end
-
-    class ::String
-      extend Gogyou::Extensions::String
-      include Gogyou::Extensions::String::Mixin
-    end
-  end
-end