crystalruby 0.2.3 → 0.3.0

data/lib/crystalruby/typebuilder.rb

@@ -4,66 +4,22 @@ module CrystalRuby
   module TypeBuilder
     module_function
 
-    def with_injected_type_dsl(context, &block)
-      with_constants(context) do
-        with_methods(context, &block)
+    def build_from_source(src, context: )
+      source_type = Types.with_binding_fallback(context) do |binding|
+        eval(src.is_a?(String) ? src : SourceReader.extract_source_from_proc(src), binding)
       end
-    end
 
-    def with_methods(context)
-      restores = []
-      %i[Array Hash NamedTuple Tuple].each do |method_name|
-        old_method = begin
-          context.instance_method(method_name)
-        rescue StandardError
-          nil
-        end
-        restores << [context, method_name, old_method]
-        context.singleton_class.undef_method(method_name) if old_method
-        context.define_singleton_method(method_name) do |*args|
-          Types.send(method_name, *args)
-        end
-      end
-      yield
-    ensure
-      restores.each do |context, method_name, old_method|
-        context.singleton_class.undef_method(method_name)
-        context.define_singleton_method(method_name, old_method) if old_method
-      end
-    end
+      return source_type if source_type.is_a?(Types::Root::Symbol)
 
-    def with_constants(context)
-      previous_const_pairs = CrystalRuby::Types.constants.map do |type|
-        [type, begin
-          context.const_get(type)
-        rescue StandardError
-          nil
-        end]
-      end
-      CrystalRuby::Types.constants.each do |type|
-        begin
-          context.send(:remove_const, type)
-        rescue StandardError
-          nil
-        end
-        context.const_set(type, CrystalRuby::Types.const_get(type))
+      unless source_type.kind_of?(Class) && source_type < Types::Type
+        raise "Invalid type #{source_type.inspect}"
       end
-      yield
-    ensure
-      previous_const_pairs.each do |const_name, const_value|
-        begin
-          context.send(:remove_const, const_name)
-        rescue StandardError
-          nil
-        end
-        context.const_set(const_name, const_value)
-      end
-    end
 
-    def build
-      result = yield
-      Types::Type.validate!(result)
-      Types::Typedef(result)
+      return source_type unless source_type.anonymous?
+
+      source_type.tap do |new_type|
+        Types::Type.validate!(new_type)
+      end
     end
   end
 end

data/lib/crystalruby/typemaps.rb

@@ -3,55 +3,60 @@
 module CrystalRuby
   module Typemaps
     CRYSTAL_TYPE_MAP = {
-      char: "Int8",        # In Crystal, :char is typically represented as Int8
-      uchar: "UInt8",      # Unsigned char
-      int8: "Int8",        # Same as :char
-      uint8: "UInt8",      # Same as :uchar
-      short: "Int16",      # Short integer
-      ushort: "UInt16",    # Unsigned short integer
-      int16: "Int16",      # Same as :short
-      uint16: "UInt16",    # Same as :ushort
-      int: "Int32",        # Integer, Crystal defaults to 32 bits
-      uint: "UInt32",      # Unsigned integer
-      int32: "Int32",      # 32-bit integer
-      uint32: "UInt32",    # 32-bit unsigned integer
-      long: "Int32 | Int64", # Long integer, size depends on the platform (32 or 64 bits)
+      char: "Int8",             # In Crystal, :char is typically represented as Int8
+      uchar: "UInt8",           # Unsigned char
+      int8: "Int8",             # Same as :char
+      uint8: "UInt8",           # Same as :uchar
+      short: "Int16",           # Short integer
+      ushort: "UInt16",         # Unsigned short integer
+      int16: "Int16",           # Same as :short
+      uint16: "UInt16",         # Same as :ushort
+      int: "Int32",             # Integer, Crystal defaults to 32 bits
+      uint: "UInt32",           # Unsigned integer
+      int32: "Int32",           # 32-bit integer
+      uint32: "UInt32",         # 32-bit unsigned integer
+      long: "Int32 | Int64",    # Long integer, size depends on the platform (32 or 64 bits)
       ulong: "UInt32 | UInt64", # Unsigned long integer, size depends on the platform
-      int64: "Int64",      # 64-bit integer
-      uint64: "UInt64",    # 64-bit unsigned integer
-      long_long: "Int64",  # Same as :int64
-      ulong_long: "UInt64", # Same as :uint64
-      float: "Float32",    # Floating point number (single precision)
-      double: "Float64",   # Double precision floating point number
-      bool: "Bool",        # Boolean type
-      void: "Void",        # Void type
-      string: "String"     # String type
+      int64: "Int64",           # 64-bit integer
+      uint64: "UInt64",         # 64-bit unsigned integer
+      long_long: "Int64",       # Same as :int64
+      ulong_long: "UInt64",     # Same as :uint64
+      float: "Float32",         # Floating point number (single precision)
+      double: "Float64",        # Double precision floating point number
+      bool: "Bool",             # Boolean type
+      void: "Void",             # Void type
+      string: "String",         # String type
+      pointer: "Pointer(Void)"  # Pointer type
+
     }
 
