rakeoe 0.0.1

data/lib/rakeoe/toolchain/environment-arm-stm32f072-eabi.osx

@@ -0,0 +1,46 @@
+export PATH="/Users/dschnell/install/gcc-arm-none-eabi-4_8-2013q4/bin/:$PATH"
+export PKG_CONFIG_SYSROOT_DIR=
+export PKG_CONFIG_PATH=
+export CONFIG_SITE=
+export CC="arm-none-eabi-gcc"
+export CXX="arm-none-eabi-g++"
+export CPP="arm-none-eabi-gcc -E"
+export AS="arm-none-eabi-as"
+export LD="arm-none-eabi-ld"
+export GDB="arm-none-eabi-gdb"
+export STRIP="arm-none-eabi-strip"
+export RANLIB="arm-none-eabi-ranlib"
+export OBJCOPY="arm-none-eabi-objcopy"
+export OBJDUMP="arm-none-eabi-objdump"
+export AR="arm-none-eabi-ar"
+export NM="arm-none-eabi-nm"
+export SIZE="arm-none-eabi-size"
+export M4=
+export TARGET_PREFIX=arm-none-eabi-
+export CONFIGURE_FLAGS=
+export CFLAGS=" -std=gnu99 -mcpu=cortex-m0 -mthumb -fomit-frame-pointer -fdata-sections -ffunction-sections -D__ASSEMBLY__ -DSTM32F072X -DSTM32F072"
+export CXXFLAGS=" -mcpu=cortex-m0 -mthumb -fomit-frame-pointer -fdata-sections -ffunction-sections -D__ASSEMBLY__"
+export LDFLAGS=' -mcpu=cortex-m0 -mthumb -g -nostartfiles -Wl,--gc-sections -Xlinker -Tlinker/stm32f072_linker.ld'
+export CPPFLAGS=
+export OECORE_NATIVE_SYSROOT=
+export OECORE_TARGET_SYSROOT=
+export OECORE_ACLOCAL_OPTS=
+export OECORE_DISTRO_VERSION=
+export OECORE_SDK_VERSION=
+export OE_QMAKE_CFLAGS=
+export OE_QMAKE_CXXFLAGS=
+export OE_QMAKE_LDFLAGS=
+export OE_QMAKE_CC=
+export OE_QMAKE_CXX=
+export OE_QMAKE_LINK=
+export OE_QMAKE_AR=
+export OE_QMAKE_LIBDIR_QT=
+export OE_QMAKE_INCDIR_QT=
+export OE_QMAKE_MOC=
+export OE_QMAKE_UIC=
+export OE_QMAKE_UIC3=
+export OE_QMAKE_RCC=
+export OE_QMAKE_QDBUSCPP2XML=
+export OE_QMAKE_QDBUSXML2CPP=
+export OE_QMAKE_QT_CONFIG=
+export QMAKESPEC=

data/lib/rakeoe/toolchain.rb

