comet-build 0.1.2

data/lib/comet/dsl/firmware.rb

@@ -0,0 +1,65 @@
+module Comet
+  module DSL
+    class Firmware
+      include Comet::DSL::Helpers
+      alias inject instance_exec
+
+      def target(device, &block)
+        raise "target #{device} redefined" if @targets.key? device
+        @targets[device] = Target.new(device, &block)
+      end
+
+      def initialize(name, imports:, &block)
+        @name = name
+        @imports = imports
+        @targets = {}
+
+        instance_exec(&block) if block_given?
+      end
+
+      def to_s
+        "firmware #{@name}"
+      end
+
+      attr_reader :name
+      attr_accessor :imports
+
+      def targets
+        @targets.keys
+      end
+
+      def target_for(device)
+        @targets[device]
+      end
+
+      def hardware_for(device)
+        @imports.flat_map do |imported|
+          imported.hardware_for device
+        end.uniq
+      end
+
+      def validate!
+        raise "firmware `#{@name}' has no targets" if @targets.empty?
+
+        @targets.values.each(&:validate!)
+        imports.each(&:validate!)
+
+        targets.each do |device|
+          validate_for! device, hardware_for(device)
+        end
+      end
+
+      private
+
+      def validate_for!(device, hardware)
+        if hardware.empty?
+          raise "firmware `#{@name}' does not support target `#{device}'"
+        end
+
+        linkers = hardware.select(&:linker?)
+        raise "no linker section for firmware `#{@name}'" if linkers.empty?
+        raise "multiple linkers for firmware `#{@name}'" if linkers.length > 1
+      end
+    end
+  end
+end

data/lib/comet/dsl/hardware.rb

@@ -0,0 +1,56 @@
+module Comet
+  module DSL
+    class Hardware
+      include Comet::DSL::Helpers
+      alias inject instance_exec
+
+      def source(language:, **kwargs, &block)
+        @sources.push Source.create(language: language, **kwargs, &block)
+      end
+
+      def linker(*args, **kwargs, &block)
+        raise 'linker section redefined' unless @linker_.nil?
+        @linker_ = Linker.new(*args, **kwargs, &block)
+      end
+
+      def import(name, path: nil)
+        @libraries.add Library.new(name, path: path)
+      end
+
+      def initialize(name, targets:, &block)
+        @name = name
+        @targets = targets
+        @sources = []
+        @linker_ = nil
+        @libraries = Set[]
+
+        instance_exec(&block) if block_given?
+      end
+
+      def to_s
+        "hardware #{@name} for #{@targets}"
+      end
+
+      attr_reader :targets
+      attr_reader :sources
+      attr_reader :linker_
+
+      def libraries
+        @libraries.to_a
+      end
+
+      def hardware_for(device)
+        device == targets ? self : []
+      end
+
+      def linker?
+        !@linker_.nil?
+      end
+
+      def validate!
+        sources.each(&:validate!)
+        @linker.validate! unless @linker.nil?
+      end
+    end
+  end
+end

data/lib/comet/dsl/helpers.rb

@@ -0,0 +1,9 @@
+module Comet
+  module DSL
+    module Helpers
+      def quote(string)
+        "\\\"#{string.strip}\\\""
+      end
+    end
+  end
+end

data/lib/comet/dsl/hex_output.rb

@@ -0,0 +1,19 @@
+module Comet
+  module DSL
+    class HexOutput
+      def initialize(path)
+        @path = path
+      end
+
+      def to_s
+        'hex output'
+      end
+
+      attr_reader :path
+
+      def validate!
+        raise "#{self} path is invalid" if @path.strip.empty?
+      end
+    end
+  end
+end

data/lib/comet/dsl/include_walker.rb

@@ -0,0 +1,42 @@
+module Comet
+  module DSL
+    module IncludeWalker
+      class << self
+        def includes_for(file, include_paths)
+          @@cache[[file, include_paths]]
+        end
+
+        def search(file, include_paths)
+          includes = []
+
+          File.read(file).scan(PATTERN) do
+            header = Regexp.last_match[1] || Regexp.last_match[2]
+            includes << find_included_file(header, include_paths)
+          end
+
+          includes.compact.uniq.dup.each do |included|
+            includes.concat search(included, include_paths)
+          end
+
+          includes.compact.uniq
+        end
+
+        private
+
+        @@cache = Hash.new do |h, k|
+          h[k] = IncludeWalker.search(*k)
+        end
+
+        PATTERN = /^\s*#\s*include\s*(?:(?:<([^>]+)>)|(?:"([^"]+)"))\s*$/m
+
+        def find_included_file(file, include_paths)
+          match = include_paths.detect do |include_path|
+            File.exist? File.join(include_path, file)
+          end
+
+          File.join(match, file) unless match.nil?
+        end
+      end
+    end
+  end
+end

data/lib/comet/dsl/library.rb

