carbon-core 0.1.0

data/lib/carbon/core/pointer.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Core
+    # Defines the pointer type and functions for the Carbon Core library.
+    #
+    # @api private
+    module Pointer
+      # The pointer type name.  This is kept here to provide a shortcut to
+      # the pointer type.
+      #
+      # @return [Concrete::Type]
+      PTYPE = Carbon::Type("Carbon::Pointer<T>")
+
+      # The pointer generic type name.  This is kept here to provide a
+      # shortcut.
+      #
+      # @return [Concrete::Type]
+      PTYPEGEN = PTYPE.generics[0].name
+
+      require "carbon/core/pointer/access"
+      require "carbon/core/pointer/cast"
+      require "carbon/core/pointer/math"
+      require "carbon/core/pointer/memory"
+      require "carbon/core/pointer/type"
+
+      extend Pointer::Access
+      extend Pointer::Cast
+      extend Pointer::Math
+      extend Pointer::Memory
+      extend Pointer::Type
+
+      # Defines the pointer type and all of the pointer functions.
+      #
+      # @see #define_pointer_type
+      # @see .define_pointer_functions
+      # @return [self]
+      def self.define_pointer
+        define_pointer_type
+        define_pointer_functions
+        self
+      end
+
+      # Defines all of the pointer
+      def self.define_pointer_functions
+        define_math_functions
+        define_cast_functions
+        define_memory_functions
+        define_access_functions
+      end
+    end
+  end
+end

data/lib/carbon/core/pointer/access.rb

@@ -0,0 +1,123 @@
+# encoding: utf-8
+# frozen_string_literal: true
+# rubocop:disable Metrics/LineLength
+
+module Carbon
+  module Core
+    module Pointer
+      # Methods that perform accesses on pointers.  This is essentially
+      # dereferencing and indexing.  This defines the following functions:
+      #
+      # - `Carbon::Pointer<T>.value(self): T`
+      # - `Carbon::Pointer<T>.value=(self, value: T): T`
+      # - `Carbon::Pointer<T>.[]<I: Carbon::Numeric>(self, index: I): T`
+      # - `Carbon::Pointer<T>.[]=<I: Carbon::Numeric>(self, index: I, value: T): T`
+      #
+      # @api private
+      module Access
+        # Define all of the access functions.  This iterates over all of the
+        # integers, defining the array get/set functions in terms of each
+        # integer type.  It then defines the value get/set functions.
+        #
+        # @return [void]
+        def define_access_functions
+          Ints.each do |int|
+            next if int.size == 1
+            define_array_get_function(int)
+            define_array_set_function(int)
+          end
+          define_value_get_function
+          define_value_set_function
+        end
+
+        # Defines the value set function.  This function (named `value=`) sets
+        # the value at the pointer.  This is the same as calling the array
+        # set function with an index of zero (0).
+        #
+        # @return [void]
+        def define_value_set_function
+          function_name = PTYPE.call(:value=, [PTYPE, PTYPEGEN])
+          Core.define(function: function_name) do |function|
+            function[:return] = PTYPEGEN
+            define_value_set_definition(function[:definition])
+          end
+        end
+
+        # Defines the value get function.  This function (named `value`) gets
+        # the value at the pointer.  This is the same as calling the array
+        # get function with an index of zero (0).
+        #
+        # @return [void]
+        def define_value_get_function
+          function_name = PTYPE.call(:value, [PTYPE])
+          Core.define(function: function_name) do |function|
+            function[:return] = PTYPEGEN
+            define_value_get_definition(function[:definition])
+          end
+        end
+
+        # Defines the array set function.  This function (named `[]=`) sets
+        # the value a given distance away from the pointer.
+        #
+        # @param int [Core::Int] The integer type for the index.
+        # @return [void]
+        def define_array_set_function(int)
+          function_name = PTYPE.call(:[]=, [PTYPE, int.name, PTYPEGEN])
+          Core.define(function: function_name) do |function|
+            function[:return] = PTYPEGEN
+            define_array_set_definition(int, function[:definition])
+          end
+        end
+
+        # Defines the array get function.  This function (named `[]`) gets the
+        # value at a given distance away from the pointer.
+        #
+        # @param int [Core::Int] The integer type for the index.
+        # @return [void]
+        def define_array_get_function(int)
+          function_name = PTYPE.call(:[], [PTYPE, int.name])
+          Core.define(function: function_name) do |function|
+            function[:return] = PTYPEGEN
+            define_array_get_definition(int, function[:definition])
+          end
+        end
+
+      private
+
+        def define_array_set_definition(_int, definition)
+          entry = definition.add("entry").build
+          this, index, value = definition.params
+          this.name, index.name, value.name = %w(self index value)
+
+          entry.store(entry.gep(this, index), value)
+          entry.ret(value)
+        end
+
+        def define_array_get_definition(_int, definition)
+          entry = definition.add("entry").build
+          this, index = definition.params
+          this.name, index.name = %w(self index)
+
+          entry.ret(entry.load(entry.gep(this, index)))
+        end
+
+        def define_value_set_definition(definition)
+          entry = definition.add("entry").build
+          this, value = definition.params
+          this.name, value.name = %w(self value)
+
+          entry.store(this, value)
+          entry.ret(value)
+        end
+
+        def define_value_get_definition(definition)
+          entry = definition.add("entry").build
+          this = definition.params[0]
+          this.name = "self"
+
+          entry.ret(entry.load(this))
+        end
+      end
+    end
+  end
+end