+    FFI_TYPE_MAP = CRYSTAL_TYPE_MAP.invert
+
     ERROR_VALUE = {
-      char: "0", # In Crystal, :char is typically represented as Int8
-      uchar: "0", # Unsigned char
-      int8: "0", # Same as :char
-      uint8: "0",      # Same as :uchar
-      short: "0",      # Short integer
-      ushort: "0", # Unsigned short integer
-      int16: "0", # Same as :short
-      uint16: "0", # Same as :ushort
-      int: "0", # Integer, Crystal defaults to 32 bits
-      uint: "0", # Unsigned integer
-      int32: "0", # 32-bit integer
-      uint32: "0", # 32-bit unsigned integer
-      long: "0", # Long integer, size depends on the platform (32 or 64 bits)
-      ulong: "0", # Unsigned long integer, size depends on the platform
-      int64: "0", # 64-bit integer
-      uint64: "0", # 64-bit unsigned integer
-      long_long: "0",  # Same as :int64
-      ulong_long: "0", # Same as :uint64
-      float: "0.0",    # Floating point number (single precision)
-      double: "0.0",   # Double precision floating point number
+      char: "0i8", # In Crystal, :char is typically represented as Int8
+      uchar: "0u8", # Unsigned char
+      int8: "0i8", # Same as :char
+      uint8: "0u8", # Same as :uchar
+      short: "0i16", # Short integer
+      ushort: "0u16", # Unsigned short integer
+      int16: "0i16", # Same as :short
+      uint16: "0u16", # Same as :ushort
+      int: "0i32", # Integer, Crystal defaults to 32 bits
+      uint: "0u32", # Unsigned integer
+      int32: "0i32", # 32-bit integer
+      uint32: "0u32", # 32-bit unsigned integer
+      long: "0i64", # Long integer, size depends on the platform (32 or 64 bits)
+      ulong: "0u64", # Unsigned long integer, size depends on the platform
+      int64: "0_i64", # 64-bit integer
+      uint64: "0_u64", # 64-bit unsigned integer
+      long_long: "0_i64",  # Same as :int64
+      ulong_long: "0_u64", # Same as :uint64
+      float: "0.0f32",    # Floating point number (single precision)
+      double: "0.0f64",   # Double precision floating point number
       bool: "false", # Boolean type
       void: "Void", # Void type
-      string: '"".to_unsafe' # String type
+      string: '"".to_unsafe', # String type
+      pointer: "Pointer(Void).null" # Pointer type
     }
 
     C_TYPE_MAP = CRYSTAL_TYPE_MAP.merge(
@@ -68,32 +73,40 @@ module CrystalRuby
       void: {
         to: "nil"
       }
-      }.tap do |hash|
-        hash.define_singleton_method(:convert) do |type, dir, expr|
-          if hash.key?(type)
-            conversion_string = hash[type][dir]
-            conversion_string =~ /%/ ? conversion_string % expr : conversion_string
-          else
-            expr
-          end
+    }.tap do |hash|
+      hash.define_singleton_method(:convert) do |type, dir, expr|
+        if hash.key?(type)
+          conversion_string = hash[type][dir]
+          conversion_string =~ /%/ ? conversion_string % expr : conversion_string
+        else
+          expr
         end
       end