@@ -0,0 +1,21 @@
+module Comet
+  module DSL
+    class Library
+      def initialize(name, path: nil)
+        @name = name
+        @path = path
+      end
+
+      def to_s
+        "library #{@name}"
+      end
+
+      attr_reader :name
+      attr_reader :path
+
+      def validate!
+        true
+      end
+    end
+  end
+end

data/lib/comet/dsl/linker.rb

@@ -0,0 +1,45 @@
+module Comet
+  module DSL
+    class Linker
+      include Comet::DSL::Helpers
+      alias inject instance_exec
+
+      def script(script)
+        @script = script
+      end
+
+      def option(*args, **kwargs)
+        @options.add('', *args, **kwargs)
+      end
+
+      def initialize(triple, isa:, cpu:, opt:, &block)
+        @triple = triple
+        @isa = isa
+        @cpu = cpu
+        @options = Options.new
+        @opt = opt
+        @script = nil
+
+        instance_exec(&block) if block_given?
+      end
+
+      def to_s
+        "linker #{@triple}"
+      end
+
+      attr_reader :triple
+      attr_reader :isa
+      attr_reader :cpu
+      attr_reader :options
+      attr_reader :opt
+
+      def script_
+        @script
+      end
+
+      def validate!
+        raise "#{self} triple is invalid" if @triple.strip.empty?
+      end
+    end
+  end
+end

data/lib/comet/dsl/map_output.rb

@@ -0,0 +1,19 @@
+module Comet
+  module DSL
+    class MapOutput
+      def initialize(path)
+        @path = path
+      end
+
+      def to_s
+        'map output'
+      end
+
+      attr_reader :path
+
+      def validate!
+        raise "#{self} path is invalid" if @path.strip.empty?
+      end
+    end
+  end
+end

data/lib/comet/dsl/native/source.rb

@@ -0,0 +1,44 @@
+module Comet
+  module DSL
+    module Native
+      class Source
+        include Comet::DSL::Helpers
+        alias inject instance_exec
+
+        def import(pattern)
+          @imports.push pattern
+        end
+
+        def initialize(**_, &block)
+          @imports = []
+
+          instance_exec(&block) if block_given?
+        end
+
+        def to_s
+          'native source'
+        end
+
+        attr_reader :imports
+
+        def language
+          :native
+        end
+
+        def native?
+          true
+        end
+
+        def files
+          @imports.flat_map do |pattern|
+            Dir.glob pattern
+          end.uniq
+        end
+
+        def validate!
+          raise "#{self} references no source files" if @imports.empty?
+        end
+      end
+    end
+  end
+end

data/lib/comet/dsl/options.rb

@@ -0,0 +1,44 @@
+module Comet
+  module DSL
+    class Options
+      def initialize
+        @options = {}
+      end
+
+      def to_s
+        'options'
+      end
+
+      def add(prefix, *args, **kwargs)
+        args.each do |key|
+          set_option "#{prefix}#{key}"
+        end
+
+        kwargs.each do |key, value|
+          set_option "#{prefix}#{key}", value
+        end
+      end
+
+      def format(prefix: '-', separator: '=')
+        @options.map do |key, value|
+          next "#{prefix}#{key}" if value.nil?
+          "#{prefix}#{key}#{separator}#{value}"
+        end
+      end
+
+      def validate!
+        true
+      end
+
+      private
+
+      def set_option(key, value = nil)
+        if value == :remove
+          @options.delete key
+        else
+          @options[key] = value
+        end
+      end
+    end
+  end
+end

data/lib/comet/dsl/software.rb

@@ -0,0 +1,42 @@
+module Comet
+  module DSL
+    class Software
+      include Comet::DSL::Helpers
+      alias inject instance_exec
+
+      def source(language:, **kwargs, &block)
+        source = Source.create(language: language, **kwargs, &block)
+        raise 'native source only allowed in hardware block' if source.native?
+        @sources.push source
+      end
+
+      def initialize(name, depends:, &block)
+        @name = name
+        @depends = depends
+        @sources = []
+
+        instance_exec(&block) if block_given?
+      end
+
+      def to_s
+        "software #{@name}"
+      end
+
+      attr_accessor :depends
+      attr_reader :sources
+
+      def hardware_for(device)
+        @depends.flat_map do |dependent|
+          dependent.hardware_for device
+        end.uniq
+      end
+
+      def validate!
+        raise "#{@name} has no source directives" if sources.empty?
+
+        depends.each(&:validate!)
+        sources.each(&:validate!)
+      end
+    end
+  end
+end

data/lib/comet/dsl/source.rb

@@ -0,0 +1,24 @@
+module Comet
+  module DSL
+    class Source
+      class << self
+        def create(language:, **kwargs, &block)
+          raise "unknown language #{language}" unless valid? language
+          LANGUAGES[language].new(**kwargs, &block) # pass extra args
+        end
+
+        private
+
+        LANGUAGES = {
+          c: C::Source,
+          cpp: CPP::Source,
+          native: Native::Source
+        }.freeze
+
+        def valid?(language)
+          LANGUAGES.keys.include? language
+        end
+      end
+    end
+  end
+end