data/lib/carbon/core/pointer/cast.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Core
+    module Pointer
+      # Performs casting for pointers.  This converts them into an integer
+      # for use in the program.  This defines the following functions on the
+      # pointer type:
+      #
+      # - `.to-int64(self): Carbon::Int64`
+      # - `.to-uint64(self): Carbon::UInt64`
+      # - `.to-int32(self): Carbon::Int32`
+      # - `.to-uint32(self): Carbon::UInt32`
+      # - `.to-int16(self): Carbon::Int16`
+      # - `.to-uint16(self): Carbon::UInt16`
+      # - `.to-int8(self): Carbon::Int8`
+      # - `.to-uint8(self): Carbon::UInt8`
+      module Cast
+        # Defines all of the cast functions for all of the integer types.
+        #
+        # @see #define_cast_function
+        # @return [void]
+        def define_cast_functions
+          Ints.each do |int|
+            next if int.size == 1
+            define_cast_function(int)
+          end
+        end
+
+        # Defines a cast function for a given integer type.
+        #
+        # @param int [Core::Int] The integer to cast the pointer to.
+        # @return [void]
+        def define_cast_function(int)
+          function_name = PTYPE.call(int.cast, [PTYPE])
+          Core.define(function: function_name) do |function|
+            function[:return] = int.name
+            define_cast_definition(int, function[:definition])
+          end
+        end
+
+      private
+
+        def define_cast_definition(int, definition)
+          entry = definition.add("entry").build
+          this = definition.params[0]
+          this.name = "self"
+
+          entry.ret(entry.ptr2int(this, int.name))
+        end
+      end
+    end
+  end
+end

data/lib/carbon/core/pointer/math.rb

