cxxproject 0.2 → 0.4.6

data/lib/cxxproject/testinstanceeval.rb

@@ -0,0 +1,65 @@
+require 'rake'
+
+project_string = 'cxx_configuration "debug" do
+  exe "basic",
+    :sources => FileList.new("**/*.cpp"),
+    :dependencies => ["2"]
+  exe "debug",
+    :sources => FileList.new("**/*.cpp"),
+    :dependencies => ["abc"]
+end'
+# project_string = 'cxx_configuration "debug" do
+#   [exe ("basic", :sources => FileList.new("**/*.cpp")),
+#    exe ("next",{})]
+# end'
+class EvalContext
+
+  attr_accessor :name, :myblock
+
+  def cxx_configuration(name, &block)
+    puts "calling cxx_configuration with name: #{name}"
+    @myblock = block
+    @name = name
+  end
+
+  def eval_project(project_text)
+    instance_eval(project_text)
+    puts "instance_eval with #{project_text}"
+  end
+
+  def configuration(*args, &block)
+    name = args[0]
+    raise "no name given" unless name.is_a?(String) && !name.strip.empty?
+    instance_eval(&block)
+  end
+
+  def check_hash(hash,allowed)
+    puts "hash" + hash.inspect
+    hash.keys.map {|k| raise "#{k} is not a valid specifier!" unless allowed.include?(k) }
+  end
+
+  def exe(name, hash)
+    puts "inside exe"
+    raise "not a hash" unless hash.is_a?(Hash)
+    check_hash hash,[:sources,:includes,:dependencies]
+    puts "sources are: #{hash[:sources]}"
+  end
+
+  def source_lib(name, hash)
+    raise "not a hash" unless hash.is_a?(Hash)
+    check_hash hash,[:sources,:includes,:dependencies]
+    raise ":sources need to be defined" unless hash.has_key?(:sources)
+    puts "sources are: #{hash[:sources]}"
+  end
+
+  def compile(name, hash)
+    raise "not a hash" unless hash.is_a?(Hash)
+    check_hash hash,[:sources,:includes]
+  end
+
+end
+
+loadContext = EvalContext.new
+loadContext.eval_project(project_string)
+loadContext.myblock.call()
+

data/lib/cxxproject/toolchain/base.rb

@@ -0,0 +1,98 @@
+module Cxxproject
+  module Toolchain
+
+    class Provider
+      @@settings = {}
+      @@default = {
+        :COMPILER =>
+        {
+          :CPP => {
+            :COMMAND => "",
+            :DEFINE_FLAG => "",
+            :OBJECT_FILE_FLAG => "",
+            :INCLUDE_PATH_FLAG => "",
+            :COMPILE_FLAGS => "",
+            :DEFINES => [],
+            :FLAGS => "",
+            :SOURCE_FILE_ENDINGS => [".cxx", ".cpp", ".c++", ".cc", ".C"],
+            :DEP_FLAGS => ""
+          },
+          :C => {
+            :COMMAND => "",
+            :DEFINE_FLAG => "",
+            :OBJECT_FILE_FLAG => "",
+            :INCLUDE_PATH_FLAG => "",
+            :COMPILE_FLAGS => "",
+            :DEFINES => [],
+            :FLAGS => "",
+            :SOURCE_FILE_ENDINGS => [".c"],
+            :DEP_FLAGS => ""
+          },
+          :ASM => {
+            :COMMAND => "",
+            :DEFINE_FLAG => "",
+            :OBJECT_FILE_FLAG => "",
+            :INCLUDE_PATH_FLAG => "",
+            :COMPILE_FLAGS => "",
+            :DEFINES => [],
+            :FLAGS => "",
+            :SOURCE_FILE_ENDINGS => [".asm", ".s", ".S"],
+            :DEP_FLAGS => ""
+          }
+        },
+
+        :ARCHIVER =>
+        {
+          :COMMAND => "",
+          :ARCHIVE_FLAGS => "",
+          :FLAGS => ""
+        },
+
+        :LINKER =>
+        {
+          :COMMAND => "",
+          :MUST_FLAGS => "",
+          :SCRIPT => "",
+          :USER_LIB_FLAG => "",
+          :EXE_FLAG => "",
+          :LIB_FLAG => "",
+          :LIB_PATH_FLAG => "",
+          :LIB_PREFIX_FLAGS => "", # "-Wl,--whole-archive",
+          :LIB_POSTFIX_FLAGS => "", # "-Wl,--no-whole-archive",
+          :FLAGS => "",
+          :MAP_FILE_FLAG => "",
+          :OUTPUT_ENDING => ".exe", # or .elf
+        },
+
+        :MAKE =>
+        {
+          :COMMAND => "make",
+          :MAKE_FLAGS => "",
+          :FLAGS => "-j",
+          :FILE_FLAG => "-f",
+          :DIR_FLAG => "-C",
+          :CLEAN => "clean"
+        },
+
+      }
+
+      def self.add(name, basedOn = nil)
+        chain = Marshal.load(Marshal.dump(basedOn.nil? ? @@default : @@settings[basedOn]))
+        @@settings[name] = chain
+        chain
+      end
+
+      def self.default
+        @@default
+      end
+
+      def self.modify_cpp_compiler(based_on, h)
+        chain = Marshal.load(Marshal.dump(@@settings[based_on]))
+        chain[:COMPILER][:CPP].update(h)
+        chain
+      end
+
+    end
+
+  end
+end

