gogyou 0.2.3 → 0.2.4

data/lib/gogyou/ffi.rb

@@ -0,0 +1,52 @@
+require "ffi"
+require_relative "../gogyou"
+
+module Gogyou
+  module Extensions
+    module FFI
+      module AbstractMemory
+        def to_address
+          to_i
+        end
+
+        alias to_ptr to_address
+
+        def bytesize
+          size
+        end
+
+        def setbinary(index, mem, offset = 0, size = mem.bytesize - offset)
+          offset = offset.to_i
+          size = size.to_i
+          size1 = mem.bytesize - offset
+          size = size1 if size > size1
+
+          if size > 0
+            put_bytes(index, mem.byteslice(offset, size))
+          end
+
+          self
+        end
+
+        def byteslice(index, size)
+          get_bytes(index, size)
+        end
+
+        def setbyte(o, n)
+          set_uint8(o, n)
+        end
+
+        def getbyte(o)
+          get_uint8(o)
+        end
+      end
+    end
+  end
+end
+
+module FFI
+  class AbstractMemory
+    include Gogyou::Extensions::FFI::AbstractMemory
+    include Gogyou::Extensions::ByteArray
+  end
+end

data/lib/gogyou/fiddle.rb

@@ -0,0 +1,53 @@
+require "fiddle"
+require_relative "../gogyou"
+
+module Gogyou
+  module Extensions
+    module Fiddle
+      module Pointer
+        def to_address
+          to_i
+        end
+
+        alias to_ptr to_address
+
+        def bytesize
+          size
+        end
+
+        def setbinary(index, mem, offset = 0, size = mem.bytesize - offset)
+          offset = offset.to_i
+          size = size.to_i
+          size1 = mem.bytesize - offset
+          size = size1 if size > size1
+
+          if size > 0
+            self[index, size] = mem.byteslice(offset, size)
+          end
+
+          self
+        end
+
+        def byteslice(index, size)
+          return nil unless index < bytesize
+          self[index, size]
+        end
+
+        def setbyte(o, n)
+          self[o] = 0xff & n.to_i
+        end
+
+        def getbyte(o)
+          0xff & self[o]
+        end
+      end
+    end
+  end
+end
+
+module Fiddle
+  class Pointer
+    include Gogyou::Extensions::Fiddle::Pointer
+    include Gogyou::Extensions::ByteArray
+  end
+end

data/lib/gogyou/primitives.rb

@@ -5,43 +5,43 @@
 require_relative "typespec"
 
 module Gogyou
-  module Primitives
-    class Primitive < ::Struct.new(:name, :bytesize, :bytealign)
-      BasicStruct = superclass
+  class Primitive < ::Struct.new(:name, :bytesize, :bytealign)
+    BasicStruct = superclass
 
-      undef :name=, :bytesize=, :bytealign=
+    undef :name=, :bytesize=, :bytealign=
 
-      def initialize(name, bytesize, bytealign, aset, aref)
-        super(name.intern, bytesize.to_i, bytealign.to_i)
-        define_singleton_method(:aset, aset)
-        define_singleton_method(:aref, aref)
-      end
+    def initialize(name, bytesize, bytealign, aset, aref)
+      super(name.intern, bytesize.to_i, bytealign.to_i)
+      define_singleton_method(:aset, aset)
+      define_singleton_method(:aref, aref)
+    end
 
-      def extensible?
-        false
-      end
+    def extensible?
+      false
+    end
 
-      def to_s
-        "\#<#{self.class}:#{name} bytesize=#{bytesize.inspect}, bytealign=#{bytealign.inspect}>"
-      end
+    def to_s
+      "\#<#{self.class}:#{name} bytesize=#{bytesize.inspect}, bytealign=#{bytealign.inspect}>"
+    end
 
-      alias inspect to_s
+    alias inspect to_s
 
-      def pretty_print(q)
-        #name, bytesize, bytealign
-        q.group(1, "\#<#{self.class}:#{name}") do
-          q.breakable " "
-          q.text "bytesize="
-          q.pp bytesize
-          q.text ","
-          q.breakable " "
-          q.text "bytealign="
-          q.pp bytealign
-        end
-        q.text ">"
+    def pretty_print(q)
+      #name, bytesize, bytealign
+      q.group(1, "\#<#{self.class}:#{name}") do
+        q.breakable " "
+        q.text "bytesize="
+        q.pp bytesize
+        q.text ","
+        q.breakable " "
+        q.text "bytealign="
+        q.pp bytealign
       end