@@ -0,0 +1,457 @@
+# -*- ruby -*-
+
+require 'rbconfig'
+require 'rake/loaders/makefile'
+require 'rakeoe/defaults'
+require 'rakeoe/test_framework'
+
+module RakeOE
+
+#
+# Toolchain specific key value reader
+#
+# @author Daniel Schnell
+class Toolchain
+  attr_reader  :qt, :settings, :target, :config
+
+  # Initializes object
+  #
+  # @param  [RakeOE::Config] config     Project wide configurations
+  #
+  def initialize(config)
+    @config = config
+
+    @kvr = KeyValueReader.new(config.platform)
+    @settings = @kvr.env
+    fixup_env
+
+    # save target platform of our compiler (gcc specific)
+    if RbConfig::CONFIG["host_os"] != "mingw32"
+      @target=`export PATH=#{@settings['PATH']} && #{@settings['CC']} -dumpmachine`.chop
+    else
+      @target=`PATH = #{@settings['PATH']} & #{@settings['CC']} -dumpmachine`.chop
+    end
+
+    @settings['TOUCH'] = 'touch'
+    # XXX DS: we should only instantiate @qt if we have any qt settings
+    @qt = QtSettings.new(self)
+    set_build_vars()
+
+    init_test_frameworks
+    sanity
+  end
+
+
+  # Do some sanity checks
+  def sanity
+    # TODO DS: check if libs and apps directories exist
+    # TODO DS: check if test frameworks exist
+  end
+
+  # returns the build directory
+  def build_dir
+    @config.directories[:build]
+  end
+
+
+  # Initializes definitions for test framework
+  # TODO: Add possibility to configure test framework specific CFLAGS/CXXFLAGS
+  def init_test_frameworks()
+    @@test_framework ||= Hash.new
+
+    config_empty_test_framework
+
+    if @config.test_fw.size > 0
+      if PrjFileCache.contain?('LIB', @config.test_fw)
+        @@test_framework[@config.test_fw] = TestFramework.new(:name         => @config.test_fw,
+                                                              :binary_path  => "#{@settings['LIB_OUT']}/lib#{@config.test_fw}.a",
+                                                              :include_dir  => PrjFileCache.exported_lib_incs(@config.test_fw),
+                                                              :cflags       => '')
+      else
+          puts "WARNING: Configured test framework (#{@config.test_fw}) does not exist in project!"
+      end
+    end
+  end
+
+  # Configures empty test framework
+  def config_empty_test_framework
+    @@test_framework[''] = TestFramework.new(:name         => '',
+                                             :binary_path  => '',
+                                             :include_dir  => '',
+                                             :cflags       => '')
+
+  end
+
+  # Returns default test framework or nil if none defined
+  def default_test_framework
+    test_framework(@config.test_fw) || test_framework('')
+  end
+
+  # Returns definitions of specific test framework or none if
+  # specified test framework doesn't exist
+  def test_framework(name)
+    @@test_framework[name]
+  end
+
+  # Returns list of all registered test framework names
+  def test_frameworks
+    @@test_framework.keys
+  end
+
+  # returns library project setting
+  def lib_setting(name, setting)
+    @libs.get(name, setting)
+  end
+
+  # returns app project setting
+  def app_setting(name, setting)
+    @apps.get(name, setting)
+  end
+
+  # returns c++ source extensions
+  def cpp_source_extensions
+    (@config.suffixes[:cplus_sources] + [@config.suffixes[:moc_source]]).uniq
+  end
+
+  # returns c source extensions
+  def c_source_extensions
+    @config.suffixes[:c_sources].uniq
+  end
+
+  # returns assembler source extensions
+  def as_source_extensions
+    @config.suffixes[:as_sources].uniq
+  end
+
+  # returns all source extensions
+  def source_extensions
+    cpp_source_extensions + c_source_extensions + as_source_extensions
+  end
+
+  # returns c++ header extensions
+  def cpp_header_extensions
+    (@config.suffixes[:cplus_headers] + [@config.suffixes[:moc_header]]).uniq
+  end
+
+  # returns c header extensions
+  def c_header_extensions
+    @config.suffixes[:c_headers].uniq
+  end
+
+  # returns moc header extensions
+  def moc_header_extension
+    @config.suffixes[:moc_header]
+  end
+
+  # returns c++ header extensions
+  def moc_source
+    @config.suffixes[:moc_source]
+  end
+
+  # Specific fixups for toolchain
+  def fixup_env
+    # set system PATH if no PATH defined
+    @settings['PATH'] ||= ENV['PATH']
+
+    # replace $PATH
+    @settings['PATH'] = @settings['PATH'].gsub('$PATH', ENV['PATH'])
+
+    # create ARCH
+    @settings['ARCH'] = "#{@settings['TARGET_PREFIX']}".chop
+
+    # remove optimizations, we set these explicitly
+    @settings['CXXFLAGS'] = "#{@settings['CXXFLAGS']} -DPROGRAM_VERSION=\\\"#{@config.sw_version}\\\"".gsub('-O2', '')
+    @settings['CFLAGS'] = "#{@settings['CFLAGS']} -DPROGRAM_VERSION=\\\"#{@config.sw_version}\\\"".gsub('-O2', '')
+    KeyValueReader.substitute_dollar_symbols!(@settings)
+  end
+
+
+  # Set common build variables
+  #
+  # @param [String] release_mode   Release mode used for the build, either 'release' or 'dbg'
+  def set_build_vars()
+    warning_flags = ' -W -Wall'
+    if 'release' == @config.release
+      optimization_flags = " #{@config.optimization_release} -DRELEASE"
+    else
+      optimization_flags = " #{@config.optimization_dbg} -g"
+    end
+
+    # we could make these also arrays of source directories ...
+    @settings['APP_SRC_DIR'] = 'src/app'
+    @settings['LIB_SRC_DIR'] = 'src/lib'
+
+    # derived settings
+    @settings['BUILD_DIR'] = "#{build_dir}/#{@target}/#{@config.release}"
+    @settings['LIB_OUT'] = "#{@settings['BUILD_DIR']}/libs"
+    @settings['APP_OUT'] = "#{@settings['BUILD_DIR']}/apps"
+    @settings['SYS_LFLAGS'] = "-L#{@settings['OECORE_TARGET_SYSROOT']}/lib -L#{@settings['OECORE_TARGET_SYSROOT']}/usr/lib"
+
+    # set LD_LIBRARY_PATH
+    @settings['LD_LIBRARY_PATH'] = @settings['LIB_OUT']
+
+    # standard settings
+    @settings['CXXFLAGS'] += warning_flags + optimization_flags + " #{@config.language_std_cpp}"
+    @settings['CFLAGS'] += warning_flags + optimization_flags + " #{@config.language_std_c}"
+    if @settings['PRJ_TYPE'] == 'SOLIB'
+      @settings['CXXFLAGS'] += ' -fPIC'
+      @settings['CFLAGS'] += ' -fPIC'
+    end
+    # !! don't change order of the following string components without care !!
+    @settings['LDFLAGS'] = @settings['LDFLAGS'] + " -L #{@settings['LIB_OUT']} #{@settings['SYS_LFLAGS']} -Wl,--no-as-needed -Wl,--start-group"
+  end
+
+  # Executes the command
+  def sh(cmd, silent: false)
+    if RbConfig::CONFIG["host_os"] != "mingw32"
+      full_cmd = "export PATH=#{@settings['PATH']} && #{cmd}"
+    else
+      full_cmd = "PATH = #{@settings['PATH']} & #{cmd}"
+    end
+
+    if silent
+      system full_cmd
+    else
+      Rake::sh full_cmd
+    end
+  end
+
+
+  # Removes list of given files
+  # @param [String]  files   List of files to be deleted
+  def rm(files)
+    if files
+      Rake::sh "rm -f #{files}" unless files.empty?
+    end
+  end
+
+
+  # Executes a given binary
+  #
+  # @param [String] binary    Absolute path of the binary to be executed
+  #
+  def run(binary)
+    # compare ruby platform config and our target setting
+    if @target[RbConfig::CONFIG["target_cpu"]]
+      system "export LD_LIBRARY_PATH=#{@settings['LD_LIBRARY_PATH']} && #{binary}"
+    else
+      puts "Warning: Can't execute on this platform: #{binary}"
+    end
+  end
+
+  # Executes a given test binary with test runner specific parameter(s)
+  #
+  # @param [String] binary    Absolute path of the binary to be executed
+  #
+  def run_junit_test(binary)
+    # compare ruby platform config and our target setting
+    if @target[RbConfig::CONFIG["target_cpu"]]
+      system "export LD_LIBRARY_PATH=#{@settings['LD_LIBRARY_PATH']} && #{binary} -o junit"
+    else
+      puts "Warning: Can't execute test on this platform: #{binary}"
+    end
+  end
+
+  # Tests given list of platforms if any of those matches the current platform
+  def current_platform_any?(platforms)
+    ([@target] & platforms).any?
+  end
+
+  # Generates compiler include line from given include path list
+  #
+  # @param [Array]  paths   Paths to be used for include file search
+  #
+  # @return [String]        Compiler include line
+  #
+  def compiler_incs_for(paths)
+    paths.each_with_object('') {|path, str| str << " -I#{path}"}
+  end
+
+  # Generates linker line from given library list
+  #
+  # @param [Array]  libs  Libraries to be used for linker line
+  #
+  # @return [String]      Linker line
+  #
+  def linker_line_for(libs)
+    libs.map { |lib| "-l#{lib}" }.join(' ').strip
+  end
+
+  # Touches a file
+  def touch(file)
+    sh "#{@settings['TOUCH']} #{file}"
+  end
+
+  # Returns platform specific settings of a resource (APP/LIB/SOLIB or external resource like e.g. an external library)
+  # as a hash with the keys CFLAGS, CXXFLAGS and LDFLAGS. The values are empty if no such resource settings exist inside
+  # the platform file. The resulting hash values can be used for platform specific compilation/linkage against the
+  # the resource.
+  #
+  # @param resource_name  [String]  name of resource
+  # @return [Hash]                  Hash of compilation/linkage flags or empty hash if no settings are defined
+  #                                 The returned hash has the following format:
+  #                                 { 'CFLAGS' => '...', 'CXXFLAGS' => '...', 'LDFLAGS' => '...'}
+  #
+  def res_platform_settings(resource_name)
+    return {} if resource_name.empty?
+
+    rv = Hash.new
+    rv['CFLAGS'] = @settings["#{resource_name}_CFLAGS"]
+    rv['CXXFLAGS'] = @settings["#{resource_name}_CXXFLAGS"]
+    rv['LDFLAGS'] = @settings["#{resource_name}_LDFLAGS"]
+    rv
+  end
+
+  # Creates compilation object
+  #
+  # @param  [Hash] params
+  # @option params [String] :source   source filename with path
+  # @option params [String] :object   object filename path
+  # @option params [Hash]   :settings project specific settings
+  # @option params [Array]  :includes include paths used
+  #
+  def obj(params = {})
+    extension = File.extname(params[:source])
+    object    = params[:object]
+    source    = params[:source]
+    incs      = compiler_incs_for(params[:includes]) + " #{@settings['LIB_INC']}"
+=begin
+puts
+puts "incs for #{object}: #{incs}"
+puts
+puts "params[:includes]:#{params[:includes]}"
+puts
+=end
+    case
+      when cpp_source_extensions.include?(extension)
+        flags = @settings['CXXFLAGS'] + ' ' + params[:settings]['ADD_CXXFLAGS']
+        compiler = "#{@settings['CXX']} -x c++ "
+      when c_source_extensions.include?(extension)
+        flags = @settings['CFLAGS'] + ' ' + params[:settings]['ADD_CFLAGS']
+        compiler = "#{@settings['CC']} -x c "
+      when as_source_extensions.include?(extension)
+        flags = ''
+        compiler = "#{@settings['AS']}"
+      else
+        raise "unsupported source file extension (#{extension}) for creating object!"
+    end
+    sh "#{compiler} #{flags} #{incs} -c #{source} -o #{object}"
+  end
+
+
+  # Creates dependency
+  #
+  # @param  [Hash] params
+  # @option params [String] :source   source filename with path
+  # @option params [String] :dep      dependency filename path
+  # @option params [Hash]   :settings project specific settings
+  # @option params [Array]  :includes include paths used
+  #
+  def dep(params = {})
+    extension = File.extname(params[:source])
+    dep       = params[:dep]
+    source    = params[:source]
+    incs      = compiler_incs_for(params[:includes]) + " #{@settings['LIB_INC']}"
+    case
+      when cpp_source_extensions.include?(extension)
+        flags = @settings['CXXFLAGS'] + ' ' + params[:settings]['ADD_CXXFLAGS']
+        compiler = "#{@settings['CXX']} -x c++ "
+      when c_source_extensions.include?(extension)
+        flags  = @settings['CFLAGS'] + ' ' + params[:settings]['ADD_CFLAGS']
+        compiler = "#{@settings['CC']} -x c "
+      when as_source_extensions.include?(extension)
+        flags = ''
+        compiler = "#{@settings['AS']}"
+      else
+        raise "unsupported source file extension (#{extension}) for creating dependency!"
+    end
+    sh "#{compiler} -MM #{flags} #{incs} -c #{source} -MT #{dep.ext('.o')} -MF #{dep}", silent: true
+  end
+
+
+  # Creates moc_ source file
+  #
+  # @param  [Hash] params
+  # @option params [String] :source   source filename with path
+  # @option params [String] :moc      moc_XXX filename path
+  # @option params [Hash]   :settings project specific settings
+  #
+  def moc(params = {})
+    moc_compiler = @settings['OE_QMAKE_MOC']
+    raise 'No Qt Toolchain set' if moc_compiler.empty?
+    sh "#{moc_compiler} -i -f#{File.basename(params[:source])} #{params[:source]} >#{params[:moc]}"
+  end
+
+
+  # Creates library
+  #
+  # @param  [Hash] params
+  # @option params [Array]  :objects  object filename paths
+  # @option params [String] :lib      library filename path
+  # @option params [Hash]   :settings project specific settings
+  #
+  def lib(params = {})
+    ldflags   = params[:settings]['ADD_LDFLAGS']
+    objs      = params[:objects].join(' ')
+    extension = File.extname(params[:lib])
+
+    case extension
+      when ('.a')
+        # need to use 'touch' for correct timestamp, ar doesn't update the timestamp
+        # if archive hasn't changed
+        sh "#{@settings['AR']} curv #{params[:lib]} #{objs} && #{@settings['TOUCH']} #{params[:lib]}"
+      when '.so'
+        sh "#{@settings['CXX']} -shared  #{ldflags} #{objs} -o #{params[:lib]}"
+      else
+        raise "unsupported library extension (#{extension})!"
+    end
+  end
+
+
+  # Creates application
+  #
+  # @param  [Hash] params
+  # @option params [Array]  :objects  array of object file paths
+  # @option params [Array]  :libs     array of libraries that should be linked against
+  # @option params [String] :app      application filename path
+  # @option params [Hash]   :settings project specific settings
+  # @option params [Array]  :includes include paths used
+  #
+  def app(params = {})
+    incs    = compiler_incs_for(params[:includes])
+    ldflags = params[:settings]['ADD_LDFLAGS'] + ' ' + @settings['LDFLAGS']
+    objs    = params[:objects].join(' ')
+    libs    = linker_line_for(params[:libs])
+
+    sh "#{@settings['SIZE']} #{objs} >#{params[:app]}.size" if @settings['SIZE']
+    sh "#{@settings['CXX']} #{incs} #{objs} #{ldflags} #{libs} -o #{params[:app]} -Wl,-Map,#{params[:app]}.map"
+    sh "#{@settings['OBJCOPY']} -O binary #{params[:app]} #{params[:app]}.bin"
+  end
+
+  # Creates test
+  #
+  # @param  [Hash] params
+  # @option params [Array]  :objects   array of object file paths
+  # @option params [Array]  :libs      array of libraries that should be linked against
+  # @option params [String] :framework test framework name
+  # @option params [String] :test      test filename path
+  # @option params [Hash]   :settings  project specific settings
+  # @option params [Array]  :includes  include paths used
+  #
+  def test(params = {})
+    incs    = compiler_incs_for(params[:includes])
+    ldflags = params[:settings]['ADD_LDFLAGS'] + ' ' +  @settings['LDFLAGS']
+    objs    = params[:objects].join(' ')
+    test_fw = linker_line_for([params[:framework]])
+    libs    = linker_line_for(params[:libs])
+
+    sh "#{@settings['CXX']} #{incs} #{objs} #{test_fw} #{ldflags} #{libs} -o #{params[:test]}"
+  end
+
+  def dump
+    @kvr.dump
+  end
+
+end
+
+end

