comet-build 0.1.2

data/lib/comet/parser.rb

@@ -0,0 +1,114 @@
+module Comet
+  class Parser
+    include Comet::DSL::Helpers
+    alias inject instance_exec
+
+    def software(name, depends:, &block)
+      raise "software `#{name}' redefined" if @software.key? name
+      @software[name] = DSL::Software.new(name, depends: depends, &block)
+    end
+
+    def hardware(name, targets:, &block)
+      if hardware_defined? name, targets
+        raise "hardware `#{name}' redefined for `#{targets}'"
+      end
+      @hardware[name].push DSL::Hardware.new(name, targets: targets, &block)
+    end
+
+    def firmware(name, imports:, &block)
+      raise "firmware `#{name}' redefined" if firmware_defined? name
+      @firmware.push DSL::Firmware.new(name, imports: imports, &block)
+    end
+
+    def array_hash
+      Hash.new { |h, k| h[k] = [] }
+    end
+
+    def plain_hash
+      {}
+    end
+
+    def initialize(filename)
+      @software = plain_hash
+      @hardware = array_hash
+      @firmware = []
+      @filename = filename
+    end
+
+    attr_reader :filename
+
+    def targets
+      parse_file! if @targets.nil?
+      @targets ||= compute_targets
+    end
+
+    def compute_targets
+      @firmware.flat_map do |firmware|
+        firmware.validate!
+
+        firmware.targets.map do |device|
+          [firmware, device]
+        end
+      end
+    end
+
+    private
+
+    def resolve_dependencies!(firmware)
+      seen = {}
+
+      firmware.imports = firmware.imports.flat_map do |name|
+        resolve! name, seen
+      end
+    end
+
+    def resolve!(name, seen)
+      if seen[name] == :temporary
+        raise "circular dependency involving `#{name}' detected"
+      end
+
+      object = object_by_name name
+      return object if seen[name] == :permanent
+      resolve_software! name, object, seen if @software.key? name
+      seen[name] = :permanent
+
+      object
+    end
+
+    def resolve_software!(name, software, seen)
+      seen[name] = :temporary
+      software.depends = software.depends.flat_map do |dependency|
+        resolve! dependency, seen
+      end
+    end
+
+    def object_by_name(name)
+      if @software[name].nil? && @hardware[name].empty?
+        raise "software or hardware `#{name}' undefined"
+      end
+
+      @software[name] || @hardware[name]
+    end
+
+    def resolve_all_dependencies!
+      @firmware.each do |firmware|
+        resolve_dependencies! firmware
+      end
+    end
+
+    def parse_file!
+      instance_eval File.read(@filename)
+      resolve_all_dependencies!
+    end
+
+    def hardware_defined?(name, targets)
+      @hardware[name].any? do |hardware|
+        hardware.targets == targets
+      end
+    end
+
+    def firmware_defined?(name)
+      @firmware.map(&:name).include? name
+    end
+  end
+end

data/lib/comet/rules/alias.rb

@@ -0,0 +1,29 @@
+module Comet
+  module Rules
+    class Alias
+      def initialize(name, dependencies)
+        @name = name
+        @dependencies = dependencies
+      end
+
+      def target
+        @name
+      end
+
+      def contents
+        [
+          ".PHONY: #{target}",
+          "#{target}: #{@dependencies.map(&:target).uniq.join ' '}"
+        ]
+      end
+
+      def rules
+        []
+      end
+
+      def commands
+        {}
+      end
+    end
+  end
+end

data/lib/comet/rules/build.rb