+      q.text ">"
     end
+  end
 
+  module Primitives
     SIZE_T    = Primitive[:size_t, TypeSpec::SIZEOF_SIZE_T, TypeSpec::SIZEOF_SIZE_T,
                           ->(buf, offset, num) { buf.store_sizet(offset, num) },
                           ->(buf, offset) { buf.load_sizet(offset) }].freeze
@@ -162,36 +162,36 @@ module Gogyou
     UCHAR     = Primitive[:uchar, 1, 1,
                           ->(buf, offset, num) { buf.store8(offset, num) },
                           ->(buf, offset) { buf.loadu8(offset) }].freeze
-    SHORT     = Primitive[:short, 2, 2,
-                          ->(buf, offset, num) { buf.store16(offset, num) },
-                          ->(buf, offset) { buf.loadi16(offset) }].freeze
-    USHORT    = Primitive[:ushort, 2, 2,
-                          ->(buf, offset, num) { buf.store16(offset, num) },
-                          ->(buf, offset) { buf.loadu16(offset) }].freeze
-    INT       = Primitive[:int, 4, 4,
-                          ->(buf, offset, num) { buf.store32(offset, num) },
-                          ->(buf, offset) { buf.loadi32(offset) }].freeze
-    UINT      = Primitive[:uint, 4, 4,
-                          ->(buf, offset, num) { buf.store32(offset, num) },
-                          ->(buf, offset) { buf.loadu32(offset) }].freeze
+    SHORT     = Primitive[:short, TypeSpec::SIZEOF_SHORT, TypeSpec::SIZEOF_SHORT,
+                          ->(buf, offset, num) { buf.store_short(offset, num) },
+                          ->(buf, offset) { buf.load_short(offset) }].freeze
+    USHORT    = Primitive[:ushort, TypeSpec::SIZEOF_SHORT, TypeSpec::SIZEOF_SHORT,
+                          ->(buf, offset, num) { buf.store_short(offset, num) },
+                          ->(buf, offset) { buf.load_ushort(offset) }].freeze
+    INT       = Primitive[:int, TypeSpec::SIZEOF_INT, TypeSpec::SIZEOF_INT,
+                          ->(buf, offset, num) { buf.store_int(offset, num) },
+                          ->(buf, offset) { buf.load_int(offset) }].freeze
+    UINT      = Primitive[:uint, TypeSpec::SIZEOF_INT, TypeSpec::SIZEOF_INT,
+                          ->(buf, offset, num) { buf.store_int(offset, num) },
+                          ->(buf, offset) { buf.load_uint(offset) }].freeze
     LONG      = Primitive[:long, TypeSpec::SIZEOF_LONG, TypeSpec::SIZEOF_LONG,
                           ->(buf, offset, num) { buf.store_long(offset, num) },
                           ->(buf, offset) { buf.load_long(offset) }].freeze
     ULONG     = Primitive[:ulong, TypeSpec::SIZEOF_LONG, TypeSpec::SIZEOF_LONG,
                           ->(buf, offset, num) { buf.store_long(offset, num) },
                           ->(buf, offset) { buf.load_ulong(offset) }].freeze
-    LONGLONG  = Primitive[:longlong, 8, 8,
-                          ->(buf, offset, num) { buf.store64(offset, num) },
-                          ->(buf, offset) { buf.loadi64(offset) }].freeze
-    ULONGLONG = Primitive[:ulonglong, 8, 8,
-                          ->(buf, offset, num) { buf.store64(offset, num) },
-                          ->(buf, offset) { buf.loadu64(offset) }].freeze
-    FLOAT     = Primitive[:float, 4, 4,
-                          ->(buf, offset, num) { buf.storef32(offset, num) },
-                          ->(buf, offset) { buf.loadf32(offset) }].freeze
-    DOUBLE    = Primitive[:double, 8, 8,
-                          ->(buf, offset, num) { buf.storef64(offset, num) },
-                          ->(buf, offset) { buf.loadf64(offset) }].freeze
+    LONGLONG  = Primitive[:longlong, TypeSpec::SIZEOF_LONGLONG, TypeSpec::SIZEOF_LONGLONG,
+                          ->(buf, offset, num) { buf.store_longlong(offset, num) },
+                          ->(buf, offset) { buf.load_longlong(offset) }].freeze
+    ULONGLONG = Primitive[:ulonglong, TypeSpec::SIZEOF_LONGLONG, TypeSpec::SIZEOF_LONGLONG,
+                          ->(buf, offset, num) { buf.store_longlong(offset, num) },
+                          ->(buf, offset) { buf.load_ulonglong(offset) }].freeze
+    FLOAT     = Primitive[:float, TypeSpec::SIZEOF_FLOAT, TypeSpec::SIZEOF_FLOAT,
+                          ->(buf, offset, num) { buf.store_float(offset, num) },
+                          ->(buf, offset) { buf.load_float(offset) }].freeze
+    DOUBLE    = Primitive[:double, TypeSpec::SIZEOF_DOUBLE, TypeSpec::SIZEOF_DOUBLE,
+                          ->(buf, offset, num) { buf.store_double(offset, num) },
+                          ->(buf, offset) { buf.load_double(offset) }].freeze
     FLOAT_BE  = Primitive[:float_be, 4, 4,
                           ->(buf, offset, num) { buf.storef32be(offset, num) },
                           ->(buf, offset) { buf.loadf32be(offset) }].freeze
