carbon-core 0.1.0

data/lib/carbon/concrete/type/part.rb

@@ -0,0 +1,100 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Concrete
+    class Type
+      # A single part of the type.  This only contains the name of the part,
+      # and the generics for the part.  For most parts, the generics are
+      # ignored (or even stripped; see {#strip}).
+      #
+      # @note
+      #   **This class is frozen upon initialization.**  This means that any
+      #   attempt to modify it will result in an error.  In most cases, the
+      #   attributes on this class will also be frozen, as well.
+      class Part
+        # The value of the part.  This is normally the lexeme or the string
+        # associated with the part.
+        #
+        # @api public
+        # @example
+        #   type = Carbon::Type("Carbon::Pointer<T>")
+        #   part = type.name.last
+        #   part.value # => "Pointer"
+        # @return [::String] The value.
+        attr_reader :value
+
+        # The generics of the part.  This is normally an empty array unless
+        # it is both the last part of a name, and contain generic information
+        # from the original source text.
+        #
+        # @api public
+        # @example
+        #   type = Carbon::Type("Carbon::Pointer<T>")
+        #   type.name.first.generics # => []
+        #   type.name.last.generics # => [#<Carbon::Concrete::Type::Generic T>]
+        # @return [<Type::Generic>] The generics.
+        attr_reader :generics
+
+        # Initialize the part with the given value and generics.
+        #
+        # @see #value
+        # @see #generics
+        # @param value [::String] The value.
+        # @param generics [<Type::Generic>] The generics.
+        def initialize(value, generics)
+          @value = value
+          @generics = generics
+          deep_freeze!
+        end
+
+        # Strips the part.  This returns a new part with all of the generic
+        # information removed.  During parsing, this is applied to all parts
+        # except the last part of the name, since the generics for the parts
+        # except the last are ignored.
+        #
+        # @api public
+        # @example
+        #   type = Carbon::Type("Carbon::Pointer<T>")
+        #   part = type.name.last
+        #   part.generics.map(&:to_s) # => ["T"]
+        #   part.strip.generics.map(&:to_s) # => []
+        # @return [Part] The new part.
+        def strip
+          Part.new(value, [])
+        end
+
+        # Returns the interned value of this part.  This contains no generic
+        # information, and as such, is the same as the value of the part.
+        #
+        # @api public
+        # @example
+        #   type = Carbon::Type("Carbon::Pointer<T>")
+        #   type.name.last.intern # => "Pointer"
+        # @note See {Item::Base#intern} For more information about interned
+        #   names.
+        # @return [::String] The interned value of this part.
+        def intern
+          value
+        end
+
+        # Returns a string representation of this part.  This contains all of
+        # the generic information, if it exists; otherwise, it is the same as
+        # {#intern}.
+        #
+        # @api public
+        # @example
+        #   type = Carbon::Type("Carbon::Pointer<T>")
+        #   type.name.last.to_s # => "Pointer<T>"
+        # @return [::String] The string representation of the part.
+        def to_s
+          if @generics.any?
+            "#{@value}<#{@generics.map(&:to_s).join(', ')}>".freeze
+          else
+            @value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/carbon/core.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "pathname"
+
+module Carbon
+  # The Carbon Core library.  This is the library that is loaded for every
+  # program, and contains definitions that cannot be defined from within
+  # Carbon.  The Carbon Core library is required for any Carbon program
+  # to function.
+  #
+  # @api private
+  module Core
+    PATH = Pathname.new(File.expand_path("../core/core.clib", __FILE__))
+    # The core index.  This can either be loaded from a core library file or
+    # from the definitions in this library.
+    #
+    # @return [Concrete::Index] The Carbon Core library index.
+    def self.index
+      @index ||= find
+    end
+
+    # Defines an item on the core index.
+    #
+    # @see .index
+    # @see Concrete::Index#define
+    # @api semipublic
+    # @example (see Concrete::Index#define)
+    # @param (see Concrete::Index#define)
+    # @yield (see Concrete::Index#define)
+    # @yieldparam (see Concrete::Index#define)
+    # @raise (see Concrete::Index#define)
+    # @return (see Concrete::Index#define)
+    def self.define(*options, &block)
+      index.define(*options, &block)
+    end
+
+    # Finalizes the index by defining all of the types on it.
+    #
+    # @api private
+    # @return [void]
+    def self.finalize
+      Core::Integer.define_integer
+      Core::Pointer.define_pointer
+      index
+    end
+
+    def self.find
+      if PATH.exist?
+        Concrete.load(PATH.read)
+      else
+        @index = Concrete::Index.new
+        finalize.tap { |i| PATH.write(Concrete.dump(i)) }
+      end
+    end
+
+    require "carbon/core/int"
+    require "carbon/core/integer"
+    require "carbon/core/pointer"
+  end
+end