@@ -0,0 +1,118 @@
+module Comet
+  module Rules
+    class Build
+      def initialize(firmware, device)
+        @firmware = firmware
+        @device = device
+      end
+
+      def target
+        @target ||= Comet::Makefile.fingerprint Hash[
+          dependencies: Set[rules.map(&:target).uniq]
+        ], extension: :phony
+      end
+
+      def contents
+        contents = [
+          ".PHONY: #{target}",
+          "#{target}: #{rules.map(&:target).uniq.join ' '}"
+        ]
+
+        if fw_target.elf?
+          contents.push "\t$(COMET_CP) #{link.target} #{fw_target.elf_output.path}"
+        end
+
+        if fw_target.bin?
+          contents.push "\t$(COMET_CP) #{bin.target} #{fw_target.bin_output.path}"
+        end
+
+        if fw_target.hex?
+          contents.push "\t$(COMET_CP) #{hex.target} #{fw_target.hex_output.path}"
+        end
+
+        if fw_target.map?
+          contents.push "\t$(COMET_CP) #{link.map_file} #{fw_target.map_output.path}"
+        end
+
+        contents
+      end
+
+      def rules
+        @rules ||= [link, bin, hex].compact
+      end
+
+      def commands
+        { COMET_CP: 'cp' }
+      end
+
+      private
+
+      def fw_target
+        @firmware.target_for @device
+      end
+
+      def bin
+        ObjCopy.new linker, link, 'binary', 'bin' if fw_target.bin?
+      end
+
+      def hex
+        ObjCopy.new linker, link, 'ihex', 'hex' if fw_target.hex?
+      end
+
+      def link
+        @link ||= Link.new linker, codegen, libraries, native_sources
+      end
+
+      def linker
+        @firmware.hardware_for(@device).detect(&:linker?).linker_
+      end
+
+      def native_sources
+        @firmware.hardware_for(@device).flat_map do |hardware|
+          hardware.sources.select(&:native?).flat_map(&:files)
+        end
+      end
+
+      def libraries
+        @firmware.hardware_for(@device).flat_map(&:libraries).uniq(&:name)
+      end
+
+      def codegen
+        @codegen ||= Codegen.new linker, merge
+      end
+
+      def merge
+        @merge ||= Merge.new compile
+      end
+
+      def compile
+        @compile ||= @firmware.imports.flat_map do |software|
+          compile_software software
+        end
+      end
+
+      def compile_software(software)
+        software.depends.flat_map do |depends|
+          if depends.is_a? Comet::DSL::Software
+            compile_software depends
+          else
+            compile_hardware depends
+          end
+        end + software.sources.reject(&:native?).flat_map do |source|
+          source.files.map do |file|
+            Compile.new source, file, linker
+          end
+        end
+      end
+
+      def compile_hardware(hardware)
+        return [] unless hardware.targets == @device
+        hardware.sources.reject(&:native?).flat_map do |source|
+          source.files.map do |file|
+            Compile.new source, file, linker
+          end
+        end
+      end
+    end
+  end
+end

data/lib/comet/rules/clean.rb

@@ -0,0 +1,29 @@
+module Comet
+  module Rules
+    class Clean
+      def initialize(folder)
+        @folder = folder
+      end
+
+      def target
+        'clean'
+      end
+
+      def contents
+        [
+          ".PHONY: #{target}",
+          "#{target}:",
+          "\t$(COMET_RM) -rf #{@folder}"
+        ]
+      end
+
+      def rules
+        []
+      end
+
+      def commands
+        { COMET_RM: 'rm' }
+      end
+    end
+  end
+end

data/lib/comet/rules/codegen.rb

@@ -0,0 +1,51 @@
+module Comet
+  module Rules
+    class Codegen
+      def initialize(linker, bitcode)
+        @linker = linker
+        @bitcode = bitcode
+      end
+
+      def target
+        @target ||= Comet::Makefile.fingerprint Hash[
+          command: clang_link_command,
+          target: @bitcode.target,
+          triple: @linker.triple,
+          isa: @linker.isa,
+          cpu: @linker.cpu,
+          opt: @linker.opt
+        ], extension: :s
+      end
+
+      def contents
+        [
+          "#{target}: #{@bitcode.target} | #{Comet::TMPDIR}",
+          "\t#{llvm_codegen} -o $@ $<"
+        ]
+      end
+
+      def rules
+        @rules ||= [@bitcode]
+      end
+
+      def commands
+        { COMET_OPT: 'clang' }
+      end
+
+      private
+
+      def llvm_codegen
+        [
+          *clang_link_command,
+          "--target=#{@linker.triple}",
+          "-march=#{@linker.isa}",
+          "-mcpu=#{@linker.cpu}"
+        ].join ' '
+      end
+
+      def clang_link_command
+        ['$(COMET_OPT)', '-S', "-O#{@linker.opt}"]
+      end
+    end
+  end
+end