@@ -210,5 +210,113 @@ module Gogyou
     DOUBLE_SWAP = Primitive[:double_swap, 8, 8,
                           ->(buf, offset, num) { buf.storef64swap(offset, num) },
                           ->(buf, offset) { buf.loadf64swap(offset) }].freeze
+    FLOAT16_T = Primitive[:float16_t, 2, 2,
+                          ->(buf, offset, num) { buf.storef16(offset, num) },
+                          ->(buf, offset) { buf.loadf16(offset) }].freeze
+    FLOAT16_SWAP = Primitive[:float16_swap, 2, 2,
+                          ->(buf, offset, num) { buf.storef16swap(offset, num) },
+                          ->(buf, offset) { buf.loadf16swap(offset) }].freeze
+    FLOAT16_BE = Primitive[:float16_be, 2, 2,
+                          ->(buf, offset, num) { buf.storef16be(offset, num) },
+                          ->(buf, offset) { buf.loadf16be(offset) }].freeze
+    FLOAT16_LE = Primitive[:float16_le, 2, 2,
+                          ->(buf, offset, num) { buf.storef16le(offset, num) },
+                          ->(buf, offset) { buf.loadf16le(offset) }].freeze
+    FLOAT32_T = Primitive[:float32_t, 4, 4,
+                          ->(buf, offset, num) { buf.storef32(offset, num) },
+                          ->(buf, offset) { buf.loadf32(offset) }].freeze
+    FLOAT32_SWAP = Primitive[:float32_swap, 4, 4,
+                          ->(buf, offset, num) { buf.storef32swap(offset, num) },
+                          ->(buf, offset) { buf.loadf32swap(offset) }].freeze
+    FLOAT32_BE = Primitive[:float32_be, 4, 4,
+                          ->(buf, offset, num) { buf.storef32be(offset, num) },
+                          ->(buf, offset) { buf.loadf32be(offset) }].freeze
+    FLOAT32_LE = Primitive[:float32_le, 4, 4,
+                          ->(buf, offset, num) { buf.storef32le(offset, num) },
+                          ->(buf, offset) { buf.loadf32le(offset) }].freeze
+    FLOAT64_T = Primitive[:float64_t, 8, 8,
+                          ->(buf, offset, num) { buf.storef64(offset, num) },
+                          ->(buf, offset) { buf.loadf64(offset) }].freeze
+    FLOAT64_SWAP = Primitive[:float64_swap, 8, 8,
+                          ->(buf, offset, num) { buf.storef64swap(offset, num) },
+                          ->(buf, offset) { buf.loadf64swap(offset) }].freeze
+    FLOAT64_BE = Primitive[:float64_be, 8, 8,
+                          ->(buf, offset, num) { buf.storef64be(offset, num) },
+                          ->(buf, offset) { buf.loadf64be(offset) }].freeze
+    FLOAT64_LE = Primitive[:float64_le, 8, 8,
+                          ->(buf, offset, num) { buf.storef64le(offset, num) },
+                          ->(buf, offset) { buf.loadf64le(offset) }].freeze
+    FIXED16Q8_T = Primitive[:fixed16q8_t, 2, 2,
+                          ->(buf, offset, num) { buf.store16q8(offset, num) },
+                          ->(buf, offset) { buf.loadi16q8(offset) }].freeze
+    FIXED16Q8_SWAP = Primitive[:fixed16q8_swap, 2, 2,
+                          ->(buf, offset, num) { buf.store16q8swap(offset, num) },
+                          ->(buf, offset) { buf.loadi16q8swap(offset) }].freeze
+    FIXED16Q8_BE = Primitive[:fixed16q8_be, 2, 2,
+                          ->(buf, offset, num) { buf.store16q8be(offset, num) },
+                          ->(buf, offset) { buf.loadi16q8be(offset) }].freeze
+    FIXED16Q8_LE = Primitive[:fixed16q8_le, 2, 2,
+                          ->(buf, offset, num) { buf.store16q8le(offset, num) },
+                          ->(buf, offset) { buf.loadi16q8le(offset) }].freeze
+    FIXED32Q6_T = Primitive[:fixed32q6_t, 4, 4,
+                          ->(buf, offset, num) { buf.store32q6(offset, num) },
+                          ->(buf, offset) { buf.loadi32q6(offset) }].freeze
+    FIXED32Q6_SWAP = Primitive[:fixed32q6_swap, 4, 4,
+                          ->(buf, offset, num) { buf.store32q6swap(offset, num) },
+                          ->(buf, offset) { buf.loadi32q6swap(offset) }].freeze
+    FIXED32Q6_BE = Primitive[:fixed32q6_be, 4, 4,
+                          ->(buf, offset, num) { buf.store32q6be(offset, num) },
+                          ->(buf, offset) { buf.loadi32q6be(offset) }].freeze
+    FIXED32Q6_LE = Primitive[:fixed32q6_le, 4, 4,
+                          ->(buf, offset, num) { buf.store32q6le(offset, num) },
+                          ->(buf, offset) { buf.loadi32q6le(offset) }].freeze
+    FIXED32Q8_T = Primitive[:fixed32q8_t, 4, 4,
+                          ->(buf, offset, num) { buf.store32q8(offset, num) },
+                          ->(buf, offset) { buf.loadi32q8(offset) }].freeze
+    FIXED32Q8_SWAP = Primitive[:fixed32q8_swap, 4, 4,
+                          ->(buf, offset, num) { buf.store32q8swap(offset, num) },
+                          ->(buf, offset) { buf.loadi32q8swap(offset) }].freeze
+    FIXED32Q8_BE = Primitive[:fixed32q8_be, 4, 4,
+                          ->(buf, offset, num) { buf.store32q8be(offset, num) },
+                          ->(buf, offset) { buf.loadi32q8be(offset) }].freeze
+    FIXED32Q8_LE = Primitive[:fixed32q8_le, 4, 4,
+                          ->(buf, offset, num) { buf.store32q8le(offset, num) },
+                          ->(buf, offset) { buf.loadi32q8le(offset) }].freeze
+    FIXED32Q12_T = Primitive[:fixed32q12_t, 4, 4,
+                          ->(buf, offset, num) { buf.store32q12(offset, num) },
+                          ->(buf, offset) { buf.loadi32q12(offset) }].freeze
+    FIXED32Q12_SWAP = Primitive[:fixed32q12_swap, 4, 4,
+                          ->(buf, offset, num) { buf.store32q12swap(offset, num) },
+                          ->(buf, offset) { buf.loadi32q12swap(offset) }].freeze
+    FIXED32Q12_BE = Primitive[:fixed32q12_be, 4, 4,
+                          ->(buf, offset, num) { buf.store32q12be(offset, num) },
+                          ->(buf, offset) { buf.loadi32q12be(offset) }].freeze
+    FIXED32Q12_LE = Primitive[:fixed32q12_le, 4, 4,
+                          ->(buf, offset, num) { buf.store32q12le(offset, num) },
+                          ->(buf, offset) { buf.loadi32q12le(offset) }].freeze
+    FIXED32Q16_T = Primitive[:fixed32q16_t, 4, 4,
+                          ->(buf, offset, num) { buf.store32q16(offset, num) },
+                          ->(buf, offset) { buf.loadi32q16(offset) }].freeze
+    FIXED32Q16_SWAP = Primitive[:fixed32q16_swap, 4, 4,
+                          ->(buf, offset, num) { buf.store32q16swap(offset, num) },
+                          ->(buf, offset) { buf.loadi32q16swap(offset) }].freeze
+    FIXED32Q16_BE = Primitive[:fixed32q16_be, 4, 4,
+                          ->(buf, offset, num) { buf.store32q16be(offset, num) },
+                          ->(buf, offset) { buf.loadi32q16be(offset) }].freeze
+    FIXED32Q16_LE = Primitive[:fixed32q16_le, 4, 4,
+                          ->(buf, offset, num) { buf.store32q16le(offset, num) },
+                          ->(buf, offset) { buf.loadi32q16le(offset) }].freeze
+    FIXED32Q24_T = Primitive[:fixed32q24_t, 4, 4,
+                          ->(buf, offset, num) { buf.store32q24(offset, num) },
+                          ->(buf, offset) { buf.loadi32q24(offset) }].freeze
+    FIXED32Q24_SWAP = Primitive[:fixed32q24_swap, 4, 4,
+                          ->(buf, offset, num) { buf.store32q24swap(offset, num) },
+                          ->(buf, offset) { buf.loadi32q24swap(offset) }].freeze
+    FIXED32Q24_BE = Primitive[:fixed32q24_be, 4, 4,
+                          ->(buf, offset, num) { buf.store32q24be(offset, num) },
+                          ->(buf, offset) { buf.loadi32q24be(offset) }].freeze
+    FIXED32Q24_LE = Primitive[:fixed32q24_le, 4, 4,
+                          ->(buf, offset, num) { buf.store32q24le(offset, num) },
+                          ->(buf, offset) { buf.loadi32q24le(offset) }].freeze
   end
 end

