crystalruby 0.2.3 → 0.3.1

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

data/lib/crystalruby/types/primitive.rb

@@ -0,0 +1,117 @@
+module CrystalRuby
+  module Types
+    class Primitive < Type
+      # Primitives just store the Ruby value directly
+      # (Or read it from memory if passed a pointer)
+      def initialize(rbval)
+        super(rbval)
+        self.value = rbval.is_a?(FFI::Pointer) ? rbval.send("read_#{ffi_type}") : rbval
+      end
+
+      # Read a value from a pointer at a given index
+      # (Type can be a byte-array, pointer or numeric type)
+      def self.fetch_single(pointer, native: false)
+        # Nothing to fetch for Nils
+        return if memsize.zero?
+
+        if numeric?
+          pointer.send("read_#{ffi_type}")
+        elsif primitive?
+          single = new(pointer.send("read_#{ffi_type}"))
+          if native
+            single.value
+          else
+            single
+          end
+        end
+      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?
+
+        pointer.send("write_#{ffi_type}", to_ffi_repr(value))
+      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)
+        if numeric?
+          pointer.send("get_array_of_#{ffi_type}", 0, size)
+        elsif primitive?
+          pointer.send("get_array_of_#{ffi_type}", 0, size).map(&method(:from_ffi_array_repr))
+        end
+      end
+
+      def self.decrement_ref_count!(pointer)
+        # Do nothing
+      end
+
+      # Define a new primitive type
+      # Primitive types are stored by value
+      # and efficiently copied using native FFI types
+      # They are written directly into the memory of a container type
+      #  (No indirection)
+      def self.build(
+        typename = nil,
+        ffi_type: :uint8,
+        memsize: FFI.type_size(ffi_type),
+        convert_if: [],
+        error: nil,
+        superclass: Primitive,
+        &block
+      )
+        Class.new(superclass) do
+          %w[typename ffi_type memsize convert_if error].each do |name|
+            define_singleton_method(name) { binding.local_variable_get("#{name}") }
+            define_method(name) { binding.local_variable_get("#{name}") }
+          end
+
+          class_eval(&block) if block_given?
+
+          # Primitives are stored directly in memory as a raw numeric value
+          def self.to_ffi_repr(value)
+            new(value).inner_value
+          end
+
+          def self.refsize
+            memsize
+          end
+
+          # Primiives are anonymous (Shouldn't be subclassed)
+          def self.anonymous?
+            true
+          end
+
+          def self.copy_to!(rbval, memory:)
+            memory.send("write_#{self.ffi_type}", to_ffi_repr(rbval))
+          end
+
+          def self.primitive?
+            true
+          end
+
+          def self.inspect
+            inspect_name
+          end
+
+          def memory
+            @value
+          end
+
+          def self.crystal_supertype
+            "CrystalRuby::Types::Primitive"
+          end
+        end
+      end
+    end
+  end
+end
+
+require_relative "primitive_types/time"
+require_relative "primitive_types/symbol"
+require_relative "primitive_types/numbers"
+require_relative "primitive_types/nil"
+require_relative "primitive_types/bool"

data/lib/crystalruby/types/primitive_types/bool.cr

@@ -0,0 +1,34 @@
+class <%= base_crystal_class_name %> < CrystalRuby::Types::Primitive
+
+  def initialize(value : ::Bool)
+    @value = value ? 1_u8 : 0_u8
+  end
+
+  def initialize(ptr : Pointer(::UInt8))
+    @value = ptr[0]
+  end
+
+  def initialize(value : UInt8)
+    @value = value
+  end
+
+  def value=(value : ::Bool)
+    @value = value ? 1_u8 : 0_u8
+  end
+
+  def value : <%= native_type_expr %>
+    @value == 1_u8
+  end
+
+  def ==(other : ::Bool)
+    value == other
+  end
+
+  def self.memsize
+    <%= memsize %>
+  end
+
+  def self.write_single(pointer : Pointer(::UInt8), value)
+    pointer.as(Pointer(::UInt8)).value = value ? 1_u8 : 0_u8
+  end
+end

data/lib/crystalruby/types/primitive_types/bool.rb

@@ -0,0 +1,11 @@
+module CrystalRuby::Types
+  Bool = Primitive.build(:Bool, convert_if: [::TrueClass, ::FalseClass], ffi_type: :uint8, memsize: 1) do
+    def value(native: false)
+      super == 1
+    end
+
+    def value=(val)
+      !!val && val != 0 ? super(1) : super(0)
+    end
+  end
+end

data/lib/crystalruby/types/primitive_types/nil.cr

@@ -0,0 +1,35 @@
+class <%= base_crystal_class_name %> < CrystalRuby::Types::Primitive
+
+  property value : ::Nil = nil
+
+  def initialize(nilval : ::Nil)
+  end
+
+  def initialize(ptr : Pointer(::UInt8))
+  end
+
+  def initialize(raw : UInt8)
+  end
+
+  def value : ::Nil
+    nil
+  end
+
+  def ==(other : ::Nil)
+    value.nil?
+  end
+
+  def value=(val : ::Nil)
+  end
+
+  def self.memsize
+    0
+  end
+
+  def return_value
+    0_u8
+  end
+
+  def self.write_single(pointer : Pointer(::UInt8), value)
+  end
+end

data/lib/crystalruby/types/primitive_types/nil.rb

@@ -0,0 +1,16 @@
+module CrystalRuby::Types
+  Nil = Primitive.build(:Nil, convert_if: [::NilClass], memsize: 0) do
+    def initialize(val = nil)
+      super
+      @value = 0
+    end
+
+    def nil?
+      true
+    end
+
+    def value(native: false)
+      nil
+    end
+  end
+end