+    end
 
     def build_type_map(crystalruby_type)
+      crystalruby_type = CRType(&crystalruby_type) if crystalruby_type.is_a?(Proc)
       {
         ffi_type: ffi_type(crystalruby_type),
         ffi_ret_type: ffi_type(crystalruby_type),
         crystal_type: crystal_type(crystalruby_type),
+        crystalruby_type: crystalruby_type,
         lib_type: lib_type(crystalruby_type),
         error_value: error_value(crystalruby_type),
-        arg_mapper: if crystalruby_type.is_a?(Types::TypeSerializer)
+        arg_mapper: if crystalruby_type.is_a?(Class) && crystalruby_type < Types::Type
                       lambda { |arg|
-                        crystalruby_type.prepare_argument(arg)
+                        arg = crystalruby_type.new(arg.memory) if arg.is_a?(Types::Type) && !arg.is_a?(crystalruby_type)
+                        arg = crystalruby_type.new(arg) unless arg.is_a?(Types::Type)
+                        arg
                       }
                     end,
-        retval_mapper: if crystalruby_type.is_a?(Types::TypeSerializer)
+        retval_mapper: if crystalruby_type.is_a?(Class) && crystalruby_type < Types::Type
                          lambda { |arg|
-                           crystalruby_type.prepare_retval(arg)
+                           if arg.is_a?(Types::Type) && !arg.is_a?(crystalruby_type)
+                             arg = crystalruby_type.new(arg.memory)
+                           end
+                           arg = crystalruby_type.new(arg) unless arg.is_a?(Types::Type)
+                           crystalruby_type.anonymous? ? arg.native : arg
                          }
                        end,
         convert_crystal_to_lib_type: ->(expr) { convert_crystal_to_lib_type(expr, crystalruby_type) },
@@ -104,13 +117,20 @@ module CrystalRuby
     def ffi_type(type)
       case type
       when Symbol then type
-      when Types::TypeSerializer then type.ffi_type
+      when Class
+        if type < Types::FixedWidth
+          :pointer
+        elsif type < Types::Primitive
+          type.ffi_type
+        end
       end
     end
 
     def lib_type(type)
-      if type.is_a?(Types::TypeSerializer)
-        type.lib_type
+      if type.is_a?(Class) && type < Types::FixedWidth
+        "Pointer(::UInt8)"
+      elsif type.is_a?(Class) && type < Types::Type
+        C_TYPE_MAP.fetch(type.ffi_type)
       else
         C_TYPE_MAP.fetch(type)
       end
@@ -119,8 +139,10 @@ module CrystalRuby
     end
 
     def error_value(type)
-      if type.is_a?(Types::TypeSerializer)
-        type.error_value
+      if type.is_a?(Class) && type < Types::FixedWidth
+        "Pointer(::UInt8).null"
+      elsif type.is_a?(Class) && type < Types::Type
+        ERROR_VALUE.fetch(type.ffi_type)
       else
         ERROR_VALUE.fetch(type)
       end
@@ -129,8 +151,8 @@ module CrystalRuby
     end
 
     def crystal_type(type)
-      if type.is_a?(Types::TypeSerializer)
-        type.crystal_type
+      if type.is_a?(Class) && type < Types::Type
+        type.anonymous? ? type.native_type_expr : type.inspect
       else
         CRYSTAL_TYPE_MAP.fetch(type)
       end
@@ -139,16 +161,19 @@ module CrystalRuby
     end
 
     def convert_lib_to_crystal_type(expr, type)
-      if type.is_a?(Types::TypeSerializer)
-        type.lib_to_crystal_type_expr(expr)
+      if type.is_a?(Class) && type < Types::Type
+        expr = "#{expr}.not_nil!" unless type.nil?
+        type.pointer_to_crystal_type_conversion(expr)
+      elsif type == :void
+        "nil"
       else
-        C_TYPE_CONVERSIONS.convert(type, :from, expr)
+        "#{C_TYPE_CONVERSIONS.convert(type, :from, expr)}.not_nil!"
       end
     end
 
     def convert_crystal_to_lib_type(expr, type)
-      if type.is_a?(Types::TypeSerializer)
-        type.crystal_to_lib_type_expr(expr)
+      if type.is_a?(Class) && type < Types::Type
+        type.crystal_type_to_pointer_type_conversion(expr)
       else
         C_TYPE_CONVERSIONS.convert(type, :to, expr)
       end

data/lib/crystalruby/types/concerns/allocator.rb

@@ -0,0 +1,80 @@
+module CrystalRuby
+  module Types
+    # Module for memory allocation and tracking functionality
+    module Allocator
+
+      # Called when module is included in a class
+      # @param base [Class] The class including this module
+      def self.included(base)
+        base.class_eval do
+          # Synchronizes a block using mutex
+          # @yield Block to be synchronized
+          def self.synchronize(&block)
+            Type::ARC_MUTEX.synchronize(&block)
+          end
+
+          # Schedules a block for execution
+          # @yield Block to be scheduled
+          def self.schedule!(&block)
+            Type::ARC_MUTEX.schedule!(&block)
+          end
+
+          extend FFI::Library
+          ffi_lib "c"
+          attach_function :_calloc, :calloc, [:size_t, :size_t], :pointer
+          attach_function :_free, :free, [:pointer], :void
+          define_singleton_method(:ptr, &FFI::Pointer.method(:new))
+          define_method(:ptr, &FFI::Pointer.method(:new))
+
+          extend Forwardable
+
+          # Instance method to allocate memory
+          # @param size [Integer] Size in bytes to allocate
+          # @return [FFI::Pointer] Pointer to allocated memory
+          def malloc(size)
+            self.class.malloc(size)
+          end
+
+          # Class method to allocate memory
+          # @param size [Integer] Size in bytes to allocate
+          # @return [FFI::Pointer] Pointer to allocated memory
+          def self.malloc(size)
+            result = _calloc(size, 1)
+            traced_live_objects[result.address] = result if trace_live_objects?
+            result
+          end
+
+          # Frees allocated memory
+          # @param ptr [FFI::Pointer] Pointer to memory to free
+          def self.free(ptr)
+            traced_live_objects.delete(ptr.address) if trace_live_objects?
+            _free(ptr)
+          end
+
+          # Returns hash of traced live objects
+          # @return [Hash] Map of addresses to pointers
+          def self.traced_live_objects
+            @traced_live_objects ||= {}
+          end
+
+          # Enables tracing of live objects
+          def self.trace_live_objects!
+            @trace_live_objects = true
+          end
+
+          # Checks if live object tracing is enabled
+          # @return [Boolean] True if tracing is enabled
+          def self.trace_live_objects?
+            !!@trace_live_objects
+          end
+
+          # Returns count of live objects being tracked
+          # @return [Integer] Number of live objects
+          def self.live_objects
+            traced_live_objects.count
+          end
+        end
+      end
+    end
+  end
+end

data/lib/crystalruby/types/fixed_width/named_tuple.cr

@@ -0,0 +1,80 @@
+class <%= base_crystal_class_name %> < CrystalRuby::Types::FixedWidth
+
+  def initialize(tuple : ::NamedTuple(<%= inner_keys.zip(inner_types).map{|k,v| "#{k}: #{v.native_type_expr}"}.join(',') %>))
+    @memory = malloc(data_offset + 8)
+    self.value = tuple
+    increment_ref_count!
+  end
+
+  def ==(other : <%= native_type_expr %>)
+    native == other
+  end
+
+  def data_pointer
+    Pointer(::UInt8).new((@memory + data_offset).as(::Pointer(UInt64)).value)
+  end
+
+  def [](key : Symbol | String)
+    <% offset = 0 %>
+    <% inner_types.each_with_index do |type, i| %>
+      <% offset += type.refsize %>
+      return <%= type.crystal_class_name %>.fetch_single(data_pointer + <%= offset - type.refsize %>).value if :<%= inner_keys[i] %> == key || key == "<%= inner_keys[i] %>"
+    <% end %>
+  end
+
+  <% offset = 0 %>
+  <% inner_types.each_with_index do |type, i| %>
+    <% offset += type.refsize %>
+    def <%= inner_keys[i] %>
+      return <%= type.crystal_class_name %>.fetch_single(data_pointer + <%= offset - type.refsize %>)
+    end
+
+    def <%= inner_keys[i] %>=(value : <%= type.native_type_expr %>)
+      return <%= type.crystal_class_name %>.write_single(data_pointer + <%= offset - type.refsize %>, value)
+    end
+  <% end %>
+
+
+
+  def value=(tuple : ::NamedTuple(<%= inner_keys.zip(inner_types).map{|k,v| "#{k}: #{v.native_type_expr}"}.join(',') %>))
+    self.class.copy_to!(tuple, @memory)
+  end
+
+  def self.copy_to!(tuple : ::NamedTuple(<%= inner_keys.zip(inner_types).map{|k,v| "#{k}: #{v.native_type_expr}"}.join(',') %>), memory : Pointer(::UInt8))
+    data_pointer = malloc(self.memsize)
+    address = data_pointer.address
+
+    <% inner_types.each_with_index do |type, i| %>
+      <%= type.crystal_class_name %>.write_single(data_pointer, tuple[:<%= inner_keys[i] %>])
+      data_pointer += <%= type.refsize %>
+    <% end %>
+
+    (memory+data_offset).as(Pointer(::UInt64)).value = address
+  end
+
+  def value
+    address = data_pointer
+    <% inner_types.each_with_index do |type, i| %>
+      v<%= i %> = <%= type.crystal_class_name %>.fetch_single(address)
+      address += <%= type.refsize %>
+    <% end %>
+    ::NamedTuple.new(<%= inner_types.map.with_index { |_, i| "#{inner_keys[i]}: v#{i}" }.join(", ") %>)
+  end
+
+  def native : ::NamedTuple(<%= inner_types.map.with_index { |type, i| "#{inner_keys[i]}: #{type.native_type_expr}" }.join(", ") %>)
+    address = data_pointer
+    <% inner_types.each_with_index do |type, i| %>
+      v<%= i %> = <%= type.crystal_class_name %>.fetch_single(address).native
+      address += <%= type.refsize %>
+    <% end %>
+    ::NamedTuple.new(<%= inner_types.map.with_index { |_, i| "#{inner_keys[i]}: v#{i}" }.join(", ") %>)
+  end
+
+  def self.memsize
+    <%= memsize %>
+  end
+
+  def self.refsize
+    <%= refsize %>
+  end
+end

data/lib/crystalruby/types/fixed_width/named_tuple.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module CrystalRuby::Types
+  NamedTuple = FixedWidth.build(error: "NamedTuple type must contain one or more symbol -> type pairs. E.g. NamedTuple(hello: Int32, world: String)")
+
+  def self.NamedTuple(types_hash)
+    raise "NamedTuple must be instantiated with a hash" unless types_hash.is_a?(Root::Hash)
+
+    types_hash.keys.each do |key|
+      raise "NamedTuple keys must be symbols" unless key.is_a?(Root::Symbol) || key.respond_to?(:to_sym)
+    end
+    keys = types_hash.keys.map(&:to_sym)
+    value_types = types_hash.values
+
+    FixedWidth.build(:NamedTuple, ffi_type: :pointer, inner_types: value_types, inner_keys: keys,
+                                  convert_if: [Root::Hash]) do
+      @data_offset = 4
+
+      # We only accept Hash-like values, which have all of the required keys
+      # and values of the correct type
+      # can successfully be cast to our inner types
+      def self.cast!(value)
+        value = value.transform_keys(&:to_sym)
+        unless value.is_a?(Hash) || value.is_a?(Root::Hash) && inner_keys.each_with_index.all? do |k, i|
+                 value.key?(k) && inner_types[i].valid_cast?(value[k])
+               end
+          raise CrystalRuby::InvalidCastError, "Cannot cast #{value} to #{inspect}"
+        end
+
+        inner_keys.map { |k| value[k] }
+      end
+
+      def self.copy_to!(values, memory:)
+        data_pointer = malloc(memsize)
+
+        memory[data_offset].write_pointer(data_pointer)
+
+        inner_types.each.reduce(0) do |offset, type|
+          type.write_single(data_pointer[offset], values.shift)
+          offset + type.refsize
+        end
+      end
+
+      def self.memsize
+        inner_types.map(&:refsize).sum
+      end
+
+      def self.each_child_address(pointer)
+        data_pointer = pointer[data_offset].read_pointer
+        inner_types.each do |type|
+          yield type, data_pointer
+          data_pointer += type.refsize
+        end
+      end
+
+      def self.offset_for(key)
+        inner_types[0...inner_keys.index(key)].map(&:refsize).sum
+      end
+
+      def value(native: false)
+        ptr = data_pointer
+        inner_keys.zip(inner_types.map do |type|
+          result = type.fetch_single(ptr, native: native)
+          ptr += type.refsize
+          result
+        end).to_h
+      end
+
+      inner_keys.each.with_index do |key, index|
+        type = inner_types[index]
+        offset = offset_for(key)
+        unless method_defined?(key)
+          define_method(key) do
+            type.fetch_single(data_pointer[offset])
+          end
+        end
+
+        unless method_defined?("#{key}=")
+          define_method("#{key}=") do |value|
+            type.write_single(data_pointer[offset], value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/crystalruby/types/fixed_width/proc.cr

@@ -0,0 +1,45 @@
+class <%= base_crystal_class_name %> < CrystalRuby::Types::FixedWidth
+
+  def initialize(inner_proc : Proc(<%= inner_types.map(&:native_type_expr).join(",") %>))
+    @memory = malloc(20) # 4 bytes RC + 2x 8 Byte Pointer
+    self.value = inner_proc
+    increment_ref_count!
+  end
+
+  def ==(other : <%= native_type_expr %>)
+    native == other
+  end
+
+  def value : Proc(<%= inner_types.map(&:crystal_type).join(",") %>)
+    func_ptr = Pointer(Void).new((@memory+4).as(Pointer(::UInt64)).value)
+    Proc(<%= inner_types.map(&:crystal_type).join(",") %>).new(func_ptr, Pointer(Void).null)
+  end
+
+  def native : Proc(<%= inner_types.map(&:crystal_type).join(",") %>)
+    value
+  end
+
+  def value=(inner_proc : Proc(<%= inner_types.map(&:native_type_expr).join(",") %>))
+    # We can't maintain a direct reference to our inner_proc within our callback
+    # as this turns it into a closure, which we cannot pass over FFI.
+    # Instead, we box the inner_proc and pass a pointer to the box to the callback.
+    # and then unbox it within the callback.
+
+    boxed_data = Box.box(inner_proc)
+
+    callback_ptr = Proc(Pointer(::UInt8), <%= inner_types.map(&:crystal_type).join(",") %>).new do |<%= inner_types.size.times.map{|i| "_v#{i}" }.join(",") %>|
+
+      inner_prc = Box(typeof(inner_proc)).unbox(_v0.as(Pointer(Void)))
+      <% inner_types.each.with_index do |inner_type, i| %>
+        <% next if i == inner_types.size - 1 %>
+        v<%= i.succ %> = <%= inner_type.crystal_class_name %>.new(_v<%= i.succ %>)<%= inner_type.anonymous? ? ".value" : "" %>
+      <% end %>
+
+      return_value = inner_prc.call(<%= inner_types.size.-(1).times.map{|i| "v#{i.succ}" }.join(",") %>)
+      <%= inner_types[-1].crystal_class_name %>.new(return_value).return_value
+    end.pointer
+
+    (@memory+4).as(Pointer(::UInt64)).value = callback_ptr.address
+    (@memory+12).as(Pointer(::UInt64)).value = boxed_data.address
+  end
+end

data/lib/crystalruby/types/fixed_width/proc.rb

@@ -0,0 +1,79 @@
+module CrystalRuby::Types
+  PROC_REGISTERY = {}
+  Proc = FixedWidth.build(error: "Proc declarations should contain a list of 0 or more comma separated argument types,"\
+    "and a single return type (or Nil if it does not return a value)")
+
+  def self.Proc(*types)
+    proc_type = FixedWidth.build(:Proc, convert_if: [::Proc], inner_types: types, ffi_type: :pointer) do
+      @data_offset = 4
+
+      def self.cast!(rbval)
+        raise "Value must be a proc" unless rbval.is_a?(::Proc)
+
+        func = FFI::Function.new(FFI::Type.const_get(inner_types[-1].ffi_type.to_s.upcase), inner_types[0...-1].map do |v|
+                                                                                              FFI::Type.const_get(v.ffi_type.to_s.upcase)
+                                                                                            end) do |*args|
+          args = args.map.with_index do |arg, i|
+            arg = inner_types[i].new(arg) unless arg.is_a?(inner_types[i])
+            inner_types[i].anonymous? ? arg.native : arg
+          end
+          return_val = rbval.call(*args)
+          return_val = inner_types[-1].new(return_val) unless return_val.is_a?(inner_types[-1])
+          return_val.memory
+        end
+        PROC_REGISTERY[func.address] = func
+        func
+      end
+
+      def self.copy_to!(rbval, memory:)
+        memory[4].write_pointer(rbval)
+      end
+
+      def invoke(*args)
+        invoker = value
+        invoker.call(memory[12].read_pointer, *args)
+      end
+
+      def value(native: false)
+        FFI::VariadicInvoker.new(
+          memory[4].read_pointer,
+          [FFI::Type::POINTER, *(inner_types[0...-1].map { |v| FFI::Type.const_get(v.ffi_type.to_s.upcase) })],
+          FFI::Type.const_get(inner_types[-1].ffi_type.to_s.upcase),
+          { ffi_convention: :stdcall }
+        )
+      end
+
+      def self.block_converter
+        <<~CRYSTAL
+          { #{
+            inner_types.size > 1 ? "|#{inner_types.size.-(1).times.map { |i| "v#{i}" }.join(",")}|" : ""
+          }
+            #{
+              inner_types[0...-1].map.with_index do |type, i|
+                <<~CRYS
+                  v#{i} = #{type.crystal_class_name}.new(v#{i}).return_value
+
+                  callback_done_channel = Channel(Nil).new
+                  result = nil
+                  if Fiber.current == Thread.current.main_fiber
+                    block_value = #{inner_types[-1].crystal_class_name}.new(__yield_to.call(#{inner_types.size.-(1).times.map { |i| "v#{i}" }.join(",")}))
+                    result = #{inner_types[-1].anonymous? ? "block_value.native" : "block_value"}
+                    next #{inner_types.last == CrystalRuby::Types::Nil ? "result" : "result.not_nil!"}
+                  else
+                    CrystalRuby.queue_callback(->{
+                      block_value = #{inner_types[-1].crystal_class_name}.new(__yield_to.call(#{inner_types.size.-(1).times.map { |i| "v#{i}" }.join(",")}))
+                      result = #{inner_types[-1].anonymous? ? "block_value.native" : "block_value"}
+                      callback_done_channel.send(nil)
+                    })
+                  end
+                  callback_done_channel.receive
+                  #{inner_types.last == CrystalRuby::Types::Nil ? "result" : "result.not_nil!"}
+                CRYS
+              end.join("\n")
+            }
+          }
+        CRYSTAL
+      end
+    end
+  end
+end