data/lib/cxxproject/toolchain/diab.rb

@@ -0,0 +1,47 @@
+require 'cxxproject/toolchain/base'
+require 'cxxproject/utils/utils'
+
+module Cxxproject
+  module Toolchain
+
+    DiabChainDebug = Provider.add("Diab_Debug")
+
+    DiabChainDebug[:COMPILER][:C].update({
+      :COMMAND => "dcc",
+      :FLAGS => "-tPPCE200Z6VEN:simple -O -XO -Xsize-opt -Xsmall-const=0 -Xenum-is-best -Xexceptions-off -g",
+      :DEFINE_FLAG => "-D",
+      :OBJECT_FILE_FLAG => "-o",
+      :INCLUDE_PATH_FLAG => "-I",
+      :COMPILE_FLAGS => "-c",
+      :DEP_FLAGS => "-Xmake-dependency=6 -Xmake-dependency-savefile="
+    })
+
+    DiabChainDebug[:COMPILER][:CPP] = Utils.deep_copy(DiabChainDebug[:COMPILER][:C])
+    DiabChainDebug[:COMPILER][:CPP][:FLAGS] = DiabChainDebug[:COMPILER][:CPP][:FLAGS] + " -Xrtti-off"
+    DiabChainDebug[:COMPILER][:CPP][:SOURCE_FILE_ENDINGS] = Provider.default[:COMPILER][:CPP][:SOURCE_FILE_ENDINGS]
+
+    DiabChainDebug[:COMPILER][:ASM] = Utils.deep_copy(DiabChainDebug[:COMPILER][:C])
+    DiabChainDebug[:COMPILER][:ASM][:COMMAND] = "das"
+    DiabChainDebug[:COMPILER][:ASM][:FLAGS] = "-tPPCE200Z6VEN:simple -Xisa-vle -g -Xasm-debug-on"
+    DiabChainDebug[:COMPILER][:ASM][:COMPILE_FLAGS] = ""
+    DiabChainDebug[:COMPILER][:ASM][:SOURCE_FILE_ENDINGS] = Provider.default[:COMPILER][:ASM][:SOURCE_FILE_ENDINGS]
+
+    DiabChainDebug[:ARCHIVER][:COMMAND] = "dar"
+    DiabChainDebug[:ARCHIVER][:ARCHIVE_FLAGS] = "-r"
+
+    DiabChainDebug[:LINKER][:COMMAND] = "dcc"
+    DiabChainDebug[:LINKER][:SCRIPT] = "-Wm"
+    DiabChainDebug[:LINKER][:USER_LIB_FLAG] = "-l:"
+    DiabChainDebug[:LINKER][:EXE_FLAG] = "-o"
+    DiabChainDebug[:LINKER][:LIB_FLAG] = "-l"
+    DiabChainDebug[:LINKER][:LIB_PATH_FLAG] = "-L"
+    DiabChainDebug[:LINKER][:MAP_FILE_FLAG] = "-Wl,-m6" # no map file if this string is empty, otherwise -Wl,-m6>abc.map
+    DiabChainDebug[:LINKER][:FLAGS] = "-ulink_date_time -uResetConfigurationHalfWord -Wl,-Xstop-on-redeclaration -Wl,-Xstop-on-warning -tPPCE200Z6VEN:simple -Wl,-Xremove-unused-sections -Wl,-Xunused-sections-list"
+    DiabChainDebug[:LINKER][:OUTPUT_ENDING] = ".elf"
+
+    DiabChainRelease = Provider.add("Diab_Release", "Diab_Debug")
+    DiabChainRelease[:COMPILER][:C][:FLAGS] = "-tPPCE200Z6VEN:simple -XO -Xsize-opt -Xsmall-const=0 -Xenum-is-best -Xsection-split -Xforce-declarations"
+    DiabChainRelease[:COMPILER][:CPP][:FLAGS] = "-tPPCE200Z6VEN:simple -XO -Xsize-opt -Xsmall-const=0 -Xenum-is-best -Xrtti-off -Xexceptions-off -Xsection-split"
+
+  end
+end