data/lib/carbon/core/int.rb

@@ -0,0 +1,87 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Core
+    # An integer type in Carbon.  The integer types are kept in here in order
+    # to keep track of the properties of each integer type.
+    #
+    # @api private
+    class Int
+      # The name of the integer type.
+      #
+      # @api public
+      # @example
+      #   int.name # => #<Carbon::Concrete::Type Carbon::Boolean>
+      # @return [Carbon::Concrete::Type] The name.
+      attr_reader :name
+
+      # The name of the function that casts another integer to this one.
+      #
+      # @api public
+      # @example
+      #   int.cast # => "to-bool"
+      # @return [::String] The cast function name.
+      attr_reader :cast
+
+      # The signage of the integer type.  This is either `:signed` or
+      # `:unsigned`.  `:signed` implies two's compliment.
+      #
+      # @api public
+      # @example
+      #   int.sign # => :unsigned
+      # @return [::Symbol] How the integer is signed.
+      attr_reader :sign
+
+      # The number of bits in the integer.  This is normally a power of two.
+      #
+      # @api public
+      # @example
+      #   int.size # => 1
+      # @return [::Integer] The size of the integer.
+      attr_reader :size
+
+      # Finds a specific integer with the given size and signage.  Uses
+      # {Ints} as the base.
+      #
+      # @param size [::Integer] The size of the integer.
+      # @param sign [::Symbol] How the integer should be signed.
+      # @return [Int] If an integer with the given size and signage is found.
+      # @return [nil] Otherwise.
+      def self.find(size:, sign:)
+        Ints.find { |i| i.size == size && i.sign == sign }
+      end
+
+      # Initialize the int.
+      #
+      # @param name [Carbon::Concrete::Type] The type of the integer.
+      # @param cast [::String] The cast function name.
+      # @param sign [::Symbol] How the integer is signed.
+      # @param size [::Integer] The size of the integer, in bits.
+      def initialize(name, cast, sign, size)
+        @name = name
+        @cast = cast
+        @sign = sign
+        @size = size
+
+        deep_freeze!
+      end
+    end
+
+    # The integeral types that are defined in Carbon, and all information
+    # pertaining to them.
+    #
+    # @return [<Int>]
+    Ints = [
+      ["Carbon::Int64", "to-int64", :signed, 64],
+      ["Carbon::UInt64", "to-uint64", :unsigned, 64],
+      ["Carbon::Int32", "to-int32", :signed, 32],
+      ["Carbon::UInt32", "to-uint32", :unsigned, 32],
+      ["Carbon::Int16", "to-int16", :signed, 16],
+      ["Carbon::UInt16", "to-uint16", :unsigned, 16],
+      ["Carbon::Int8", "to-int8", :signed, 8],
+      ["Carbon::UInt8", "to-uint8", :unsigned, 8],
+      ["Carbon::Boolean", "to-bool", :unsigned, 1]
+    ].map { |a| Int.new(Carbon::Type(a[0]), *a[1..-1]) }.deep_freeze!
+  end
+end

data/lib/carbon/core/integer.rb