data/lib/comet/dsl/target.rb

@@ -0,0 +1,64 @@
+module Comet
+  module DSL
+    class Target
+      include Comet::DSL::Helpers
+      alias inject instance_exec
+
+      def elf(path)
+        @elf_output = ElfOutput.new(path)
+      end
+
+      def bin(path)
+        @bin_output = BinOutput.new(path)
+      end
+
+      def hex(path)
+        @hex_output = HexOutput.new(path)
+      end
+
+      def map(path)
+        @map_output = MapOutput.new(path)
+      end
+
+      def initialize(device, &block)
+        @elf_output = nil
+        @bin_output = nil
+        @hex_output = nil
+        @map_output = nil
+        @device = device
+
+        instance_exec(&block) if block_given?
+      end
+
+      def to_s
+        "target for #{@device}"
+      end
+
+      attr_reader :elf_output
+      attr_reader :bin_output
+      attr_reader :hex_output
+      attr_reader :map_output
+
+      def elf?
+        !@elf_output.nil?
+      end
+
+      def bin?
+        !@bin_output.nil?
+      end
+
+      def hex?
+        !@hex_output.nil?
+      end
+
+      def map?
+        !@map_output.nil?
+      end
+
+      def validate!
+        has_outputs = [elf?, bin?, hex?, map?].any?
+        raise "#{self} describes no outputs" unless has_outputs
+      end
+    end
+  end
+end

data/lib/comet/makefile.rb

@@ -0,0 +1,129 @@
+require 'digest'
+require 'set'
+
+module Comet
+  class Makefile
+    def initialize
+      @rules = [tmpdir_rule]
+    end
+
+    def contents
+      (commands + @rules.map(&:contents)).flatten.join "\n"
+    end
+
+    def execute(*args)
+      process_spawn make_command(*args) do |stdin|
+        stdin.write contents
+      end
+    end
+
+    def alias(name, rules)
+      insert Rules::Alias.new(name, rules)
+    end
+
+    def build(firmware, device)
+      append Rules::Build.new(firmware, device)
+    end
+
+    def error(message)
+      insert Rules::Error.new(message)
+    end
+
+    def clean
+      append Rules::Clean.new(Comet::TMPDIR)
+    end
+
+    private
+
+    def tmpdir_rule
+      @tmpdir_rule ||= Rules::TmpDir.new
+    end
+
+    def insert(rule)
+      @rules.unshift rule unless seen? rule
+      rule.rules.each(&method(:append))
+      rule
+    end
+
+    def append(rule)
+      @rules.push rule unless seen? rule
+      rule.rules.each(&method(:append))
+      rule
+    end
+
+    def seen?(rule)
+      @rules.map(&:target).include? rule.target
+    end
+
+    def process_spawn(arguments)
+      IO.pipe do |read, write|
+        process = spawn(*arguments, in: read)
+        yield write # pass in process stdin
+        write.close # make sure to close
+        Process.wait process
+      end
+
+      $?.exitstatus
+    end
+
+    def commands
+      commands = @rules.map(&:commands).reduce(&:merge)
+      commands.flat_map do |name, default|
+        ["#{name} ?= #{default}"]
+      end
+    end
+
+    def make_command(arguments, verbose: false)
+      [
+        ENV.fetch('MAKE', 'make'),
+        verbose ? nil : '-s',
+        '-f', '-', *arguments
+      ].compact
+    end
+
+    # Make utilities (TODO: move this elsewhere?)
+
+    class << self
+      def select_command(preferred, alternate, args)
+        return command(alternate, args) if preferred == alternate
+
+        check_command = "(command -v #{preferred} > /dev/null)"
+        preferred_cmd = command preferred, args
+        alternate_cmd = command alternate, args
+
+        "#{check_command} && #{preferred_cmd} || #{alternate_cmd}"
+      end
+
+      def command(command, args)
+        [command, *args].join ' '
+      end
+
+      def fingerprint(dependencies, extension:)
+        File.join Comet::TMPDIR, "#{hash dependencies}.#{extension}"
+      end
+
+      private
+
+      def hash(object)
+        digest = Digest::SHA256.new
+
+        if [Array, Set, Hash].any? { |t| object.is_a? t }
+          hash_container digest, container: object
+        else
+          digest.update Digest::SHA256.digest(object.class.name)
+          digest.update Digest::SHA256.digest(object.to_s)
+        end
+
+        digest.hexdigest[0..19]
+      end
+
+      def hash_container(digest, container:)
+        if container.is_a? Array
+          container.each { |element| digest.update hash(element) }
+        else # this will work for both hashes and sets
+          digest.update hash(container.to_a.sort)
+        end
+      end
+    end
+  end
+end