carbon-core 0.1.0

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

@@ -0,0 +1,145 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Core
+    module Integer
+      # Defines a set of miscellaneous functions.  These functions are various
+      # functions that don't fit in any of the other category.  These functions
+      # include:
+      #
+      # - `.next(self): self`
+      # - `.succ(self): self`
+      # - `.abs(self): self`
+      # - `.prev(self): self`
+      # - `.pred(self): self`
+      # - `.to-bool(self): self`
+      # - `.size(): Carbon::UInt32`
+      # - `.size(self): Carbon::UInt32`
+      #
+      # These functions are defined on all of the integer types except boolean.
+      # However, `.size` is also defined on boolean.
+      #
+      # @api private
+      module Misc
+        # Defines the "to boolean" function for the given integer type.  This
+        # just returns the result of comparison of the number to zero (returns
+        # 0 if the number is zero, 1 otherwise).
+        #
+        # @param int [Core::Int] The (receiver) value.
+        # @return [void]
+        def define_bool_function(int)
+          function_name = int.name.call("to-bool", [int.name])
+          Core.define(function: function_name) do |function|
+            function[:return] = int.name
+            function[:definition].add("entry").build do |b|
+              this = function[:definition].params[0]
+              this.name = "self"
+              b.ret(b.icmp(:ne, this, 0))
+            end
+          end
+        end
+
+        # Define the next functions for the given integer type.  These
+        # functions just return the given number incremented by one.  This is
+        # implemented without any calls.  This function defines both the
+        # `.next` and `.succ` functions.
+        #
+        # @param int [Core::Int] The (receiver) value.
+        # @return [void]
+        def define_next_function(int)
+          %w(next succ).each do |name|
+            function_name = int.name.call(name, [int.name])
+            Core.define(function: function_name) do |function|
+              function[:return] = int.name
+              define_next_definition(function[:definition])
+            end
+          end
+        end
+
+        # Define the previous functions for the given integer type.  These
+        # functions just return the given number decremented by one.  This is
+        # implemented without any calls.  This function defines both the
+        # `.prev` and `.pred` functions.
+        #
+        # @param int [Core::Int] The (receiver) value.
+        # @return [void]
+        def define_prev_function(int)
+          %w(prev pred).each do |name|
+            function_name = int.name.call(name, [int.name])
+            Core.define(function: function_name) do |function|
+              function[:return] = int.name
+              define_prev_definition(function[:definition])
+            end
+          end
+        end
+
+        # Define the absolute value function.  For signed integers, it returns
+        # the absolute (positive) value of an integer; for unsigned integers,
+        # it returns itself.
+        #
+        # @param int [Core::Int] The (receiver) value.
+        # @return [void]
+        def define_iabs_function(int)
+          function_name = int.name.call("abs", [int.name])
+          Core.define(function: function_name) do |function|
+            function[:return] = int.name
+            define_iabs_definition(int, function[:definition])
+          end
+        end
+
+        # Defines the size function.  This returns the size of the integer, in
+        # bits.
+        #
+        # @param int [Core::Int] The (receiver) integer type.
+        # @return [void]
+        def define_size_function(int)
+          [[], [int.name]].each do |args|
+            function_name = int.name.call("size", args)
+            Core.define(function: function_name) do |function|
+              function[:return] = Carbon::Type("Carbon::UInt32")
+              define_size_definition(int, function[:definition])
+            end
+          end
+        end
+
+      private
+
+        def define_next_definition(definition)
+          entry = definition.add("entry").build
+          this = definition.params[0]
+          this.name = "self"
+
+          entry.ret(entry.add(this, 1))
+        end
+
+        def define_prev_definition(definition)
+          entry = definition.add("entry").build
+          this = definition.params[0]
+          this.name = "self"
+
+          entry.ret(entry.sub(this, 1))
+        end
+
+        def define_iabs_definition(int, definition)
+          entry = definition.add("entry").build
+          this = definition.params[0]
+          this.name = "self"
+
+          if int.sign == :unsigned
+            entry.ret(this)
+          else
+            y = entry.ashr(this, int.size - 1)
+            entry.ret(entry.sub(entry.xor(this, y), y))
+          end
+        end
+
+        def define_size_definition(int, definition)
+          entry = definition.add("entry").build
+
+          entry.ret(int.size)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,133 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Core
+    module Integer
+      # Defines "polarity" functions.  This means positive/negative or
+      # odd/even.  This defines the following functions:
+      #
+      # - `.positive?(self): Carbon::Boolean`
+      # - `.negative?(self): Carbon::Boolean`
+      # - `.even?(self): Carbon::Boolean`
+      # - `.odd?(self): Carbon::Boolean`
+      #
+      # These functions are defined on all integer types except boolean.
+      # That includes `.positive?` and `.negative?`, which has no meaning on
+      # an unisgned integer (see {#define_positive_function} and
+      # {#define_negative_function} for how unsigned integers are handled).
+      #
+      # @api private
+      module Pole
+        # Defines the positive function.  The function (named `positive?`)
+        # returns a boolean value; if the receiver is greater than or equal to
+        # zero, the function returns `true`; otherwise, the function returns
+        # `false`.  This provides a special case for unsigned integers: all
+        # unsigned integers are always positive, so this function returns
+        # `true` for unsigned integers.  For signed integers, it checks the
+        # sign bit (`lshr %i, (sub %i.size, 1)`).
+        #
+        # @param int [Core::Int] The (receiver) value.
+        # @return [void]
+        def define_positive_function(int)
+          function_name = int.name.call("positive?", [int.name])
+          Core.define(function: function_name) do |function|
+            function[:return] = Carbon::Boolean
+            define_positive_definition(int, function[:definition])
+          end
+        end
+
+        # Defines the negative function.  The function (named `negative?`)
+        # returns a boolean value; if the receiver is less than zero, the
+        # function returns `true`; otherwise, the function returns `false`.
+        # This provides a special case for unsigned integers: all unsigned
+        # integers are always positive, so this function returns `false` for
+        # unsigned integers.  For signed integers, it checks the sign bit
+        # (`xor (lshr %i, (sub %i.size, 1)), 1`).
+        #
+        # @param int [Core::Int] The (receiver) value.
+        # @return [void]
+        def define_negative_function(int)
+          function_name = int.name.call("negative?", [int.name])
+          Core.define(function: function_name) do |function|
+            function[:return] = Carbon::Boolean
+            define_negative_definition(int, function[:definition])
+          end
+        end
+
+        # Defines the even function.  The function (named `even?`) returns a
+        # boolean value; if the receiver is even (i.e. evenly divisible by
+        # two), the function returns `true`; otherwise, the function returns
+        # `false`.  It performs the check by checking the least significant
+        # bit (`trunc %i to i1`).
+        #
+        # @param int [Core::Int] The (receiver) value.
+        # @return [void]
+        def define_even_function(int)
+          function_name = int.name.call("even?", [int.name])
+          Core.define(function: function_name) do |function|
+            function[:return] = Carbon::Boolean
+            define_even_definition(int, function[:definition])
+          end
+        end
+
+        # Defines the odd function.  The function (named `odd?`) returns a
+        # boolean value; if the receiver is odd (i.e. not evenly divisible
+        # by two), the function returns `true`; otherwise, the function returns
+        # `false`.  It performs the check by checking the least significant
+        # bit (`xor (trunc %i to i1), 1`).
+        #
+        # @param int [Core::Int] The (receiver) value.
+        # @return [void]
+        def define_odd_function(int)
+          function_name = int.name.call("odd?", [int.name])
+          Core.define(function: function_name) do |function|
+            function[:return] = Carbon::Boolean
+            define_odd_definition(int, function[:definition])
+          end
+        end
+
+      private
+
+        def define_positive_definition(int, definition)
+          entry = definition.add("entry").build
+          this = definition.params[0]
+          this.name = "self"
+
+          return entry.ret(1) if int.sign == :unsigned
+          sign = entry.lshr(this, int.size - 1)
+          trunc = entry.trunc(sign, Carbon::Boolean)
+          entry.ret(trunc)
+        end
+
+        def define_negative_definition(int, definition)
+          entry = definition.add("entry").build
+          this = definition.params[0]
+          this.name = "self"
+
+          return entry.ret(0) if int.sign == :unsigned
+          sign = entry.lshr(this, int.size - 1)
+          trunc = entry.trunc(sign, Carbon::Boolean)
+          negate = entry.xor(trunc, 1)
+          entry.ret(negate)
+        end
+
+        def define_even_definition(_int, definition)
+          entry = definition.add("entry").build
+          this = definition.params[0]
+          this.name = "self"
+
+          entry.ret(entry.xor(entry.trunc(this, Carbon::Boolean), 1))
+        end
+
+        def define_odd_definition(_int, definition)
+          entry = definition.add("entry").build
+          this = definition.params[0]
+          this.name = "self"
+
+          entry.ret(entry.trunc(this, Carbon::Boolean))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Core
+    module Integer
+      # Defines the "spaceship" function on all integers except booleans.  The
+      # spaceship operator compares two integers, and returns three possible
+      # values depending on the order of the integers: `1` if the receiver
+      # (`this`) is greater than the right (`other`), `0` if `this` is equal
+      # to `other`, and `-1` if `this` is less than `other`.  This is useful
+      # for determining the order of things.  This module defines a single
+      # function on all integers except boolean:
+      #
+      # - `.<=><T: Carbon::Numeric>(self, other: T): Carbon::Int8`
+      #
+      # The function returns `Carbon::Int8` because it is the smallest possible
+      # integer type that retains sign information.
+      module Ship
+        # Defines the spaceship function (`:<=>`).  The left and right integer
+        # types are given.  The spaceship function works the same as the one
+        # in Ruby:
+        #
+        # - If the left value is less than the right value, return -1;
+        #   otherwise,
+        # - If the left value is equal to the right value, return 0;
+        #   otherwise,
+        # - The left value is greater than the right value, return 1.
+        #
+        # @param left [Core::Int] The left (receiver) value.
+        # @param right [Core::Int] The right value.
+        # @return [void]
+        def define_ship_function(left, right)
+          return if left.size == 1 || right.size == 1
+          function_name = left.name.call(:<=>, [left.name, right.name])
+          Core.define(function: function_name) do |function|
+            function[:return] = Carbon::Type("Carbon::Int8")
+            define_ship_definition(left, right, function[:definition])
+          end
+        end
+
+      private
+
+        def define_ship_definition(left, right, definition)
+          blocks =
+            %w(entry this<other this!<other this=other this>other)
+              .map { |n| definition.add(n) }
+          params = definition.params
+          params[0].name, params[1].name = %w(self other)
+          params = force_same_cast(params, blocks[0].build, left, right)
+
+          define_ship_definition_returns(blocks)
+          define_ship_definition_compare(params, blocks)
+        end
+
+        def define_ship_definition_returns(blocks)
+          blocks[1].build.ret(1)
+          blocks[3].build.ret(0)
+          blocks[4].build.ret(-1)
+        end
+
+        def define_ship_definition_compare(params, blocks)
+          blocks[0]
+            .build { |b| b.br(b.icmp(:lt, *params), blocks[1], blocks[2]) }
+          blocks[2]
+            .build { |b| b.br(b.icmp(:eq, *params), blocks[4], blocks[5]) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Core
+    module Integer
+      # Defines signage functions.  This can be used to determine if an integer
+      # is signed or unsigned.  This defines the following functions on all
+      # integers except boolean:
+      #
+      # - `.signed?(): Carbon::Boolean`
+      # - `.signed?(self): Carbon::Boolean`
+      # - `.unsigned?(): Carbon::Boolean`
+      # - `.unsigned?(self): Carbon::Boolean`
+      #
+      # @api private
+      module Sign
+        # Defines the sign functions on the given integer.  This produces the
+        # four variants of the sign functions: signed vs. unsigned, and
+        # no vs. one parameter.
+        #
+        # @param int [Core::Int] The (receiver) value.
+        # @return [void]
+        def define_sign_functions(int)
+          params = [[], [int.name]]
+          signs = [:signed, :unsigned]
+          params.product(signs).each do |(param, sign)|
+            define_sign_function(int, sign, param)
+          end
+        end
+
+        # Defines a sign function.  If the integer is the same sign as the
+        # given sign, the defined function returns `true`; otherwise, it
+        # returns `false`.
+        #
+        # @param int [Core::Int] The (receiver) value.
+        # @param sign [::Symbol] The sign function to define.
+        # @param args [<Concrete::Type>] The arguments that the function
+        #   takes.  These are ignored.
+        def define_sign_function(int, sign, args)
+          function_name = int.name.call("#{sign}?", args)
+          Core.define(function: function_name) do |function|
+            function[:return] = Carbon::Boolean
+            function[:definition].add("entry").build do |b|
+              int.sign == sign ? b.ret(1) : b.ret(0)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Core
+    module Integer
+      # Defines the integer types.  This uses the {Core::Ints} list to
+      # determine the integer types that will be defined, and defines them with
+      # the `:internal` type.  This defines the following integer types:
+      #
+      # - `Carbon::Int8`, `Carbon::UInt8`
+      # - `Carbon::Int16`, `Carbon::UInt16`
+      # - `Carbon::Int32`, `Carbon::UInt32`
+      # - `Carbon::Int64`, `Carbon::UInt64`
+      #
+      # @api private
+      module Type
+        # Defines all of the integer types.
+        #
+        # @return [void]
+        def define_integer_types
+          Ints.each { |int| define_integer_type(int) }
+        end
+
+        # Defines the integer type for the given integer information.  All
+        # integers implement both the `Carbon::Sized` and `Carbon::Numeric`
+        # traits.
+        #
+        # @param int [Core::Int] The integer type.
+        # @return [void]
+        def define_integer_type(int)
+          Core.define(internal: int.name) do |internal|
+            internal[:kind] = :integer
+            internal[:size] = int.size
+            internal[:implements] << Carbon::Type("Carbon::Sized")
+            internal[:implements] << Carbon::Type("Carbon::Numeric")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Core
+    module Integer
+      # Defines zero functions.  These can be used to determine if an integer
+      # is (or isn't) zero.  This defines all of these functions on all
+      # integers except booleans:
+      #
+      # - `.zero?(self): Carbon::Boolean`
+      # - `.nonzero?(self): Carbon::Boolean`
+      #
+      # @api private
+      module Zero
+        # Defines the zero function.  The function returns `true` if the value
+        # is equal to zero.
+        #
+        # @param int [Core::Int] The (receiver) value.
+        # @return [void]
+        def define_zero_function(int)
+          function_name = int.name.call("zero?", [int.name])
+          Core.define(function: function_name) do |function|
+            function[:return] = Carbon::Boolean
+            function[:definition].add("entry").build do |b|
+              this = function[:definition].params[0]
+              this.name = "self"
+              b.ret(b.icmp(:eq, this, 0))
+            end
+          end
+        end
+
+        # Defines the nonzero function.  The function returns `true` if the
+        # value isn't equal to zero.
+        #
+        # @param int [Core::Int] The (receiver) value.
+        # @return [void]
+        def define_nonzero_function(int)
+          function_name = int.name.call("nonzero?", [int.name])
+          Core.define(function: function_name) do |function|
+            function[:return] = Carbon::Boolean
+            function[:definition].add("entry").build do |b|
+              this = function[:definition].params[0]
+              this.name = "self"
+              b.ret(b.icmp(:ne, this, 0))
+            end
+          end
+        end
+      end
+    end
+  end
+end