data/lib/gogyou/typespec.rb

@@ -4,7 +4,7 @@ module Gogyou
     SIZEOF_SHORT    = [0].pack("S!").bytesize
     SIZEOF_INT      = [0].pack("I!").bytesize
     SIZEOF_LONG     = [0].pack("L!").bytesize
-    SIZEOF_LONGLONG = [0].pack("Q!").bytesize
+    SIZEOF_LONGLONG = [0].pack("Q").bytesize
     SIZEOF_SIZE_T   = [nil].pack("P").bytesize
     SIZEOF_FLOAT    = [0].pack("F").bytesize
     SIZEOF_DOUBLE   = [0].pack("D").bytesize

data/lib/gogyou/version.rb

@@ -1,3 +1,3 @@
 module Gogyou
-  VERSION = "0.2.3"
+  VERSION = "0.2.4"
 end

data/mkprims.rb

@@ -44,22 +44,58 @@ int64_swap  8 8 store64swap loadi64swap
 uint64_swap 8 8 store64swap loadu64swap
 char      1 1 store8   loadi8
 uchar     1 1 store8   loadu8
-short     2 2 store16  loadi16
-ushort    2 2 store16  loadu16
-int 4 4 store32 loadi32
-uint 4 4 store32 loadu32
-long TypeSpec::SIZEOF_LONG TypeSpec::SIZEOF_LONG store_long load_long
-ulong TypeSpec::SIZEOF_LONG TypeSpec::SIZEOF_LONG store_long load_ulong
-longlong 8 8 store64 loadi64
-ulonglong 8 8 store64 loadu64
-float     4 4 storef32  loadf32
-double    8 8 storef64  loadf64
+short     TypeSpec::SIZEOF_SHORT TypeSpec::SIZEOF_SHORT store_short  load_short
+ushort    TypeSpec::SIZEOF_SHORT TypeSpec::SIZEOF_SHORT store_short  load_ushort
+int       TypeSpec::SIZEOF_INT TypeSpec::SIZEOF_INT store_int load_int
+uint      TypeSpec::SIZEOF_INT TypeSpec::SIZEOF_INT store_int load_uint
+long      TypeSpec::SIZEOF_LONG TypeSpec::SIZEOF_LONG store_long load_long
+ulong     TypeSpec::SIZEOF_LONG TypeSpec::SIZEOF_LONG store_long load_ulong
+longlong  TypeSpec::SIZEOF_LONGLONG TypeSpec::SIZEOF_LONGLONG store_longlong load_longlong
+ulonglong TypeSpec::SIZEOF_LONGLONG TypeSpec::SIZEOF_LONGLONG store_longlong load_ulonglong
+float     TypeSpec::SIZEOF_FLOAT TypeSpec::SIZEOF_FLOAT store_float  load_float
+double    TypeSpec::SIZEOF_DOUBLE TypeSpec::SIZEOF_DOUBLE store_double  load_double
 float_be  4 4 storef32be loadf32be
 double_be 8 8 storef64be  loadf64be
 float_le  4 4 storef32le  loadf32le
 double_le 8 8 storef64le  loadf64le
 float_swap  4 4 storef32swap  loadf32swap
 double_swap 8 8 storef64swap  loadf64swap
