carbon-core 0.1.0 → 0.1.1

data/lib/carbon/tacky/instruction/generation.rb

@@ -0,0 +1,90 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Tacky
+    class Instruction  < Value
+      # Generation logic for instructions.
+      module Generation
+
+      private
+
+        # Generates a "normal" instruction.  It maps the parameters, then sends
+        # the instruction over to a builder for LLVM, before returning the
+        # result of the instruction.
+        #
+        # @param context [Tacky::Context] The context.
+        # @param block [::LLVM::BasicBlock] The block.
+        # @return [::LLVM::Value] The result of the llvm instruction.
+        def generate_normal(context, block)
+          params = mapped_parameters(context)
+          value = nil
+
+          block.build { |b| value = b.public_send(@instruction, *params) }
+          value
+        end
+
+        def generate_null(context, _block)
+          params = mapped_parameters(context)
+          context.find(params.first).null
+        end
+
+        def generate_sizeof(context, _block)
+          params = mapped_parameters(context)
+          context.find(params.first).size
+        end
+
+        def generate_typeof(context, block)
+          context.find(typeof_value(@parameters.first, context))
+        end
+
+        # [Concrete::Type, String | Symbol, *Value]
+        def generate_mcall(context, block)
+          mod, name = @parameters[0..1]
+          types = @parameters[2..-1].map { |p| typeof_value(p, context) }
+          fname = mod.call(name, types)
+          item, func = context.functions.fetch(fname)
+          params = @parameters[2..-1].map { |p| mapped_parameter(p, context) }
+          result = nil
+
+          block.build { |b| result = b.call(func, *params) }
+          context.type(result, item.return)
+        end
+
+        # [Value, String | Symbol, *Value]
+        def generate_ucall(context, block)
+          mod = typeof_value(@parameters[0], context, block)
+          name = @parameters[1]
+          types = @parameters[2..-1].map { |p| typeof_value(p, context) }
+          fname = mod.call(name, [mod, *types])
+          item, func = context.functions.fetch(fname)
+          params = [@parameters[0], *@parameters[2..-1]]
+            .map { |p| mapped_parameter(p, context) }
+          result = nil
+
+          block.build { |b| result = b.call(func, params) }
+          concrete.type(result, item.return)
+        end
+
+        def mapped_parameters(context)
+          @parameters.map { |p| mapped_parameter(p, context) }
+        end
+
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def mapped_parameter(param, context)
+          case param
+          when Concrete::Type   then context.find(param)
+          when Tacky::Reference then context.instructions.fetch(param.id)
+          when Tacky::Parameter then context.params.fetch(param.value)
+          when Tacky::Typed     then mapped_parameter(param.value, context)
+          when ::Integer then LLVM.Int(param)
+          when ::Float then LLVM.Float(param)
+          when ::String then param
+          else fail ArgumentError, "Unexpected parameter #{param.class}"
+          end
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+      end
+    end
+  end
+end

data/lib/carbon/tacky/instruction/typeof.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Tacky
+    class Instruction < Value
+      module Typeof
+        # rubocop:disable Metrics/CyclomaticComplexity
+        def typeof_value(value, context)
+          case value
+          when Concrete::Type   then value
+          when Tacky::Reference then fail NotImplementedError
+          when Tacky::Parameter then context.function.params[value.value].type
+          when Tacky::Typed     then value.type
+          when ::Integer        then Carbon::Type("Carbon::Int32")
+          when ::Float          then Carbon::Type("Carbon::Float")
+          when ::String         then Carbon::Type("Carbon::String")
+          else fail ArgumentError, "Cannot typeof #{value.class}"
+          end
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity
+      end
+    end
+  end
+end

data/lib/carbon/tacky/reference.rb

@@ -18,6 +18,10 @@ module Carbon
       def initialize(id)
         @id = id
       end
+
+      def as(type)
+        Tacky::Typed.new(self, type)
+      end
     end
   end
 end

data/lib/carbon/tacky/typed.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module Carbon
+  module Tacky
+    Typed = Struct.new(:value, :type) do
+      INT32 = Carbon::Type("Carbon::Int32")
+      STRING = Carbon::Type("Carbon::String")
+      FLOAT = Carbon::Type("Carbon::Float")
+
+      def self.from(value)
+        case value
+        when Concrete::Type, Tacky::Typed then value
+        when Tacky::Parameter             then new(value, value.type)
+        when Tacky::Reference             then fail NotImplementedError
+        when Tacky::Block                 then nil
+        when ::Integer                    then new(value, INT32)
+        when ::Float                      then new(value, FLOAT)
+        when ::String, ::Symbol           then new(value, STRING)
+        else fail ArgumentError, "Cannot guess type for #{value.class}"
+        end
+      end
+    end
+  end
+end

data/lib/carbon/version.rb

@@ -5,5 +5,5 @@ module Carbon
   # The version of Carbon.
   #
   # @return [::String]
-  VERSION = "0.1.0".freeze
+  VERSION = "0.1.1".freeze
 end

data/scripts/core.rb

@@ -0,0 +1,9 @@
+# coding: utf-8
+# frozen_string_literal: true
+lib = File.expand_path("../../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "pry"
+require "pry/rescue"
+require "carbon"
+
+index = Carbon::Core.index

data/scripts/test.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+# frozen_string_literal: true
+
+lib = File.expand_path("../../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "ruby-prof"
+require "pry"
+require "pry/rescue"
+require "carbon"
+
+Pry.rescue do
+  index = Carbon::Core.finalize
+  add = index.fetch("Carbon::UInt32.+(Carbon::UInt32, Carbon::Int32)")
+  build = Carbon::Concrete::Build.new(index.build(add), index)
+
+  build.call
+  puts build.module
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: carbon-core
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Jeremy Rodi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-07-25 00:00:00.000000000 Z
+date: 2016-08-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -67,19 +67,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.1'
 - !ruby/object:Gem::Dependency
-  name: msgpack
+  name: oj
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '2.17'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '2.17'
 - !ruby/object:Gem::Dependency
   name: ice_nine
   requirement: !ruby/object:Gem::Requirement
@@ -111,6 +111,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- Vagrantfile
 - carbon.gemspec
 - lib/carbon.rb
 - lib/carbon/concrete.rb
@@ -155,10 +156,16 @@ files:
 - lib/carbon/tacky/context.rb
 - lib/carbon/tacky/function.rb
 - lib/carbon/tacky/instruction.rb
+- lib/carbon/tacky/instruction/dependencies.rb
+- lib/carbon/tacky/instruction/generation.rb
+- lib/carbon/tacky/instruction/typeof.rb
 - lib/carbon/tacky/parameter.rb
 - lib/carbon/tacky/reference.rb
+- lib/carbon/tacky/typed.rb
 - lib/carbon/tacky/value.rb
 - lib/carbon/version.rb
+- scripts/core.rb
+- scripts/test.rb
 homepage: https://github.com/carbon-lang/core
 licenses:
 - MIT