data/lib/cxxproject/toolchain/gcc.rb

@@ -0,0 +1,39 @@
+require 'cxxproject/toolchain/base'
+require 'cxxproject/utils/utils'
+
+module Cxxproject
+  module Toolchain
+
+    GCCChain = Provider.add("GCC")
+
+    GCCChain[:COMPILER][:CPP].update({
+      :COMMAND => "g++",
+      :DEFINE_FLAG => "-D",
+      :OBJECT_FILE_FLAG => "-o",
+      :INCLUDE_PATH_FLAG => "-I",
+      :COMPILE_FLAGS => "-c ",
+      :DEP_FLAGS => "-MMD -MF " # empty space at the end is important!
+    })
+
+    GCCChain[:COMPILER][:C] = Utils.deep_copy(GCCChain[:COMPILER][:CPP])
+    GCCChain[:COMPILER][:C][:SOURCE_FILE_ENDINGS] = Provider.default[:COMPILER][:C][:SOURCE_FILE_ENDINGS]
+    GCCChain[:COMPILER][:C][:COMMAND] = "gcc"
+
+    GCCChain[:COMPILER][:ASM] = Utils.deep_copy(GCCChain[:COMPILER][:C])
+    GCCChain[:COMPILER][:ASM][:SOURCE_FILE_ENDINGS] = Provider.default[:COMPILER][:ASM][:SOURCE_FILE_ENDINGS]
+
+    GCCChain[:ARCHIVER][:COMMAND] = "ar"
+    GCCChain[:ARCHIVER][:ARCHIVE_FLAGS] = "-r"
+
+    GCCChain[:LINKER][:COMMAND] = "g++"
+    GCCChain[:LINKER][:SCRIPT] = "-T"
+    GCCChain[:LINKER][:USER_LIB_FLAG] = "-l:"
+    GCCChain[:LINKER][:EXE_FLAG] = "-o"
+    GCCChain[:LINKER][:LIB_FLAG] = "-l"
+    GCCChain[:LINKER][:LIB_PATH_FLAG] = "-L"
+    GCCChain[:LINKER][:FLAGS] = "-all_load"
+    GCCChain[:LINKER][:LIB_PREFIX_FLAGS] = "-Wl,--whole-archive"
+    GCCChain[:LINKER][:LIB_POSTFIX_FLAGS] = "-Wl,--no-whole-archive"
+
+  end
+end

data/lib/cxxproject/toolchain/provider.rb

@@ -0,0 +1,18 @@
+require 'cxxproject/toolchain/diab'
+require 'cxxproject/toolchain/gcc'
+
+module Cxxproject
+  module Toolchain
+
+    class Provider
+
+      def self.[](name)
+        return @@settings[name] if @@settings.include? name
+        nil
+      end
+
+
+    end
+
+  end
+end

data/lib/cxxproject/torake/compiler.rb

@@ -0,0 +1,10 @@
+
+class Compiler
+  attr_reader :output_path
+
+  def initialize(output_path)
+    @output_path = output_path
+    CLOBBER.include(output_path)
+  end
+
+end

data/lib/cxxproject/torake.rb