data/lib/rakeoe/version.rb

@@ -0,0 +1,3 @@
+module RakeOE
+  VERSION = "0.0.1"
+end

data/lib/rakeoe.rb

@@ -0,0 +1,94 @@
+
+require 'rake'
+require 'rake/dsl_definition'
+require 'rake/clean'
+
+require 'rakeoe/config'
+require 'rakeoe/version'
+require 'rakeoe/defaults'
+require 'rakeoe/key_value_reader'
+require 'rakeoe/toolchain'
+require 'rakeoe/qt_settings'
+require 'rakeoe/lib'
+require 'rakeoe/app'
+require 'rakeoe/prj_file_cache'
+
+module RakeOE
+
+  include Rake::DSL   # for #task, #desc, #namespace
+
+  # Initialize RakeOE project. Reads & parses all prj.rake files
+  # of given config.
+  #
+  # @param config [RakeOE::Config]      Configuration as provided by project Rakefile
+  #
+  def init(config)
+
+    RakeOE::PrjFileCache.sweep_recursive(config.directories[:apps] + config.directories[:libs])
+
+    toolchain = RakeOE::Toolchain.new(config)
+    
+    #
+    # Top level tasks
+    #
+    %w[lib app].each do |type|
+      namespace type do
+        # Introduce type:all
+        #
+        # All libs/apps will make themselves dependent on this task, so whenever you call
+        #   'rake lib:all' or 'rake app:all'
+        # all libs/apps will thus be generated automatically
+        desc "Create all #{type}s"
+        task :all
+
+        case type
+        when 'lib'
+          RakeOE::PrjFileCache.for_each('LIB') do |name, settings|
+            RakeOE::Lib.new(name, settings, toolchain).create
+          end
+
+          RakeOE::PrjFileCache.for_each('SOLIB') do |name, settings|
+            RakeOE::Lib.new(name, settings, toolchain).create
+          end
+
+        when 'app'
+          RakeOE::PrjFileCache.for_each('APP') do |name, settings|
+            RakeOE::App.new(name, settings, toolchain).create
+          end
+        else
+          raise "No such type #{type} supported"
+        end
+
+        # Introduce type:test:all
+        #
+        # All tests in lib/app will make themselves dependent on this task, so whenever you call
+        #   'rake lib:test:all'
+        # all available library tests will be generated automatically before execution
+        namespace 'test' do
+          desc "Run all #{type} tests"
+          task :all
+        end
+      end
+    end
+
+    desc 'Dumps toolchain environment variables'
+    task :dump do
+      puts
+      config.dump
+      puts
+      toolchain.dump
+      puts
+    end
+  
+    task :all => %w[lib:all app:all]
+    task :test => %w[lib:test:all app:test:all]
+    task :test_build => %w[lib:test:build app:test:build]
+    task :junit => %w[lib:test:junit app:test:junit]
+    task :default => :all
+
+    # kind of mrproper/realclean
+    CLOBBER.include('*.tmp', "#{config.directories[:build]}/*")
+  end
+end
+
+include RakeOE

data/rakeoe.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rakeoe/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rakeoe"
+  spec.version       = RakeOE::VERSION
+  spec.authors       = ["Daniel Schnell"]
+  spec.email         = ["dschnell@skerpa.com"]
+  spec.description   = %q{RakeOE : Rake Optimized for Embedded
+                          A build system for test driven Embedded C/C++ Development based on Ruby Rake.
+                          RakeOE is a build system for application development. It can parse OpenEmbedded/Yocto environment files.
+                          In this way it knows how to cross compile in whatever target platform the cross compiler builds.
+                          It uses automatically the appropriate include paths and libraries of the given platform.}
+  spec.summary       = %q{RakeOE : Rake Optimized for Embedded. A build system for test driven Embedded C/C++ Development}
+  spec.homepage      = "http://rakeoe.github.io/rakeoe/"
+  spec.license       = "GPLv3"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  
+  spec.add_dependency "rake"
+end