crystalruby 0.2.3 → 0.3.1

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

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

@@ -0,0 +1,53 @@
+class <%= base_crystal_class_name %> < CrystalRuby::Types::FixedWidth
+
+  def initialize(value : <%= native_type_expr %>)
+    @memory = malloc(data_offset + <%= memsize %>_u64)
+    self.value = value
+    increment_ref_count!
+  end
+
+  def value=(value : <%= native_type_expr %>)
+    self.class.copy_to!(value, @memory)
+  end
+
+  def ==(other : <%= native_type_expr %>)
+    native == other
+  end
+
+  def value
+    data_pointer = @memory + data_offset
+    case data_pointer.value
+    <% union_types.each_with_index do |type, index| %>
+      when <%= index %>
+      <%= type.crystal_class_name %>.fetch_single(data_pointer+1)
+    <% end %>
+    else raise "Invalid union type #{data_pointer.value}"
+    end
+  end
+
+  def native
+    data_pointer = @memory + data_offset
+    case data_pointer.value
+    <% union_types.each_with_index do |type, index| %>
+      when <%= index %>
+      <%= type.crystal_class_name %>.fetch_single(data_pointer+1).native
+    <% end %>
+    else raise "Invalid union type #{data_pointer.value}"
+    end
+  end
+
+  def self.copy_to!(value : <%= native_type_expr %>, ptr : Pointer(::UInt8))
+    data_pointer = ptr + data_offset
+    case value
+    <% union_types.each_with_index do |type, index| %>
+      when <%= type.native_type_expr %>
+        data_pointer[0] = <%= index %>
+        <%= type.crystal_class_name %>.write_single(data_pointer + 1, value)
+    <% end %>
+    end
+  end
+
+  def self.memsize
+    <%= memsize %>
+  end
+end

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module CrystalRuby::Types
+  TaggedUnion = Class.new(Type) { @error = "Union type must be instantiated from one or more concrete types" }
+
+  def self.TaggedUnion(*union_types)
+    Class.new(FixedWidth) do
+      # We only accept List-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)
+        casteable_type_index = union_types.find_index do |type, _index|
+          next false unless type.valid_cast?(value)
+
+          type.cast!(value)
+          next true
+        rescue StandardError
+          nil
+        end
+        unless casteable_type_index
+          raise CrystalRuby::InvalidCastError,
+                "Cannot cast #{value}:#{value.class} to #{inspect}"
+        end
+
+        [casteable_type_index, value]
+      end
+
+      def value(native: false)
+        type = self.class.union_types[data_pointer.read_uint8]
+        type.fetch_single(data_pointer[1], native: native)
+      end
+
+      def nil?
+        value.nil?
+      end
+
+      def ==(other)
+        value == other
+      end
+
+      def self.copy_to!((type_index, value), memory:)
+        memory[data_offset].write_int8(type_index)
+        union_types[type_index].write_single(memory[data_offset + 1], value)
+      end
+
+      def data_pointer
+        memory[data_offset]
+      end
+
+      def self.each_child_address(pointer)
+        pointer += data_offset
+        type = self.union_types[pointer.read_uint8]
+        yield type, pointer[1]
+      end
+
+      def self.inner_types
+        union_types
+      end
+
+      define_singleton_method(:memsize) do
+        union_types.map(&:refsize).max + 1
+      end
+
+      def self.refsize
+        8
+      end
+
+      def self.typename
+        "TaggedUnion"
+      end
+
+      define_singleton_method(:union_types) do
+        union_types
+      end
+
+      define_singleton_method(:valid?) do
+        union_types.all?(&:valid?)
+      end
+
+      define_singleton_method(:error) do
+        union_types.map(&:error).join(", ") if union_types.any?(&:error)
+      end
+
+      define_singleton_method(:inspect) do
+        if anonymous?
+          union_types.map(&:inspect).join(" | ")
+        else
+          crystal_class_name
+        end
+      end
+
+      define_singleton_method(:native_type_expr) do
+        union_types.map(&:native_type_expr).join(" | ")
+      end
+
+      define_singleton_method(:named_type_expr) do
+        union_types.map(&:named_type_expr).join(" | ")
+      end
+
+      define_singleton_method(:type_expr) do
+        anonymous? ? native_type_expr : name
+      end
+
+      define_singleton_method(:data_offset) do
+        4
+      end
+
+      define_singleton_method(:valid_cast?) do |raw|
+        union_types.any? { |type| type.valid_cast?(raw) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+class <%= base_crystal_class_name %> < CrystalRuby::Types::FixedWidth
+
+  def initialize(tuple : ::Tuple(<%= inner_types.map(&:native_type_expr).join(',') %>))
+    @memory = malloc(data_offset + 8)
+    self.value = tuple
+    increment_ref_count!
+  end
+
+  def data_pointer
+    Pointer(::UInt8).new((@memory + data_offset).as(Pointer(::UInt64)).value)
+  end
+
+  def [](index : Int)
+    index += size if index < 0
+    <% 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 %>) if <%= i %> == index
+    <% end %>
+  end
+
+  <% inner_types.each_with_index.group_by{|t,i| t.native_type_expr }.each do |(native_type_expr, types_width_index)| %>
+  def []=(index : Int, value : <%= native_type_expr %>)
+    index += size if index < 0
+    <% types_width_index.each do |type, i| %>
+      return <%= type.crystal_class_name %>.write_single(data_pointer + <%= offset_for(i) %>, value) if <%= i %> == index
+    <% end %>
+    raise ArgumentError.new("Index out of bounds")
+  end
+  <% end %>
+
+  def ==(other : ::Tuple(<%= inner_types.map(&:native_type_expr).join(',') %>))
+    value == other
+  end
+
+  def value=(tuple : ::Tuple(<%= inner_types.map(&:native_type_expr).join(',') %>))
+    self.class.copy_to!(tuple, @memory)
+  end
+
+  def self.copy_to!(tuple : ::Tuple(<%= inner_types.map(&: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[<%= i %>])
+      data_pointer += <%= type.refsize %>
+    <% end %>
+
+    (memory+data_offset).as(Pointer(::UInt64)).value = address
+  end
+
+  def ==(other : <%= native_type_expr %>)
+    native == other
+  end
+
+  def value : ::Tuple(<%= inner_types.map(&:native_type_expr).join(',') %>)
+    address = data_pointer
+    <% inner_types.each_with_index do |type, i| %>
+      v<%= i %> = <%= type.crystal_class_name %>.fetch_single(address)
+      address += <%= type.refsize %>
+    <% end %>
+    ::Tuple.new(<%= inner_types.map.with_index { |_, i| "v#{i}" }.join(", ") %>)
+  end
+
+  def native : ::Tuple(<%= inner_types.map(&: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 %>
+    ::Tuple.new(<%= inner_types.map.with_index { |_, i| "v#{i}" }.join(", ") %>)
+  end
+
+  def self.memsize
+    <%= memsize %>
+  end
+
+  def self.refsize
+    <%= refsize %>
+  end
+end