@@ -0,0 +1,109 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "carbon/core/integer/cast"
+require "carbon/core/integer/math"
+require "carbon/core/integer/misc"
+require "carbon/core/integer/pole"
+require "carbon/core/integer/ship"
+require "carbon/core/integer/sign"
+require "carbon/core/integer/type"
+require "carbon/core/integer/zero"
+
+module Carbon
+  module Core
+    # Manages all Integer definitions for the Core library.  This includes
+    # all nine (9) types and all 1298 integer functions.
+    #
+    # @api private
+    module Integer
+      extend Integer::Cast
+      extend Integer::Math
+      extend Integer::Misc
+      extend Integer::Pole
+      extend Integer::Ship
+      extend Integer::Sign
+      extend Integer::Type
+      extend Integer::Zero
+
+      class << self
+        # Defines all integer definitions on the Core library.  This just calls
+        # {.define_integer_types} and {.define_integer_functions}.
+        #
+        # @api private
+        # @see #define_integer_types
+        # @see .define_integer_functions
+        # @return [self]
+        def define_integer
+          define_integer_types
+          define_integer_functions
+          self
+        end
+
+        # Defines all integer functions on the Core library.
+        #
+        # @api private
+        # @see #define_cast_function
+        # @see #define_math_functions
+        # @see #define_comp_functions
+        # @see #define_ship_function
+        # @see #define_next_function
+        # @see #define_prev_function
+        # @see #define_iabs_function
+        # @see #define_size_function
+        # @see #define_even_function
+        # @see #define_odd_function
+        # @see #define_positive_function
+        # @see #define_negative_function
+        # @see #define_sign_function
+        # @see #define_zero_function
+        # @see #define_nonzero_function
+        # @return [void]
+        def define_integer_functions
+          performed = Set.new
+          Ints.product(Ints).each do |(first, second)|
+            define_integer_functions_pair(first, second)
+            define_integer_functions_one(first) unless performed.include?(first)
+            performed << first
+          end
+        end
+
+      private
+
+        def define_integer_functions_pair(first, second)
+          define_cast_function(first, second) unless second.size == 1
+          return if first.size == 1 || second.size == 1
+
+          define_math_functions(first, second)
+          define_comp_functions(first, second)
+          define_ship_function(first, second)
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def define_integer_functions_one(first)
+          define_bool_function(first)
+          return if first.size == 1
+
+          # MISC
+          define_next_function(first)
+          define_prev_function(first)
+          define_iabs_function(first)
+          define_size_function(first)
+
+          # POLE
+          define_even_function(first)
+          define_odd_function(first)
+          define_positive_function(first)
+          define_negative_function(first)
+
+          # SIGN
+          define_sign_functions(first)
+
+          # ZERO
+          define_zero_function(first)
+          define_nonzero_function(first)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Core
+    module Integer
+      # Defines cast functions for integers.  This applies to all integers.
+      # This guarentees that the following functions exist on all integers:
+      #
+      # - `.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`
+      #
+      # These functions upcast and downcast as nessicary, but use the sign of
+      # the original number to determine how the casting should be handled.
+      # For example, an `Int32` is upcast to a `UInt64` using the
+      # sign-extension instruction; however, a `UInt32` is upcast to a `Int32`
+      # using the zero-extension instruction.  This is to keep the same number
+      # as the value, but just converted to a longer number.  This is in line
+      # with the behavior of C.
+      #
+      # @api private
+      module Cast
+        # Defines a cast function for a single pair of integers.
+        #
+        # @param from [Core::Int] The source integer.
+        # @param to [Core::Int] The destination integer.
+        # @return [void]
+        def define_cast_function(from, to)
+          function_name = from.name.call(to.cast, [from.name])
+          Core.define(function: function_name) do |function|
+            function[:return] = to.name
+            perform_cast(from, to, function[:definition])
+          end
+        end
+
+      private
+
+        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/MethodLength
+        def perform_cast(from, to, definition)
+          entry = definition.add("entry").build
+          this = definition.params[0]
+          this.name = "self"
+
+          # from <=> to -> from - to
+          case [from.sign, from.size <=> to.size]
+          when [:unsigned, 0], [:signed, 0]
+            sidecast(entry, this, to.name)
+          when [:unsigned, 1], [:signed, 1]
+            downcast(entry, this, to.name)
+          when [:unsigned, -1]
+            upcast_unsigned(entry, this, to.name)
+          when [:signed, -1]
+            upcast_signed(entry, this, to.name)
+          else fail # no way you can get here
+          end
+        end
+
+        def upcast_signed(entry, this, to)
+          entry.ret(entry.sext(this, to))
+        end
+
+        def upcast_unsigned(entry, this, to)
+          entry.ret(entry.zext(this, to))
+        end
+
+        def downcast(entry, this, to)
+          entry.ret(entry.trunc(this, to))
+        end
+
+        def sidecast(entry, this, to)
+          entry.ret(entry.int_cast(this, to))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,198 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Core
+    module Integer
+      # Defines math operations on almost all integers except booleans.
+      # Provides the following methods on all integer types except booleans:
+      #
+      # - `.+<T: Carbon::Numeric>(self, T: other): self`
+      # - `.-<T: Carbon::Numeric>(self, T: other): self`
+      # - `.*<T: Carbon::Numeric>(self, T: other): self`
+      # - `./<T: Carbon::Numeric>(self, T: other): self`
+      # - `.%<T: Carbon::Numeric>(self, T: other): self`
+      # - `.|<T: Carbon::Numeric>(self, T: other): self`
+      # - `.&<T: Carbon::Numeric>(self, T: other): self`
+      # - `.<<<T: Carbon::Numeric>(self, T: other): self`
+      # - `.>><T: Carbon::Numeric>(self, T: other): self`
+      # - `.^<T: Carbon::Numeric>(self, T: other): self`
+      # - `.==<T: Carbon::Numeric>(self, T: other): Carbon::Boolean`
+      # - `.===<T: Carbon::Numeric>(self, T: other): Carbon::Boolean`
+      # - `.<<T: Carbon::Numeric>(self, T: other): Carbon::Boolean`
+      # - `.><T: Carbon::Numeric>(self, T: other): Carbon::Boolean`
+      # - `.<=<T: Carbon::Numeric>(self, T: other): Carbon::Boolean`
+      # - `.>=<T: Carbon::Numeric>(self, T: other): Carbon::Boolean`
+      #
+      # Note that the core library never actually uses generics.  Instead,
+      # all math operations are defined relative to another integer, and
+      # overloading is used to match to the right function.  For example,
+      # `Int32.+(Int32, Int8)` is a different function than
+      # `Int32.+(Int32, UInt8)`; the functions use no actual generics.
+      #
+      # @api private
+      module Math
+        # The math operations that can be performed.  Note that for LLVM,
+        # `:/`, `:%`, and `:>>` are sign-dependant.
+        #
+        #
+        # @return [<::Symbol>]
+        MATH_OPERATIONS = %i(+ - * / % | & << >> ^).freeze
+
+        # The comparison operations that can be performed.  Note that for
+        # LLVM, `:<`, `:>`, `:<=`, and `:>=` are sign-dependant.
+        #
+        # @return [<::Symbol>]
+        COMP_OPERATIONS = %i(== === < > <= >=).freeze
+
+        # A mapping of comparison operations to their _icmp_ equivalents.
+        # Since most of the _icmp_ values are sign-dependant, the keys also
+        # contain sign information.
+        #
+        # @return [{(::Symbol, ::Symbol) => ::Symbol}]
+        COMP_OPERATIONS_MAP = {
+          [:unsigned, :==] => :eq, [:signed, :==] => :eq,
+          [:unsigned, :===] => :eq, [:signed, :===] => :eq,
+          [:unsigned, :<] => :ult, [:signed, :<] => :slt,
+          [:unsigned, :>] => :ugt, [:signed, :>] => :sgt,
+          [:unsigned, :<=] => :ule, [:signed, :<=] => :sle,
+          [:unsigned, :>=] => :uge, [:signed, :>=] => :sge
+        }.deep_freeze!
+
+        # Defines all of the math functions.  The left and right integer types
+        # are given, and the {MATH_OPERATIONS} are iterated over, providing
+        # the operator for the {#define_math_function} method.
+        #
+        # @param left [Core::Int] The left (receiver) value.
+        # @param right [Core::Int] The right value.
+        # @return [void]
+        def define_math_functions(left, right)
+          MATH_OPERATIONS.each { |op| define_math_function(left, right, op) }
+        end
+
+        # Defines all of the comparison functinos.  The left and right integer
+        # types are given, and the {COMP_OPERATIONS} are iterated over,
+        # providing the operator for the {#define_comp_function} method.
+        #
+        # @param left [Core::Int] The left (receiver) value.
+        # @param right [Core::Int] The right value.
+        # @return [void]
+        def define_comp_functions(left, right)
+          COMP_OPERATIONS.each { |op| define_comp_function(left, right, op) }
+        end
+
+        # Defines a math function.  The left and right integer types are given,
+        # as well as the specific operation.
+        #
+        # @param left [Core::Int] The left (receiver) value.
+        # @param right [Core::Int] The right value.
+        # @param op [::Symbol] The mathmatical operation.  One of
+        #   {MATH_OPERATIONS}.
+        # @return [void]
+        def define_math_function(left, right, op)
+          function_name = left.name.call(op, [left.name, right.name])
+          Core.define(function: function_name) do |function|
+            function[:return] = left.name
+            define_math_definition(left, right, op, function[:definition])
+          end
+        end
+
+        # Defines a compare function.  The left and right integer types are
+        # given, as well as the specific operation.
+        #
+        # @param left [Core::Int] The left (receiver) value.
+        # @param right [Core::Int] The right value.
+        # @param op [::Symbol] The comparison operation.  One of
+        #   {COMP_OPERATIONS}.
+        # @return [void]
+        def define_comp_function(left, right, op)
+          function_name = left.name.call(op, [left.name, right.name])
+          Core.define(function: function_name) do |function|
+            function[:return] = Carbon::Boolean
+            define_comp_definition(left, right, op, function[:definition])
+          end
+        end
+
+      private
+
+        def define_comp_definition(left, right, op, definition)
+          entry = definition.add("entry").build
+          params = definition.params
+          params[0].name, params[1].name = %w(self other)
+          this, other = force_same_cast(params, entry, left, right)
+          icmp = COMP_OPERATIONS_MAP.fetch(left.sign, op)
+          entry.ret(entry.icmp(icmp, this, other))
+        end
+
+        def define_math_definition(left, right, op, definition)
+          entry = definition.add("entry").build
+          params = definition.params
+          params[0].name, params[1].name = %w(self other)
+          this, other = force_same_cast(params, entry, left, right)
+          result = perform_operation(entry, [this, other], left, op)
+          return_original_size(entry, result, left, right)
+        end
+
+        OPERATIONS = {
+          :+ => :add, :- => :sub, :| => :or, :& => :and, :* => :mul,
+          :"^" => :xor, :<< => :shl
+        }.freeze
+
+        def perform_operation(entry, params, left, op)
+          if OPERATIONS.key?(op)
+            entry.public_send(OPERATIONS[op], *params)
+          elsif op == :>> then right_shift(entry, params, left)
+          elsif op == :/  then divide(entry, params, left)
+          elsif op == :%  then remainder(entry, params, left)
+          else fail # Not possible.
+          end
+        end
+
+        def right_shift(entry, params, left)
+          case left.sign
+          when :unsigned then entry.lshr(*params)
+          when :signed   then entry.ashr(*params)
+          end
+        end
+
+        def divide(entry, params, left)
+          case left.sign
+          when :unsigned then entry.udiv(*params)
+          when :signed   then entry.sdiv(*params)
+          end
+        end
+
+        def remainder(entry, params, left)
+          case left.sign
+          when :unsigned then entry.urem(*params)
+          when :signed   then entry.srem(*params)
+          end
+        end
+
+        def return_original_size(entry, result, left, right)
+          size = left.size <=> right.size
+          return entry.ret(result) if size == 0 || size == 1
+
+          type = Int.find(size: right.size, sign: left.sign)
+          fname = type.name.call(left.cast, [type.name])
+          entry.call(fname, result)
+        end
+
+        def force_same_cast(params, entry, left, right)
+          lcall, rcall = find_size(left, right)
+          [entry.call(lcall, params[0]),
+            entry.call(rcall, params[1])]
+        end
+
+        def find_size(left, right)
+          sign = left.sign
+          size = [left.size, right.size].max
+          fname = sign == :unsigned ? "to-uint#{size}" : "to-int#{size}"
+
+          [left.name.call(fname, [left.name]),
+            right.name.call(fname, [right.name])]
+        end
+      end
+    end
+  end
+end