+float16_t 2 2 storef16 loadf16
+float16_swap 2 2 storef16swap loadf16swap
+float16_be 2 2 storef16be loadf16be
+float16_le 2 2 storef16le loadf16le
+float32_t 4 4 storef32 loadf32
+float32_swap 4 4 storef32swap loadf32swap
+float32_be 4 4 storef32be loadf32be
+float32_le 4 4 storef32le loadf32le
+float64_t 8 8 storef64 loadf64
+float64_swap 8 8 storef64swap loadf64swap
+float64_be 8 8 storef64be loadf64be
+float64_le 8 8 storef64le loadf64le
+fixed16q8_t 2 2 store16q8 loadi16q8
+fixed16q8_swap 2 2 store16q8swap loadi16q8swap
+fixed16q8_be 2 2 store16q8be loadi16q8be
+fixed16q8_le 2 2 store16q8le loadi16q8le
+fixed32q6_t 4 4 store32q6 loadi32q6
+fixed32q6_swap 4 4 store32q6swap loadi32q6swap
+fixed32q6_be 4 4 store32q6be loadi32q6be
+fixed32q6_le 4 4 store32q6le loadi32q6le
+fixed32q8_t 4 4 store32q8 loadi32q8
+fixed32q8_swap 4 4 store32q8swap loadi32q8swap
+fixed32q8_be 4 4 store32q8be loadi32q8be
+fixed32q8_le 4 4 store32q8le loadi32q8le
+fixed32q12_t 4 4 store32q12 loadi32q12
+fixed32q12_swap 4 4 store32q12swap loadi32q12swap
+fixed32q12_be 4 4 store32q12be loadi32q12be
+fixed32q12_le 4 4 store32q12le loadi32q12le
+fixed32q16_t 4 4 store32q16 loadi32q16
+fixed32q16_swap 4 4 store32q16swap loadi32q16swap
+fixed32q16_be 4 4 store32q16be loadi32q16be
+fixed32q16_le 4 4 store32q16le loadi32q16le
+fixed32q24_t 4 4 store32q24 loadi32q24
+fixed32q24_swap 4 4 store32q24swap loadi32q24swap
+fixed32q24_be 4 4 store32q24be loadi32q24be
+fixed32q24_le 4 4 store32q24le loadi32q24le
 EOS
 
 File.open(path, "wb") do |f|
