crystalruby 0.2.2 → 0.3.0

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,109 @@
+# 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(: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

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module CrystalRuby::Types
+  Tuple = FixedWidth.build(
+    :Tuple,
+    error: "Tuple type must contain one or more types E.g. Tuple(Int32, String)"
+  )
+
+  def self.Tuple(*types)
+    FixedWidth.build(:Tuple, inner_types: types, convert_if: [Root::Array], superclass: Tuple) do
+      @data_offset = 4
+
+      # 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)
+        unless (value.is_a?(Array) || value.is_a?(Tuple) || value.is_a?(Root::Array)) && value.zip(inner_types).each do |v, t|
+                 t && t.valid_cast?(v)
+               end && value.length == inner_types.length
+          raise CrystalRuby::InvalidCastError, "Cannot cast #{value} to #{inspect}"
+        end
+
+        value
+      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.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.memsize
+        inner_types.map(&:refsize).sum
+      end
+
+      def size
+        inner_types.size
+      end
+
+      def checked_offset!(index, size)
+        raise "Index out of bounds: #{index} >= #{size}" if index >= size
+
+        if index < 0
+          raise "Index out of bounds: #{index} < -#{size}" if index < -size
+
+          index += size
+        end
+        self.class.offset_for(index)
+      end
+
+      def self.offset_for(index)
+        inner_types[0...index].map(&:refsize).sum
+      end
+
+      # Return the element at the given index.
+      # This will automatically increment
+      # the reference count if not a primitive type.
+      def [](index)
+        inner_types[index].fetch_single(data_pointer[checked_offset!(index, size)])
+      end
+
+      # Overwrite the element at the given index
+      # The replaced element will have
+      # its reference count decremented.
+      def []=(index, value)
+        inner_types[index].write_single(data_pointer[checked_offset!(index, size)], value)
+      end
+
+      def value(native: false)
+        ptr = data_pointer
+        inner_types.map do |type|
+          result = type.fetch_single(ptr, native: native)
+          ptr += type.refsize
+          result
+        end
+      end
+    end
+  end
+end

data/lib/crystalruby/types/fixed_width.cr

@@ -0,0 +1,138 @@
+module CrystalRuby
+  module Types
+    # For a fixed width type, we allocate a single block block of memory of the form
+    # [ref_count (uint32), data(uint8*)]
+    class FixedWidth < Type
+
+      # We can instantiate it with a Value (for a new object)
+      # or a Pointer (for a copy of an existing object)
+      macro inherited
+        def initialize(@memory : Pointer(::UInt8))
+          increment_ref_count!
+        end
+      end
+
+      def finalize
+        self.class.decrement_ref_count!(@memory)
+      end
+
+      def increment_ref_count!
+        self.class.increment_ref_count!(@memory)
+      end
+
+      def self.increment_ref_count!(memory, by=1)
+        as_int32_ptr = memory.as(Pointer(::UInt32))
+        synchronize{ as_int32_ptr[0] += by }
+      end
+
+      def self.decrement_ref_count!(memory, by=1)
+        as_int32_ptr = memory.as(Pointer(::UInt32))
+        synchronize{ as_int32_ptr[0] -= by }
+        free!(memory) if as_int32_ptr[0] == 0
+      end
+
+      def self.refsize
+        8
+      end
+
+
+      def self.free!(memory)
+        # Decrease ref counts for any data we are pointing to
+        # Also responsible for freeing internal memory if ref count reaches zero
+        decr_inner_ref_counts!(memory)
+        # # Free slot memory
+        free(memory)
+      end
+
+      def self.decr_inner_ref_counts!(pointer)
+        self.each_child_address(pointer) do |child_type, child_address|
+          child_type.decrement_ref_count!(child_address.read_pointer)
+        end
+        # Free data block, if we're a variable with type.
+        as_pointer_ref = (pointer+data_offset).as(Pointer(Pointer(::UInt8)))
+        free(as_pointer_ref[0]) if variable_width?
+      end
+
+      def self.variable_width?
+        false
+      end
+
+      # Ref count is always the first UInt32 in the memory block
+      def ref_count
+        memory.as(Pointer(::UInt32))[0]
+      end
+
+      def ref_count=(val)
+        memory.as(Pointer(::UInt32))[0] = value
+      end
+
+      # Data pointer follows the ref count (and size for variable width types)
+      # In the case of variable width types the data pointer points to the start of a separate data block
+      # So this method is overridden inside variable_width.rb to resolve this pointer.
+      def data_pointer : Pointer(UInt8)
+        (memory + data_offset)
+      end
+
+      # Create a brand new copy of this object
+      def deep_dup
+        self.class.new(value)
+      end
+
+      # Create a new reference to this object.
+      def dup
+        self.class.new(@memory)
+      end
+
+      def address
+        memory.address
+      end
+
+      def data_offset
+        self.class.data_offset
+      end
+
+      def memsize
+        self.class.memsize
+      end
+
+      def size_offset
+        self.class.size_offset
+      end
+
+      def self.size_offset
+        4
+      end
+
+      def self.data_offset
+        4
+      end
+
+      # Read a value of this type from the
+      # contained pointer at a given index
+      def self.fetch_single(pointer : Pointer(::UInt8))
+        value_pointer = pointer.as(Pointer(Pointer(::UInt8)))
+        new(value_pointer.value)
+      end
+
+      # Write a data type into a pointer at a given index
+      # (Type can be a byte-array, pointer or numeric type
+      #
+      # )
+      def self.write_single(pointer, value)
+        value_pointer = pointer.as(Pointer(Pointer(::UInt8)))
+        if !value_pointer[0].null?
+          decrement_ref_count!(value_pointer[0])
+        end
+        memory = malloc(self.data_offset + self.memsize)
+
+        self.copy_to!(value, memory)
+        value_pointer.value = memory
+        increment_ref_count!(memory)
+      end
+
+      # Fetch an array of a given data type from a list pointer
+      # (Type can be a byte-array, pointer or numeric type)
+
+    end
+  end
+end

