mtbuild 0.0.1

data/lib/mtbuild/staticlibrary_project.rb

@@ -0,0 +1,21 @@
+module MTBuild
+  require "mtbuild/staticlibrary_configuration"
+  require 'mtbuild/project'
+
+  # This class is used to build static libraries. A static library has
+  # compilation and archival phases that produce a binary library package.
+	class StaticLibraryProject < Project
+
+    # Adds a named static library configuration to the project.
+    def add_configuration(configuration_name, configuration)
+      super
+      default_configuration = Workspace.configuration_defaults.fetch(configuration_name, {})
+      merged_configuration = Utils.merge_configurations(default_configuration, configuration)
+      cfg = StaticLibraryConfiguration.new(@project_name, @project_folder, effective_output_folder, configuration_name, merged_configuration)
+      @configurations << cfg
+      return cfg
+    end
+
+	end
+
+end

data/lib/mtbuild/staticlibrary_task.rb

@@ -0,0 +1,31 @@
+module Rake
+
+  require 'rake'
+
+  # This is a top-level Rake task for creating a static library
+  class StaticLibraryTask < Task
+
+    # API header location for the static library
+    attr_accessor :api_headers
+
+    # The static library output file(s)
+    attr_accessor :library_files
+
+    def initialize(task_name, app)
+      super
+      @api_headers = ''
+      @library_files = ''
+    end
+
+  end
+
+  module DSL
+
+    # DSL method to create a static library task.
+    def static_library_task(*args, &block)
+      new_task = Rake::StaticLibraryTask.define_task(*args, &block)
+    end
+
+  end
+
+end

data/lib/mtbuild/test_application_configuration.rb

@@ -0,0 +1,33 @@
+module MTBuild
+  require 'mtbuild/compiled_configuration'
+
+  # Use this class to create test application configurations. You won't typically
+  # instantiate this directly. Instead, the TestApplicationProject.add_configuration
+  # method will create this for you.
+	class TestApplicationConfiguration < CompiledConfiguration
+
+    # Create the actual Rake tasks that will perform the configuration's work
+    def configure_tasks
+      super
+      all_object_files = []
+      all_object_folders = []
+      @toolchains.each do |toolchain, sources|
+        object_files, object_folders = toolchain.create_compile_tasks(sources)
+        all_object_files |= object_files
+        all_object_folders |= object_folders
+      end
+
+      application_binaries, application_files, application_folders = @default_toolchain.create_application_tasks(all_object_files, @project_name)
+      dependencies = @dependencies+all_object_folders+application_folders+application_files+application_binaries
+
+      desc "Build and run test application '#{@project_name}' with configuration '#{@configuration_name}'"
+      new_task = test_application_task @configuration_name => dependencies do |t|
+        puts "built test application #{t.name}."
+        sh application_binaries.first
+        puts "ran test application #{t.name}."
+      end
+    end
+
+	end
+
+end

data/lib/mtbuild/test_application_project.rb

@@ -0,0 +1,22 @@
+module MTBuild
+  require "mtbuild/test_application_configuration"
+  require 'mtbuild/project'
+
+  # This class is used to build test applications. A test application has
+  # compilation and link phases that produce a binary test executable. The test
+  # executable is invoked after building successfully.
+	class TestApplicationProject < Project
+
+    # Adds a named test application configuration to the project.
+    def add_configuration(configuration_name, configuration)
+      super
+      default_configuration = Workspace.configuration_defaults.fetch(configuration_name, {})
+      merged_configuration = Utils.merge_configurations(default_configuration, configuration)
+      cfg = TestApplicationConfiguration.new(@project_name, @project_folder, effective_output_folder, configuration_name, merged_configuration)
+      @configurations << cfg
+      return cfg
+    end
+
+	end
+
+end

data/lib/mtbuild/test_application_task.rb

@@ -0,0 +1,23 @@
+module Rake
+
+  require 'rake'
+
+  # This is a top-level Rake task for creating a test application
+  class TestApplicationTask < Task
+
+    def initialize(task_name, app)
+      super
+    end
+
+  end
+
+  module DSL
+
+    # DSL method to create a test application task.
+    def test_application_task(*args, &block)
+      new_task = Rake::TestApplicationTask.define_task(*args, &block)
+    end
+
+  end
+
+end

data/lib/mtbuild/toolchain.rb