@@ -0,0 +1,187 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Core
+    module Pointer
+      # Defines pointer arithmatic.  This allows for addition and subtraction,
+      # as well as comparison.  This module defines the following functions:
+      #
+      # - `.+<N: Carbon::Numeric>(self, other: N): self`
+      # - `.-<N: Carbon::Numeric>(self, other: N): self`
+      # - `.<<N: Carbon::Numeric>(self, other: N): Carbon::Boolean`
+      # - `.><N: Carbon::Numeric>(self, other: N): Carbon::Boolean`
+      # - `.<=<N: Carbon::Numeric>(self, other: N): Carbon::Boolean`
+      # - `.>=<N: Carbon::Numeric>(self, other: N): Carbon::Boolean`
+      # - `.<=><N: Carbon::Numeric>(self, other: N): Carbon::Int8`
+      # - `.<(self, other: self): Carbon::Boolean`
+      # - `.>(self, other: self): Carbon::Boolean`
+      # - `.<=(self, other: self): Carbon::Boolean`
+      # - `.>=(self, other: self): Carbon::Boolean`
+      # - `.<=>(self, other: self): Carbon::Int8`
+      #
+      # These are defined for all integers except boolean.
+      module Math
+        # The math operations that can be applied to pointers.
+        #
+        # @return [<::Symbol>]
+        MATH_OPERATIONS = %i(+ -).freeze
+
+        # The comparison operations that can be applied to pointers.
+        #
+        # @return [<::Symbol>]
+        COMP_OPERATIONS = %i(< > <= >=).freeze
+
+        # Comprehensively defines all of the math, comparison, and spaceship
+        # operations for pointers.
+        #
+        # @see #define_math_function
+        # @see #define_comp_function
+        # @see #define_space_function
+        # @see #define_comp_pointer_function
+        # @see #define_space_pointer_function
+        # @return [void]
+        def define_math_functions
+          Ints.each do |int|
+            next if int.size == 1
+            MATH_OPERATIONS.each { |op| define_math_function(int, op) }
+            COMP_OPERATIONS.each { |op| define_comp_function(int, op) }
+            define_space_function(int)
+          end
+
+          COMP_OPERATIONS.each { |op| define_comp_pointer_function(op) }
+          define_space_pointer_function
+        end
+
+        # Defines the `<=>` function for two pointers.  This returns `-1`,
+        # `0`, or `1`, if the receiver is less than, equal to, or greater than
+        # the parameter, respectively.
+        #
+        # @return [void]
+        def define_space_pointer_function
+          function_name = PTYPE.call(:<=>, [PTYPE, PTYPE])
+          Core.define(function: function_name) do |function|
+            function[:return] = Carbon::Type("Carbon::Int8")
+            define_space_pointer_definition(function[:definition])
+          end
+        end
+
+        # Defines a comparison function for two pointers.
+        #
+        # @param op [::Symbol] The operation that the function performs.
+        #   This should be one of {COMP_OPERATIONS}.
+        # @return [void]
+        def define_comp_pointer_function(op)
+          function_name = PTYPE.call(op, [PTYPE, PTYPE])
+          Core.define(function: function_name) do |function|
+            function[:return] = Carbon::Boolean
+            define_comp_pointer_definition(op, function[:definition])
+          end
+        end
+
+        # Defines the space function (`<=>`) for a pointer and an integer.
+        # It returns `-1`, `0`, or `1`, if the receiver is less than, equal to,
+        # or greater than the parameter, respectively.
+        #
+        # @param int [Core::Int] The integer type to compare to.
+        # @return [void]
+        def define_space_function(int)
+          function_name = PTYPE.call(:<=>, [PTYPE, int.name])
+          Core.define(function: function_name) do |function|
+            function[:return] = Carbon::Type("Carbon::Int8")
+            define_space_definition(int, function[:definition])
+          end
+        end
+
+        # Defines a given math function on a pointer.
+        #
+        # @param int [Core::Int] The integer type that the operation uses.
+        # @param op [::Symbol] The math operation to perform.  This should be
+        #   one of {MATH_OPERATIONS}.
+        # @return [void]
+        def define_math_function(int, op)
+          function_name = PTYPE.call(op, [PTYPE, int.name])
+          Core.define(function: function_name) do |function|
+            function[:return] = PTYPE
+            define_math_definition(int, op, function[:definition])
+          end
+        end
+
+        # Defines a given comparison operation on a pointer.
+        #
+        # @param int [Core::Int] The integer type that the operation uses.
+        # @param op [::Symbol] The comparison operation to perform.  This should
+        #   be one of {COMP_OPERATIONS}.
+        def define_comp_function(int, op)
+          function_name = PTYPE.call(op, [PTYPE, int.name])
+          Core.define(function: function_name) do |function|
+            function[:return] = Carbon::Boolean
+            define_comp_definition(int, op, function[:definition])
+          end
+        end
+
+      private
+
+        def perform_pointer_cast(entry, params, int)
+          this, other = params
+          this.name, other.name = %w(self other)
+          fname = PTYPE.call(int.cast, [PTYPE])
+          thisint = entry.call(fname, this)
+          otherint = entry.call(fname, other)
+          [thisint, otherint]
+        end
+
+        def define_space_pointer_definition(definition)
+          entry = definition.add("entry").build
+          params = definition.params
+          int = Int.find(sign: :signed, size: 64)
+          this, other = perform_pointer_cast(entry, params, int)
+
+          fname = PTYPE.call(:<=>, [int.name, int.name])
+          entry.ret(entry.call(fname, this, other))
+        end
+
+        def define_comp_pointer_definition(op, definition)
+          entry = definition.add("entry").build
+          params = definition.params
+          int = Ints.find { |i| i.sign == :signed && i.size == 64 }
+          this, other = perform_pointer_cast(entry, params, int)
+          icmp = Integer::Math::COMP_OPERATIONS_MAP.fetch([:signed, op])
+
+          entry.ret(entry.icmp(icmp, this, other))
+        end
+
+        def define_space_definition(int, definition)
+          entry = definition.add("entry").build
+          this, other = definition.params
+          this.name, other.name = %w(self other)
+
+          fname = PTYPE.call(int.cast, [PTYPE])
+          intptr = entry.call(fname, this)
+          fname = PTYPE.call(:<=>, [int.name, int.name])
+          entry.ret(entry.call(fname, intptr, other))
+        end
+
+        def define_comp_definition(int, op, definition)
+          entry = definition.add("entry").build
+          this, other = definition.params
+          this.name, other.name = %w(self other)
+
+          fname = PTYPE.call(int.cast, [PTYPE])
+          intptr = entry.call(fname, this)
+          icmp = Integer::Math::COMP_OPERATIONS_MAP.fetch([int.sign, op])
+          entry.ret(entry.icmp(icmp, intptr, other))
+        end
+
+        def define_math_definition(_int, op, definition)
+          entry = definition.add("entry").build
+          this, other = definition.params
+          this.name, other.name = %w(self other)
+          other = entry.mul(other, -1) if op == :-
+
+          entry.ret(entry.gep(this, other))
+        end
+      end
+    end
+  end
+end