data/lib/comet/rules/compile.rb

@@ -0,0 +1,72 @@
+module Comet
+  module Rules
+    class Compile
+      def initialize(source, file, linker)
+        @source = source
+        @file = file
+        @linker = linker
+      end
+
+      def target
+        @target ||= Comet::Makefile.fingerprint Hash[
+          file: @file,
+          triple: @linker.triple,
+          isa: @linker.isa,
+          cpu: @linker.cpu,
+          flags: Set[formatted_flags],
+          headers: formatted_headers,
+          dependencies: Set[dependencies]
+        ], extension: :ll
+      end
+
+      def contents
+        [
+          "#{target}: #{@file} #{dependencies.join ' '} | #{Comet::TMPDIR}",
+          "\t#{clang_compile} #{formatted_flags.join ' '} -o $@ -c $<"
+        ]
+      end
+
+      def rules
+        []
+      end
+
+      def commands
+        { COMET_CC: 'clang' }
+      end
+
+      private
+
+      def formatted_flags
+        @formatted_flags ||= @source.options.format
+      end
+
+      def dependencies
+        @dependencies ||= find_dependencies
+      end
+
+      def find_dependencies
+        Comet::DSL::IncludeWalker.includes_for(@file, @source.headers)
+      end
+
+      def clang_compile
+        [
+          '$(COMET_CC)',
+          '-x',
+          'c',
+          "--target=#{@linker.triple}",
+          "-march=#{@linker.isa}",
+          "-mcpu=#{@linker.cpu}",
+          '-S',
+          '-flto',
+          *formatted_headers
+        ].join ' '
+      end
+
+      def formatted_headers
+        @source.headers.map do |header|
+          "-I#{header}"
+        end.join
+      end
+    end
+  end
+end

data/lib/comet/rules/error.rb

@@ -0,0 +1,33 @@
+module Comet
+  module Rules
+    class Error
+      def initialize(message)
+        @message = message
+      end
+
+      def target
+        nil
+      end
+
+      def contents
+        ["$(error #{pretty_message})"]
+      end
+
+      def rules
+        []
+      end
+
+      def commands
+        {}
+      end
+
+      private
+
+      def pretty_message
+        words = @message.split
+        words.first.capitalize!
+        words.join ' '
+      end
+    end
+  end
+end

data/lib/comet/rules/link.rb

@@ -0,0 +1,74 @@
+module Comet
+  module Rules
+    class Link
+      def initialize(linker, dependency, libraries, native_sources)
+        @linker = linker
+        @dependency = dependency
+        @libraries = libraries
+        @native_sources = native_sources
+      end
+
+      def target
+        @target ||= Comet::Makefile.fingerprint Hash[
+          dependency: @dependency.target,
+          triple: @linker.triple,
+          isa: @linker.isa,
+          cpu: @linker.cpu,
+          script: @linker.script_,
+          libraries: formatted_libraries,
+          native_sources: @native_sources,
+          flags: formatted_flags
+        ], extension: :elf
+      end
+
+      def map_file
+        target.gsub(/.elf$/, '.map')
+      end
+
+      def contents
+        [
+          "#{target}: #{@dependency.target} #{@native_sources.join ' '} | #{Comet::TMPDIR}",
+          "\t#{clang_link} #{formatted_script} #{formatted_flags.join ' '} -Wl,-Map=#{map_file} -o $@ $^ #{formatted_libraries}"
+        ]
+      end
+
+      def rules
+        [@dependency]
+      end
+
+      def commands
+        { COMET_LD: 'clang' }
+      end
+
+      private
+
+      def formatted_script
+        return '' if @linker.script_.nil?
+        "-T#{@linker.script_}"
+      end
+
+      def formatted_flags
+        @formatted_flags ||= @linker.options.format
+      end
+
+      def clang_link
+        [
+          '$(COMET_LD)',
+          "--target=#{@linker.triple}",
+          "-march=#{@linker.isa}",
+          "-mcpu=#{@linker.cpu}"
+        ].join ' '
+      end
+
+      def formatted_libraries
+        @libraries.flat_map do |library|
+          if library.path.nil?
+            "-l#{library.name}"
+          else
+            ["-L#{File.join library.path, library.name}"]
+          end
+        end.join ' '
+      end
+    end
+  end
+end