data/lib/crystalruby/types/fixed_width.rb

@@ -0,0 +1,205 @@
+module CrystalRuby
+  module Types
+    # For a fixed width type, we allocate a single block block of memory of the form
+    # [ref_count (uint32), data(uint8*)]
+    class FixedWidth < Type
+      # We can instantiate it with a Value (for a new object)
+      # or a Pointer (for a copy of an existing object)
+      def initialize(rbval)
+        super
+        case rbval
+        when FFI::Pointer then allocate_new_from_reference!(rbval)
+        else allocate_new_from_value!(rbval)
+        end
+        self.class.increment_ref_count!(memory)
+        ObjectSpace.define_finalizer(self, self.class.finalize(memory))
+      end
+
+      def self.finalize(memory)
+        lambda { |_|
+          decrement_ref_count!(memory)
+        }
+      end
+
+      def allocate_new_from_value!(rbval)
+        # New block of memory, to hold our object.
+        # For variable with, this is 2x UInt32 for ref count and size, plus a data pointer (8 bytes)
+        # Layout:
+        # - ref_count (4 bytes)
+        # - size (4 bytes)
+        # - data (8 bytes)
+        #
+        # For fixed the data is inline
+        # Layout:
+        # - ref_count (4 bytes)
+        # - size (0 bytes) (No size for fixed width types)
+        # - data (memsize bytes)
+        self.memory = malloc(refsize + data_offset)
+        self.value = rbval
+      end
+
+      def allocate_new_from_reference!(memory)
+        # When we point to an existing block of memory, we don't need to allocate anything.
+        # This memory should be to a single, separately allocated block of the above size.
+        # When this type is contained within another type, it should be as a pointer to this block (not the contents of the block itself).
+        self.memory = memory
+      end
+
+      # Each type should be convertible to an FFI representation. (I.e. how is a value or reference to this value stored
+      # within e.g. an Array, Hash, Tuple or any other containing type).
+      # For both fixed and variable types these are simply stored within
+      # the containing type as a pointer to the memory block.
+      # We return the pointer to this memory here.
+      def self.to_ffi_repr(value)
+        to_store = new(value)
+        increment_ref_count!(to_store.memory)
+        to_store.memory
+      end
+
+      # Read a value of this type from the
+      # contained pointer at a given index
+      def self.fetch_single(pointer, native: false)
+        # Nothing to fetch for Nils
+        return if memsize.zero?
+
+        value_pointer = pointer.read_pointer
+        native ? new(value_pointer).native : new(value_pointer)
+      end
+
+      # Write a data type into a pointer at a given index
+      # (Type can be a byte-array, pointer or numeric type
+      #
+      # )
+      def self.write_single(pointer, value)
+        # Dont need to write nils
+        return if memsize.zero?
+
+        decrement_ref_count!(pointer.read_pointer) unless pointer.read_pointer.null?
+        memory = malloc(refsize + data_offset)
+        copy_to!(cast!(value), memory: memory)
+        increment_ref_count!(memory)
+        pointer.write_pointer(memory)
+      end
+
+      # Fetch an array of a given data type from a list pointer
+      # (Type can be a byte-array, pointer or numeric type)
+      def self.fetch_multi(pointer, size, native: false)
+        size.times.map { |i| fetch_single(pointer[i * refsize], native: native) }
+      end
+
+      def self.increment_ref_count!(memory, by = 1)
+        synchronize { memory.write_int32(memory.read_int32 + by) }
+      end
+
+      def self.decrement_ref_count!(memory, by = 1)
+        synchronize { memory.write_int32(memory.read_int32 - by) }
+        return unless memory.read_int32.zero?
+
+        free!(memory)
+      end
+
+      def self.free!(memory)
+        # Decrease ref counts for any data we are pointing to
+        # Also responsible for freeing internal memory if ref count reaches zero
+        decr_inner_ref_counts!(memory)
+
+        # # Free slot memory
+        free(memory)
+      end
+
+      def self.decr_inner_ref_counts!(pointer)
+        each_child_address(pointer) do |child_type, child_address|
+          child_type.decrement_ref_count!(child_address.read_pointer) if child_type.fixed_width?
+        end
+        # Free data block, if we're a variable width type.
+        return unless variable_width?
+
+        free(pointer[data_offset].read_pointer)
+      end
+
+      # Ref count is always the first Int32 in the memory block
+      def ref_count
+        memory.read_uint32
+      end
+
+      def ref_count=(val)
+        memory.write_int32(val)
+      end
+
+      # Data pointer follows the ref count (and size for variable width types)
+      # In the case of variable width types the data pointer points to the start of a separate data block
+      # So this method is overridden inside variable_width.rb to resolve this pointer.
+      def data_pointer
+        memory[data_offset].read_pointer
+      end
+
+      def size
+        memory[size_offset].read_int32
+      end
+
+      def address
+        @memory.address
+      end
+
+      def self.crystal_supertype
+        "CrystalRuby::Types::FixedWidth"
+      end
+
+      def self.crystal_type
+        "Pointer(::UInt8)"
+      end
+
+      # If we are fixed with,
+      # The memory we allocate a single block of memory, if not already given.
+      # Within this block of memory, we copy our contents directly.
+      #
+      # If we are variable width, we allocate a small block of memory for the pointer only
+      # and allocate a separate block of memory for the data.
+      # We store the pointer to the data in the memory block.
+
+      def value=(value)
+        # If we're already pointing at something
+        # Decrement the ref counts of anything we're pointing at
+        value = cast!(value)
+
+        self.class.decr_inner_ref_counts!(memory) if ref_count > 0
+        self.class.copy_to!(value, memory: memory)
+      end
+
+      # Build a new FixedWith subtype
+      # Layout varies according to the sizes of internal types
+      def self.build(
+        typename = nil,
+        error: nil,
+        inner_types: nil,
+        inner_keys: nil,
+        ffi_type: :pointer,
+        memsize: FFI.type_size(ffi_type),
+        refsize: 8,
+        convert_if: [],
+        superclass: FixedWidth,
+        size_offset: 4,
+        data_offset: 4,
+        &block
+      )
+        inner_types&.each(&Type.method(:validate!))
+
+        Class.new(superclass) do
+          bind_local_vars!(
+            %i[typename error inner_types inner_keys ffi_type memsize convert_if size_offset data_offset
+               refsize], binding
+          )
+          class_eval(&block) if block_given?
+
+          def self.fixed_width?
+            true
+          end
+        end
+      end
+    end
+  end
+end
+require_relative "fixed_width/proc"
+require_relative "fixed_width/named_tuple"
+require_relative "fixed_width/tuple"
+require_relative "fixed_width/tagged_union"

data/lib/crystalruby/types/primitive.cr

@@ -0,0 +1,21 @@
+module CrystalRuby
+  module Types
+    class Primitive < Type
+      def return_value
+        @value
+      end
+
+      def native
+        value
+      end
+
+      def self.fetch_single(pointer : Pointer(::UInt8))
+        new(pointer)
+      end
+
+      def self.refsize
+        self.memsize
+      end
+    end
+  end
+end