@@ -0,0 +1,152 @@
+require 'logger'
+require 'pp'
+require 'pathname'
+require 'cxxproject/extensions/rake_ext'
+require 'cxxproject/toolchain/gcc'
+require 'cxxproject/task_maker'
+
+class CxxProject2Rake
+
+  attr_accessor :base, :all_tasks
+
+  def initialize(projects, build_dir, toolchain, base='.', logLevel=Logger::ERROR)
+    pwd = `pwd`
+    @log = Logger.new(STDOUT)
+    @log.formatter = proc { |severity, datetime, progname, msg|
+      "#{severity}: #{msg}\n"
+    }
+
+    @log.level = logLevel
+    @log.debug "starting..."
+    @base = base
+    @all_tasks = instantiate_tasks(projects, build_dir, toolchain, base)
+  end
+
+  def instantiate_tasks(project_configs, build_dir, toolchain, base='.')
+    cd base do
+      project_configs.each do |p|
+        abort "project config #{p} cannot be found!" unless File.exists?(p)
+      end
+    end
+    @log.debug "project_configs: #{project_configs}"
+    register_projects(project_configs)
+    define_project_info_task()
+    @gcc = toolchain
+    task_maker = TaskMaker.new(@log)
+    task_maker.set_loglevel(@log.level);
+    tasks = []
+
+    #todo: sort ALL_BUILDING_BLOCKS (circular deps)
+
+    ALL_BUILDING_BLOCKS.each do |name,block|
+      block.set_tcs(@gcc) unless block.has_tcs?
+      block.set_output_dir(Dir.pwd + "/" + build_dir)
+      rel_projects = project_configs.collect { |p| File.join(base,p) }
+      block.set_config_files(rel_projects)
+      block.complete_init()
+    end
+
+    ALL_BUILDING_BLOCKS.each do |name,block|
+      @log.debug "creating task for block: #{block.name}/taskname: #{block.get_task_name} (#{block})"
+      t = task_maker.create_tasks_for_building_block(block)
+      if (t != nil)
+        tasks << { :task => t, :name => name }
+      end
+    end
+    tasks
+  end
+
+  def register_projects(projects)
+    cd(@base,:verbose => false) do |b|
+      projects.each do |project_file|
+        @log.debug "register project #{project_file}"
+        dirname = File.dirname(project_file)
+        @log.debug "dirname for project was: #{dirname}"
+        cd(dirname,:verbose => false) do | base_dir |
+          @log.debug "current dir: #{`pwd`}, #{base_dir}"
+          loadContext = EvalContext.new
+          loadContext.eval_project(File.read(File.basename(project_file)))
+          loadContext.myblock.call()
+          loadContext.all_blocks.each do |p|
+            p.set_project_dir(Dir.pwd)
+            if p.sources.instance_of?(Rake::FileList)
+              p.set_sources(p.sources.to_a)
+            end
+          end
+        end
+      end
+    end
+  end
+  def define_project_info_task
+    desc "shows your defined projects"
+    task :project_info do
+      p "ProjectBase: #{@base}"
+      ALL_BUILDING_BLOCKS.each_value do |bb|
+        pp bb
+      end
+    end
+  end
+
+end
+
+class EvalContext
+
+  attr_accessor :myblock, :all_blocks
+
+  def cxx_configuration(&block)
+    @myblock = block
+    @all_blocks = []
+  end
+
+  def eval_project(project_text)
+    instance_eval(project_text)
+  end
+
+  def configuration(*args, &block)
+    name = args[0]
+    raise "no name given" unless name.is_a?(String) && !name.strip.empty?
+    instance_eval(&block)
+  end
+
+  def check_hash(hash,allowed)
+    hash.keys.map {|k| raise "#{k} is not a valid specifier!" unless allowed.include?(k) }
+  end
+
+  def exe(name, hash)
+    raise "not a hash" unless hash.is_a?(Hash)
+    check_hash hash,[:sources,:includes,:dependencies]
+    bblock = Executable.new(name)
+    bblock.set_sources(hash[:sources]) if hash.has_key?(:sources)
+    bblock.set_includes(hash[:includes]) if hash.has_key?(:includes)
+    bblock.set_dependencies(hash[:dependencies]) if hash.has_key?(:dependencies)
+
+    if OS.linux?
+      bblock.set_lib_searchpaths(["/usr/local/lib","/usr/lib"])
+    else
+      bblock.set_lib_searchpaths(["C:/tool/cygwin/lib"])
+    end
+    all_blocks << bblock
+  end
+
+  def source_lib(name, hash)
+    raise "not a hash" unless hash.is_a?(Hash)
+    check_hash hash,[:sources,:includes,:dependencies,:toolchain]
+    raise ":sources need to be defined" unless hash.has_key?(:sources)
+    bblock = SourceLibrary.new(name)
+    bblock.set_sources(hash[:sources])
+    bblock.set_includes(hash[:includes]) if hash.has_key?(:includes)
+    bblock.set_tcs(hash[:toolchain]) if hash.has_key?(:toolchain)
+    bblock.set_dependencies(hash[:dependencies]) if hash.has_key?(:dependencies)
+    all_blocks << bblock
+  end
+
+  def compile(name, hash)
+    raise "not a hash" unless hash.is_a?(Hash)
+    check_hash hash,[:sources,:includes]
+    bblock = SingleSource.new(name)
+    bblock.set_sources(hash[:sources]) if hash.has_key?(:sources)
+    bblock.set_includes(hash[:includes]) if hash.has_key?(:includes)
+    all_blocks << bblock
+  end
+
+end