@@ -0,0 +1,109 @@
+module MTBuild
+
+  # This is the base class for all toolchain types.
+	class Toolchain
+
+    # The toolchain's output folder
+    attr_accessor :output_folder
+
+    # The project's folder. Relative path references are interpreted as
+    # relative to this folder.
+    attr_accessor :project_folder
+
+    # Text to append to the name of output files
+    attr_accessor :output_decorator
+
+		def initialize(configuration)
+      @output_folder = ''
+      @project_folder = ''
+      @output_decorator = ''
+      @include_objects = []
+      @include_paths = []
+      @library_paths = []
+
+      add_include_paths(expand_project_relative_paths(configuration.fetch(:include_paths, [])))
+      add_include_objects(expand_project_relative_paths(configuration.fetch(:include_objects, [])))
+      add_library_paths(expand_project_relative_paths(configuration.fetch(:library_paths, [])))
+		end
+
+    # Retrieve a list of additional objects to link with
+    def get_include_objects
+      @include_objects.collect {|i| File.expand_path(i.gsub('$(PROJECT_DIR)', @project_folder))}
+    end
+
+    # Retrieve a list of include paths to compile with
+    def get_include_paths
+      @include_paths.collect {|i| File.expand_path(i.gsub('$(PROJECT_DIR)', @project_folder))}
+    end
+
+    # Retrieve a list of library paths to link with
+    def get_library_paths
+      @library_paths.collect {|i| File.expand_path(i.gsub('$(PROJECT_DIR)', @project_folder))}
+    end
+
+    # Add an additional object to the list of additional objects to link with
+    def add_include_objects(include_objects)
+      include_objects = Utils.ensure_array(include_objects).to_a.flatten
+      @include_objects |= include_objects
+    end
+
+    # Add an include path to the list of include paths to compile with
+    def add_include_paths(include_paths)
+      include_paths = Utils.ensure_array(include_paths).to_a.flatten
+      @include_paths |= include_paths
+    end
+
+    # Add a library path to the list of library paths to link with
+    def add_library_paths(library_paths)
+      library_paths = Utils.ensure_array(library_paths).to_a.flatten
+      @library_paths |= library_paths
+    end
+
+    # Create Rake tasks for compilation
+    def create_compile_tasks(source_files)
+      fail "Toolchain didn't provide create_compile_tasks"
+    end
+
+    # Create Rake tasks for archival
+    def create_static_library_tasks(objects, library_name)
+      fail "Toolchain didn't provide create_static_library_tasks"
+    end
+
+    # Create Rake tasks for linking
+    def create_application_tasks(objects, executable_name)
+      fail "Toolchain didn't provide create_executable_tasks"
+    end
+
+    private
+
+    def expand_project_relative_paths(paths)
+      return Utils.ensure_array(paths).to_a.flatten.collect{ |p| (File.join('$(PROJECT_DIR)', p))}
+    end
+
+    @registered_toolchains = {}
+
+    def self.register_toolchain(toolchain_name, toolchain_class)
+      @registered_toolchains[toolchain_name] = toolchain_class;
+    end
+
+    def self.create_toolchain(toolchain_configuration)
+      toolchain_name = toolchain_configuration.fetch(:name, nil)
+      fail "error: toolchain name not specified." if toolchain_name.nil?
+
+      toolchain_class = @registered_toolchains.fetch(toolchain_name, nil)
+      if !toolchain_class
+        toolchain_file = File.join('mtbuild', 'toolchains', toolchain_name.to_s)
+        begin
+          require toolchain_file
+        rescue LoadError
+        end
+      end
+      toolchain_class = @registered_toolchains.fetch(toolchain_name, nil)
+      fail "error: toolchain #{toolchain_name} could not be found." if toolchain_class.nil?
+      return Object::const_get(toolchain_class).new(toolchain_configuration)
+    end
+
+    include Rake::DSL
+	end
+
+end

data/lib/mtbuild/toolchains/arm_none_eabi_gcc.rb

