gogyou 0.1.240911.prototype → 0.2

data/lib/gogyou/model.rb

@@ -0,0 +1,504 @@
+module Gogyou
+  #
+  # 構造体の構成情報などを保持するクラスです。
+  #
+  # 構造体の大きさや各フィールドの名前、バイト位置、型などを管理します。
+  #
+  class Model < ::Struct.new(:bytesize,   # total bytesize in bytes
+                             :bytealign,  # byte alignment
+                             :fields)     # array of field
+    BasicStruct = superclass
+
+    FIELDNAME_PATTERN = /\A[A-Za-z_][0-9A-Za-z_]*\Z/
+
+    undef :bytesize=, :bytealign=, :fields=
+
+    def initialize(*args)
+      case
+      when args.size < 3
+        raise ArgumentError, "wrong argument size (#{args.size} for 3+)"
+      when args.size < 4 && args[2].kind_of?(::Array)
+        super
+      else
+        super(args[0], args[1], args.slice(2 .. -1))
+      end
+    end
+
+    def aset(buffer, offset, value)
+      raise NotImplementedError
+    end
+
+    def aref(buffer, offset)
+      raise NotImplementedError
+    end
+
+    def extensible?
+      fields.any? { |f| f.extensible? }
+    end
+
+    def to_s
+      "#{self.class}[bytesize=#{bytesize.inspect}, bytealign=#{bytealign.inspect}, fields=#{fields.inspect}]"
+    end
+
+    alias inspect to_s
+
+    def pretty_print(q)
+      #bytesize, bytealign, fields
+      q.group(1, "#{self.class}[") do
+        #q.breakable
+        q.text "bytesize="
+        q.pp bytesize
+        q.text ", "
+        #q.breakable
+        q.text "bytealign="
+        q.pp bytealign
+        q.text ", "
+        #q.breakable(" ")
+        q.text "fields="
+        q.breakable
+        q.pp fields
+      end
+      q.text "]"
+    end
+
+    # 構造体の各メンバの情報を保持する
+    class Field < ::Struct.new(:offset, # field offset in model
+                               :name,   # field name
+                               :vector, # 要素数。任意数配列の場合は 0。配列でないならば nil。
+                               :type,   # type specification (or model object) of this field
+                               :flags)  # 0x01: const / 0x02: packed (not aligned)
+      BasicStruct = superclass
+
+      FLAG_CONST  = 0x01
+      FLAG_PACKED = 0x02
+
+      def initialize(offset, name, vector, type, flags = 0)
+        super(offset, name, vector, type, flags)
+      end
+
+      def extensible?
+        if vector
+          vector[-1] == 0 ? true : false
+        else
+          type.extensible?
+        end
+      end
+
+      def const?
+        ((flags & FLAG_CONST) == FLAG_CONST) ? true : false
+      end
+
+      def packed?
+        ((flags & FLAG_PACKED) == FLAG_PACKED) ? true : false
+      end
+
+      def mark_const
+        self.flags |= FLAG_CONST
+        self
+      end
+
+      def mark_packed
+        self.flags |= FLAGS_PACKED
+        self
+      end
+
+      def strflags
+        set = [const? ? "const" : nil, packed? ? "packed" : nil]
+        set.compact!
+        return nil if set.empty?
+        set.join(",")
+      end
+
+      def strflags_with_paren
+        set = strflags
+        set ? "(#{set})" : ""
+      end
+
+      def to_s
+        "#{self.class}[offset=#{offset.inspect}, name=#{name.inspect}, vector=#{vector.inspect}, type=#{type.inspect}, flags=0x#{flags.to_s(16)}#{strflags_with_paren}]"
+      end
+
+      alias inspect to_s
+
+      def pretty_print(q)
+        q.group(1, "#{self.class}[") do
+          #q.breakable
+          q.text "offset="
+          q.pp offset
+          q.text ", "
+          #q.breakable
+          q.text "name="
+          q.pp name
+          q.text ", "
+          #q.breakable
+          q.text "vector="
+          q.pp vector
+          q.text ", "
+          #q.breakable
+          q.text "flags=0x%02x%s" % [flags, strflags_with_paren]
+          q.text ","
+          q.breakable(" ")
+          q.text "type="
+          q.pp type
+        end
+        q.text "]"
+      end
+    end
+
+    def self.struct(typemap, &block)
+      define_container(typemap, Model::Struct, &block)
+    end
+
+    def self.union(typemap, &block)
+      define_container(typemap, Model::Union, &block)
+    end
+
+    def self.typedef(typemap, type, aliasname, *elements)
+      raise ArgumentError, "informal aliasname (#{aliasname.inspect})" unless aliasname =~ FIELDNAME_PATTERN
+      aliasname = aliasname.intern
+
+      case type
+      when Symbol, String
+        type0 = type
+        type = typemap[type.intern]
+        raise ArgumentError, "type not defined (#{type0})" unless type
+      else
+        # 型情報子を用いる方法
+        raise ArgumentError, "type is not typeinfo (#{type.inspect})" unless Model.check_typeinfo(type)
+      end
+
+      unless elements.empty?
+        # 配列型
+        # TODO: Accessor::Array を構築するのではなく、Model::Array インスタンスを生成するようにする
+        type = Accessor.define_subarray(Model::Field[0, nil, elements, type, 0])
+      end
+
+      typemap[aliasname] = type
+
+      nil
+    end
+
+    def self.define_container(typemap, model_type, &block)
+      creator = model_type::Creator.new(typemap, 0, [])
+      proxy = model_type::Creator::Proxy.new(creator)
+      proxy.instance_exec(&block)
+      model = creator.to_model
+      model
+    end
+
+    def self.check_typeinfo(obj)
+      if obj.kind_of?(Model) ||
+         (obj.kind_of?(Module) && obj < Accessor) ||
+         (obj.respond_to?(:bytesize) &&
+          obj.respond_to?(:bytealign) &&
+          obj.respond_to?(:extensible?) &&
+          obj.respond_to?(:aset) &&
+          obj.respond_to?(:aref))
+        true
+      else
+        false
+      end
+    end
+
+
+    BasicCreator = ::Struct.new(:typemap, :offset, :fields)
+
+    class BasicCreator
+      def maxalign(fields = self.fields)
+        fields.map { |f| f.type.bytealign }.max
+      end
+
+      def maxsize(fields = self.fields)
+        fields.map { |f| s = f.type.bytesize; f.vector ? f.vector.inject(&:*) * s : s }.max
+      end
+
+      def flatten_field(fields = self.fields)
+        #pp fields
+        fields2 = []
+        fields.each do |f|
+          #p f
+          #p f.class
+          if f.name
+            fields2 << f
+          else
+            raise "BUG? : field.type is not a Model (%p)" % f.type unless f.type.kind_of?(Model)
+            fs = flatten_field(f.type.fields)
+            fs.each { |ff| ff.offset += f.offset; ff.mark_const if f.const? }
+            fields2.concat fs
+          end
+        end
+        fields2
+      end
+
+      # :nodoc: all
+      class Proxy < Object
+      #class Proxy < BasicObject
+        def initialize(creator)
+          #singleton_class = (class << proxy; self; end)
+          singleton_class.class_eval do
+            latest_fields = nil
+            #define_method(:method_missing, ->(type, *args) { latest_fields = creator.addfield(type, args); nil })
+            creator.typemap.each_key do |t|
+              define_method(t, ->(*args) { latest_fields = creator.addfield(t, args); nil })
+            end
+            define_method(:struct, ->(*args, &block) { latest_fields = creator.struct(args, &block); nil })
+            define_method(:union, ->(*args, &block) { latest_fields = creator.union(args, &block); nil })
+            define_method(:const, ->(dummy_fields) { creator.const(latest_fields); latest_fields = nil; nil })
+            define_method(:typedef, ->(*args, &block) { creator.typedef(args, &block) })
+            if creator.respond_to?(:bytealign)
+              define_method(:bytealign, ->(bytesize, &block) { creator.bytealign(bytesize, &block) })
+            end
+            if creator.respond_to?(:padding)
+              define_method(:padding, ->(bytesize, &block) { creator.padding(bytesize, &block) })
+            end
+          end
+        end
+      end
+
+      #
+      # call-seq:
+      #   struct type, name, *vector
+      #   struct proc, name, *vector
+      #   struct { ... }
+      #
+      # 最初の呼び出し方法は、既存の (typedef していない) 型情報を用いる、または構造体をその場で定義するために利用できます。
+      #
+      # 二番目の呼び出し方法は、無名構造体を定義するために利用できます。
+      #
+      # === example (型情報を用いる)
+      #
+      #   Type1 = struct {
+      #     struct UserType, :a, :b, 2, 3, 4
+      #   }
+      #
+      # === example (構造体をその場で定義して、構造体へのアクセッサを定義する)
+      #
+      #   Type2 = struct {
+      #     struct -> {
+      #       int :x, y, z
+      #     }, :a, :b, 2, 3, 4
+      #   }
+      #
+      # === example (無名構造体)
+      #
+      #   Type3 = struct {
+      #     struct {
+      #       int :a, :b, 2, 3, 4
+      #     }
+      #   }
+      #
+      def struct(args, &block)
+        define_container(args, block, Model.method(:struct))
+      end
+
+      #
+      # call-seq:
+      #   union type, name, *vector
+      #   union proc, name, *vector
+      #   union { ... }
+      #
+      # 共用体を定義します。
+      #
+      # 呼び出し方は struct と変わりません。
+      #
+      # ただ、<tt>union type, ...</tt> の場合は、<tt>struct type, ...</tt> と同じ結果となります。
+      # これは type がどのような構造になっているのかを gogyou が管理も把握もしないためです。
+      # この記述ができる唯一の理由は、人間が見てわかりやすくすることを意図しています
+      # (ただし、ミスリードを誘う手口にも利用されてしまうのが最大の欠点です)。
+      #
+      def union(args, &block)
+        define_container(args, block, Model.method(:union))
+      end
+
+      def define_container(args, anonymblock, container)
+        if anonymblock
+          raise ArgumentError, "given block and arguments" unless args.empty?
+          model = container.(typemap.dup, &anonymblock)
+          raise "BUG - object is not a Model (#{model.class})" unless model.kind_of?(Model)
+          #p model: model, superclass: model.superclass
+          self.offset = offset.align_ceil(model.bytealign) unless kind_of?(Model::Union::Creator)
+          fields << f = Field[offset, nil, nil, model, 0]
+          self.offset += model.bytesize unless kind_of?(Model::Union::Creator)
+          [f]
+        else
+          type = args.shift
+          type = container.(typemap.dup, &type) if type.kind_of?(::Proc)
+          addfield!(type, args)
+        end
+      end
+
+      def typedef(args)
+        raise NotImplementedError
+      end
+
+      def const(fields)
+        fields.each { |f| f.mark_const }
+      end
+
+      #
+      # フィールド名の解析
+      #
+      def parse!(args)
+        raise ArgumentError, "nothing argument" if args.empty?
+        name = nil
+        vector = nil
+        while arg = args.shift
+          case arg
+          when Symbol, String
+            yield(name, vector) if name
+            raise ArgumentError, "informal field name (#{arg.to_s})" unless arg =~ FIELDNAME_PATTERN
+            name = arg.intern
+            vector = nil
+          when Integer
+            raise ArgumentError, "first argument is field name only (#{arg})" unless name
+            raise ArgumentError, "given negative number (#{arg})" unless arg >= 0
+            vector ||= []
+            vector << arg.to_i
+            if vector[-1] == 0
+              yield(name, vector)
+              unless args.empty?
+                raise ArgumentError, "given fields after extensible vector"
+              end
+              return nil
+            end
+          else
+            raise ArgumentError, "given any object (#{arg.inspect})"
+          end
+        end
+
+        yield(name, vector)
+
+        nil
+      end
+
+      def addfield(type, args)
+        typeobj = typemap[type.intern]
+        unless typeobj
+          raise NoMethodError, "typename or method is missing (#{type})"
+        end
+
+        addfield!(typeobj, args)
+      end
+
+      def addfield!(typeobj, args)
+        #p typeobj
+        # check extensible field  >>>  creator.fields[-1].vector[-1]
+        if (x = fields[-1]) && (x = x.vector) && x[-1] == 0
+          raise ArgumentError, "not given fields after extensible vector"
+        end
+
+        typesize = typeobj.bytesize
+        typealign = typeobj.bytealign
+
+        tmpfields = []
+
+        parse!(args) do |name, vect|
+          self.offset = offset.align_ceil(typealign) unless kind_of?(Model::Union::Creator)
+          fields << f = Field[offset, name, vect, typeobj, 0]
+          tmpfields << f
+          unless kind_of?(Model::Union::Creator)
+            elements = vect ? vect.inject(1, &:*) : 1
+            self.offset += typesize * elements
+          end
+        end
+
+        tmpfields
+      end
+    end
+
+    class Struct < Model
+      class Creator < Model::BasicCreator
+        def bytealign(bytesize)
+          raise NotImplementedError
+        end
+
+        def padding(bytesize)
+          raise NotImplementedError
+        end
+
+        def to_model
+          Model::Struct.new(offset.align_ceil(maxalign), maxalign, flatten_field)
+        end
+      end
+
+      def aset(buffer, offset, value)
+        raise NotImplementedError
+      end
+
+      def aref(buffer, offset)
+        v = Accessor::TemporaryStruct.new(buffer, offset, self)
+        v.infect_from(self, buffer) unless v.frozen?
+        v.freeze if frozen? || buffer.frozen?
+        v
+      end
+
+      def create_accessor
+        Accessor::Struct.define(self)
+      end
+    end
+
+    class Union < Model
+      class Creator < Model::BasicCreator
+        def to_model
+          Model::Union.new(maxsize.align_ceil(maxalign), maxalign, flatten_field)
+        end
+      end
+
+      def aset(buffer, offset, value)
+        raise NotImplementedError
+      end
+
+      def aref(buffer, offset)
+        v = Accessor::TemporaryUnion.new(buffer, offset, self)
+        v.infect_from(self, buffer) unless v.frozen?
+        v.freeze if frozen? || buffer.frozen?
+        v
+      end
+
+      def create_accessor
+        Accessor::Union.define(self)
+      end
+    end
+
+    #
+    # C の配列を模造するクラス。
+    #
+    class Array < Model
+      def extensible?
+        fields[-1] == 0 ? true : false
+      end
+
+      def aset(buffer, offset, value)
+        raise NotImplementedError
+      end
+
+      def aref(buffer, offset)
+        raise NotImplementedError
+        accessor = Accessor::Array[buffer, offset, self]
+        accessor.instance_eval do
+          field = fields[0]
+          type = field.type
+          elements = field.vector[-1]
+
+          define_singleton_method(:check_index, ->(i) {
+            i = i.to_i
+            raise IndexError unless i >= 0 && (elements.nil? || i < elements)
+            i
+          })
+
+          define_singleton_method(:[], ->(i) {
+            v = type.aref(buffer__GOGYOU__, offset__GOGYOU__ + type.bytesize * check_index(i))
+            v.infect_from(self, buffer) unless v.frozen?
+            v.freeze if frozen? || buffer.frozen? || field.const?
+            v
+          })
+
+          define_singleton_method(:[]=, ->(i, v) {
+            type.aset(buffer__GOGYOU__, offset__GOGYOU__ + type.bytesize * check_index(i), v)
+          })
+        end
+        accessor
+      end
+    end
+  end
+end