data/lib/comet/rules/merge.rb

@@ -0,0 +1,37 @@
+module Comet
+  module Rules
+    class Merge
+      def initialize(dependencies)
+        @dependencies = dependencies
+      end
+
+      def target
+        @target ||= Comet::Makefile.fingerprint Hash[
+          command: llvm_link,
+          dependencies: Set[@dependencies.map(&:target).uniq]
+        ], extension: :ll
+      end
+
+      def contents
+        [
+          "#{target}: #{@dependencies.map(&:target).uniq.join ' '} | #{Comet::TMPDIR}",
+          "\t#{llvm_link.join ' '} -o $@ $^"
+        ]
+      end
+
+      def rules
+        @dependencies
+      end
+
+      def commands
+        { COMET_LINK: 'llvm-link' }
+      end
+
+      private
+
+      def llvm_link
+        ['$(COMET_LINK)', '-S']
+      end
+    end
+  end
+end

data/lib/comet/rules/objcopy.rb

@@ -0,0 +1,41 @@
+module Comet
+  module Rules
+    class ObjCopy
+      def initialize(linker, elf, format, extension)
+        @linker = linker
+        @elf = elf
+        @format = format
+        @extension = extension
+      end
+
+      def target
+        @target ||= Comet::Makefile.fingerprint Hash[
+          triple: @linker.triple,
+          format: @format,
+          elf: @elf.target
+        ], extension: @extension
+      end
+
+      def contents
+        [
+          "#{target}: #{@elf.target} | #{Comet::TMPDIR}",
+          "\t#{objcopy}"
+        ]
+      end
+
+      def rules
+        [@elf]
+      end
+
+      def commands
+        { COMET_OBJCOPY: 'objcopy' }
+      end
+
+      private
+
+      def objcopy
+        Comet::Makefile.select_command "#{@linker.triple}-$(COMET_OBJCOPY)", '$(COMET_OBJCOPY)', ['-O', @format, '$<', '$@']
+      end
+    end
+  end
+end

data/lib/comet/rules/tmpdir.rb

@@ -0,0 +1,39 @@
+module Comet
+  module Rules
+    class TmpDir
+      def target
+        Comet::TMPDIR
+      end
+
+      def contents
+        [
+          ".PHONY: #{target}",
+          "#{target}:",
+          "\tif #{exists?} || #{valid?}; then #{create}; fi"
+        ]
+      end
+
+      def rules
+        []
+      end
+
+      def commands
+        { COMET_LN: 'ln' }
+      end
+
+      private
+
+      def exists?
+        '[ ! -d "$@" ]'
+      end
+
+      def valid?
+        "[ ! -d \"`readlink #{target}`\" ]"
+      end
+
+      def create
+        '$(COMET_LN) -sf `mktemp -d` $@'
+      end
+    end
+  end
+end

data/lib/comet/version.rb

@@ -0,0 +1,3 @@
+module Comet
+  VERSION = '0.1.2'.freeze
+end