@@ -0,0 +1,69 @@
+module MTBuild
+  require 'mtbuild/toolchains/gcc'
+
+  Toolchain.register_toolchain(:arm_none_eabi_gcc, 'MTBuild::ToolchainArmNoneEabiGcc')
+
+  # This ToolchainGcc subclass can build using arm-non-eabi-gcc
+	class ToolchainArmNoneEabiGcc < ToolchainGcc
+
+		def initialize(configuration)
+      super
+		end
+
+    # Create Rake tasks for linking
+    def create_application_tasks(objects, executable_name)
+      elf_file = File.join(@output_folder, "#{executable_name}#{@output_decorator}.elf")
+      bin_file = File.join(@output_folder, "#{executable_name}#{@output_decorator}.bin")
+      hex_file = File.join(@output_folder, "#{executable_name}#{@output_decorator}.hex")
+      map_file = File.join(@output_folder, "#{executable_name}#{@output_decorator}.map")
+      executable_folder = @output_folder
+      directory executable_folder
+      CLOBBER.include(executable_folder)
+      CLOBBER.include(elf_file)
+
+      all_objects = objects+get_include_objects
+
+      file elf_file => all_objects do |t|
+        command_line = construct_link_command(all_objects, t.name, get_include_paths, get_library_paths, map_file)
+        sh command_line
+      end
+
+      file map_file => elf_file
+
+      file bin_file => elf_file do |t|
+        command_line = construct_objcopy_command(elf_file, t.name, ' -Obinary')
+        sh command_line
+      end
+      file hex_file => elf_file do |t|
+        command_line = construct_objcopy_command(elf_file, t.name, ' -Oihex')
+        sh command_line
+      end
+
+      return [elf_file, bin_file, hex_file], [map_file], [executable_folder]
+    end
+
+    private
+
+    def construct_objcopy_command(input_name, output_name, objcopyflags)
+      return "#{objcopy}#{objcopyflags} #{input_name} #{output_name}"
+    end
+
+    def compiler
+      return 'arm-none-eabi-gcc'
+    end
+
+    def archiver
+      return 'arm-none-eabi-ar'
+    end
+
+    def linker
+      return 'arm-none-eabi-gcc'
+    end
+
+    def objcopy
+      return 'arm-none-eabi-objcopy'
+    end
+
+	end
+
+end

data/lib/mtbuild/toolchains/gcc.rb