data/lib/carbon/core/pointer/memory.rb

@@ -0,0 +1,85 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Core
+    module Pointer
+      # Performs memory operations on a pointer.  This is mainly alloc/free.
+      # C library functions are included in another module.  This defines
+      # the following functions on the pointer type:
+      #
+      # - `.alloc<T: Carbon::Numeric>(size: T): self`
+      # - `.free(self): Carbon::Void`
+      #
+      # These are defined for every integer except boolean.
+      module Memory
+        # Defines all of the memory functions relative to each integer type.
+        #
+        # @see #define_alloc_function
+        # @see #define_free_function
+        # @return [void]
+        def define_memory_functions
+          Ints.each do |int|
+            next if int.size == 1
+            define_alloc_function(int)
+          end
+
+          define_free_function
+        end
+
+        # Defines the `alloc` function with the given integer type as the
+        # parameter.  The `alloc` function allocates a block of memory and
+        # returns it as a pointer.
+        #
+        # @param int [Core::Int] The integer type to be used as a parameter.
+        # @return [void]
+        def define_alloc_function(int)
+          function_name = PTYPE.call(:alloc, [int.name])
+          Core.define(function: function_name) do |function|
+            function[:return] = PTYPE
+            define_alloc_definition(int, function[:definition])
+          end
+        end
+
+        # Defines the `free` function.  The `free` function frees the current
+        # pointer.
+        #
+        # @return [void]
+        def define_free_function
+          function_name = PTYPE.call(:free, [PTYPE])
+          Core.define(function: function_name) do |function|
+            function[:return] = Carbon::Type("Carbon::Void")
+            define_free_definition(function[:definition])
+          end
+        end
+
+      private
+
+        def define_alloc_definition(int, definition)
+          entry = definition.add("entry").build
+          size = definition.params[0]
+          size.name = "size"
+
+          element = entry.sizeof(PTYPEGEN)
+          size = convert_int_size(int, size, entry)
+          total = entry.mul(element, size)
+          entry.ret(entry.malloc(total))
+        end
+
+        def define_free_definition(definition)
+          entry = definition.add("entry").build
+          this = definition.params[0]
+          this.name = "self"
+          entry.free(this)
+          entry.ret_void
+        end
+
+        def convert_int_size(int, value, entry)
+          size = Int.find(sign: :unsigned, size: 64)
+          name = int.name.call(size.cast, [int.name])
+          entry.call(name, value)
+        end
+      end
+    end
+  end
+end