data/lib/cxxproject/utils/dot/building_block_graph_writer.rb

@@ -0,0 +1,19 @@
+require 'cxxproject/utils/dot/graph_writer'
+
+class BuildingBlockGraphWriter < GraphWriter
+
+  private
+
+  def write_node(node)
+    @dotFile.write("  \"#{node.graph_name}\"\n")
+  end
+
+  def write_transition(node, dep)
+    @dotFile.write("  \"#{node.graph_name}\" -> \"#{dep.graph_name}\"\n")
+  end
+
+  def get_deps(node)
+    return node.dependencies.map { |depName| ALL_BUILDING_BLOCKS[depName] }
+  end
+
+end

data/lib/cxxproject/utils/dot/graph_writer.rb

@@ -0,0 +1,53 @@
+class GraphWriter
+
+  NO = 0
+  DETAIL = 1
+  YES = 2
+
+  def write_graph(filename,startNodes)
+    @filename = filename
+    start_graph
+    @writtenNodes = []
+    startNodes.each { |n| write_step(n) }
+    end_graph
+  end
+
+  private
+
+  def write_step(node)
+    return if @writtenNodes.include? node
+    @writtenNodes << node
+
+    write_node(node)
+
+    get_deps(node).each do |dep|
+      write_transition(node, dep)
+      write_step(dep)
+    end
+  end
+
+  def start_graph
+    puts "\nWriting dot-file #{@filename}...\n"
+    @dotFile = File.new(@filename, "w")
+    @dotFile.write("digraph TaskGraph\n");
+    @dotFile.write("{\n");
+  end
+
+  def end_graph
+    @dotFile.write("}\n");
+    @dotFile.close()
+  end
+
+  def write_node(node)
+    raise "Must be implemented by descendants"
+  end
+
+  def write_transition(node, dep)
+    raise "Must be implemented by descendants"
+  end
+
+  def get_deps(node)
+    raise "Must be implemented by descendants"
+  end
+
+end

data/lib/cxxproject/utils/dot/task_graph_writer.rb

@@ -0,0 +1,34 @@
+require 'cxxproject/utils/dot/graph_writer'
+
+class TaskGraphWriter < GraphWriter
+
+  def write_graph(filename,startNodes,detailTasks = false)
+    @detailTasks = detailTasks ? GraphWriter::DETAIL : GraphWriter::YES
+    super(filename,startNodes)
+  end
+
+  private
+
+  def get_deps(node)
+    deps = []
+    if node.showInGraph == GraphWriter::YES
+      node.prerequisites.each do |p|
+        task = Rake.application.lookup(p)
+        if (task)
+          next if task.showInGraph < @detailTasks
+          deps << task
+        end
+      end
+    end
+    deps
+  end
+
+  def write_node(node)
+    @dotFile.write("  \"#{node.name}\"\n")
+  end
+
+  def write_transition(node, dep)
+    @dotFile.write("  \"#{node.name}\" -> \"#{dep.name}\"\n")
+  end
+
+end