@@ -0,0 +1,160 @@
+module MTBuild
+  require 'mtbuild/toolchain'
+  require 'mtbuild/utils'
+  require 'rake/clean'
+  require 'rake/loaders/makefile'
+
+  Toolchain.register_toolchain(:gcc, 'MTBuild::ToolchainGcc')
+
+  # This Toolchain subclass can build using GCC
+	class ToolchainGcc < Toolchain
+
+    attr_accessor :cppflags, :cflags, :cxxflags, :asflags, :ldflags, :linker_script
+
+		def initialize(configuration)
+      super
+
+      begin
+        toolchain_test_output=%x{#{compiler} --version 2>&1}
+        toolchain_test_passed=$?.success?
+      rescue
+        toolchain_test_passed = false
+      end
+      fail "Toolchain component #{compiler} not found." unless toolchain_test_passed
+
+      @compiler_is_LLVM_gcc = toolchain_test_output.include?'LLVM'
+      @cppflags = configuration.fetch(:cppflags, '')
+      @cflags = configuration.fetch(:cflags, '')
+      @cxxflags = configuration.fetch(:cxxflags, '')
+      @asflags = configuration.fetch(:asflags, '')
+      @ldflags = configuration.fetch(:ldflags, '')
+      @linker_script = configuration.fetch(:linker_script, '')
+		end
+
+    # Create Rake tasks for compilation
+    def create_compile_tasks(source_files)
+      object_files = []
+      object_folders = []
+
+      source_files.each do |source_file|
+
+        relative_source_location = Utils::path_difference(@project_folder, File.dirname(source_file))
+        fail "Source file #{source_file} must be within #{@project_folder}." if relative_source_location.nil?
+        output_folder = File.join(@output_folder, relative_source_location)
+
+        object_folders << output_folder unless object_folders.include?output_folder
+
+        directory output_folder
+        CLOBBER.include(output_folder)
+
+        object_file = File.join(output_folder, source_file.pathmap('%n.o'))
+        dependency_file = File.join(output_folder, source_file.pathmap('%n.d'))
+
+        object_files << object_file
+        CLEAN.include(object_file)
+        CLEAN.include(dependency_file)
+
+        file_type = get_file_type(source_file)
+
+        file object_file => [source_file] do |t|
+          command_line = construct_compile_command(file_type, [source_file], get_include_paths, t.name)
+          sh command_line
+        end
+        Rake::MakefileLoader.new.load(dependency_file) if File.file?(dependency_file)
+      end
+      return object_files, object_folders
+    end
+
+    # Create Rake tasks for archival
+    def create_static_library_tasks(objects, library_name)
+      library_file = File.join(@output_folder, "lib#{library_name}#{@output_decorator}.a")
+      library_folder = @output_folder
+      directory library_folder
+      CLOBBER.include(library_folder)
+      CLOBBER.include(library_file)
+
+      file library_file => objects do |t|
+        command_line = construct_archive_command(objects, t.name)
+        sh command_line
+      end
+      return [library_file], [library_folder]
+    end
+
+    # Create Rake tasks for linking
+    def create_application_tasks(objects, executable_name)
+      elf_file = File.join(@output_folder, "#{executable_name}#{@output_decorator}")
+      map_file = File.join(@output_folder, "#{executable_name}#{@output_decorator}.map")
+      executable_folder = @output_folder
+      directory executable_folder
+      CLOBBER.include(executable_folder)
+      CLOBBER.include(elf_file)
+
+      all_objects = objects+get_include_objects
+
+      file elf_file => all_objects do |t|
+        command_line = construct_link_command(all_objects, t.name, get_include_paths, get_library_paths, map_file)
+        sh command_line
+      end
+
+      file map_file => elf_file
+
+      return [elf_file], [map_file], [executable_folder]
+    end
+
+    private
+
+    def get_file_type(source_file)
+      file_extension = File.extname(source_file)
+      return :cplusplus if ['.cc', '.cp', '.cxx', '.cpp', '.CPP', '.c++', '.C'].include? file_extension
+      return :asm if ['.s', '.S', '.sx'].include? file_extension
+      return :c
+    end
+
+    def construct_compile_command(file_type, prerequisites, include_paths, output_name)
+      prerequisites_s = prerequisites.empty? ? '' : " #{prerequisites.join(' ')}"
+      include_paths_s = include_paths.empty? ? '' : " -I#{include_paths.join(' -I')}"
+      cppflags_s = @cppflags.empty? ? '' : " #{@cppflags}"
+      cflags_s = @cflags.empty? ? '' : " #{@cflags}"
+      cxxflags_s = @cxxflags.empty? ? '' : " #{@cxxflags}"
+      asflags_s = @asflags.empty? ? '' : " #{@asflags}"
+      return "#{compiler}#{cppflags_s}#{cflags_s}#{prerequisites_s}#{include_paths_s} -MMD -c -o #{output_name}" if file_type == :c
+      return "#{compiler}#{cppflags_s}#{cxxflags_s}#{prerequisites_s}#{include_paths_s} -MMD -c -o #{output_name}" if file_type == :cplusplus
+      return "#{compiler}#{cppflags_s}#{asflags_s}#{prerequisites_s}#{include_paths_s} -MMD -c -o #{output_name}" if file_type == :asm
+    end
+
+    def construct_archive_command(prerequisites, output_name)
+      prerequisites_s = prerequisites.empty? ? '' : " #{prerequisites.join(' ')}"
+      return "#{archiver} rcs #{output_name} #{prerequisites_s}"
+    end
+
+    def construct_link_command(prerequisites, output_name, include_paths, library_paths, map_name)
+      prerequisites_s = prerequisites.empty? ? '' : " #{prerequisites.join(' ')}"
+      include_paths_s = include_paths.empty? ? '' : " -I#{include_paths.join(' -I')}"
+      library_paths_s = library_paths.empty? ? '' : " -L#{library_paths.join(' -L')}"
+      cppflags_s = @cppflags.empty? ? '' : " #{@cppflags}"
+      cflags_s = @cflags.empty? ? '' : " #{@cflags}"
+      ldflags_s = @ldflags.empty? ? '' : " #{@ldflags}"
+      linker_script_s = @linker_script.empty? ? '' : " -Wl,-T#{File.join(@project_folder,@linker_script)}"
+      return "#{compiler}#{cppflags_s}#{cflags_s}#{ldflags_s}#{linker_script_s}#{prerequisites_s}#{include_paths_s} #{map_flag(map_name)} -o #{output_name}"
+    end
+
+    def map_flag(map_file)
+      return "-Wl,-map,#{map_file}" if @compiler_is_LLVM_gcc
+      return "-Wl,-Map=#{map_file},--cref"
+    end
+
+    def compiler
+      return 'gcc'
+    end
+
+    def archiver
+      return 'ar'
+    end
+
+    def linker
+      return 'gcc'
+    end
+
+	end
+
+end