@@ -71,43 +107,43 @@ File.open(path, "wb") do |f|
 require_relative "typespec"
 
 module Gogyou
-  module Primitives
-    class Primitive < ::Struct.new(:name, :bytesize, :bytealign)
-      BasicStruct = superclass
+  class Primitive < ::Struct.new(:name, :bytesize, :bytealign)
+    BasicStruct = superclass
 
-      undef :name=, :bytesize=, :bytealign=
+    undef :name=, :bytesize=, :bytealign=
 
-      def initialize(name, bytesize, bytealign, aset, aref)
-        super(name.intern, bytesize.to_i, bytealign.to_i)
-        define_singleton_method(:aset, aset)
-        define_singleton_method(:aref, aref)
-      end
+    def initialize(name, bytesize, bytealign, aset, aref)
+      super(name.intern, bytesize.to_i, bytealign.to_i)
+      define_singleton_method(:aset, aset)
+      define_singleton_method(:aref, aref)
+    end
 
-      def extensible?
-        false
-      end
+    def extensible?
+      false
+    end
 
-      def to_s
-        "\\\#<\#{self.class}:\#{name} bytesize=\#{bytesize.inspect}, bytealign=\#{bytealign.inspect}>"
-      end
+    def to_s
+      "\\\#<\#{self.class}:\#{name} bytesize=\#{bytesize.inspect}, bytealign=\#{bytealign.inspect}>"
+    end
 
-      alias inspect to_s
+    alias inspect to_s
 
-      def pretty_print(q)
-        #name, bytesize, bytealign
-        q.group(1, "\\\#<\#{self.class}:\#{name}") do
-          q.breakable " "
-          q.text "bytesize="
-          q.pp bytesize
-          q.text ","
-          q.breakable " "
-          q.text "bytealign="
-          q.pp bytealign
-        end
-        q.text ">"
+    def pretty_print(q)
+      #name, bytesize, bytealign
+      q.group(1, "\\\#<\#{self.class}:\#{name}") do
+        q.breakable " "
+        q.text "bytesize="
+        q.pp bytesize
+        q.text ","
+        q.breakable " "
+        q.text "bytealign="
+        q.pp bytealign
       end
+      q.text ">"
     end
+  end
 
+  module Primitives
   EOS
 
   records = records.split(/\n/)