cxxproject 0.4.6 → 0.5.47

data/lib/cxxproject/task_maker.rb

@@ -1,418 +0,0 @@
-require 'cxxproject/buildingblocks/module'
-require 'cxxproject/buildingblocks/makefile'
-require 'cxxproject/buildingblocks/executable'
-require 'cxxproject/buildingblocks/source_library'
-require 'cxxproject/buildingblocks/single_source'
-require 'cxxproject/buildingblocks/binary_library'
-require 'cxxproject/buildingblocks/custom_building_block'
-require 'cxxproject/buildingblocks/command_line'
-require 'cxxproject/extensions/rake_ext'
-require 'cxxproject/extensions/file_ext'
-require 'cxxproject/utils/dot/graph_writer'
-
-require 'logger'
-require 'yaml'
-require 'tmpdir'
-
-
-# A class which encapsulates the generation of c/cpp artifacts like object-files, libraries and so on
-class TaskMaker
-
-  def initialize(logger)
-    @log = logger
-  end
-
-  def set_loglevel(level)
-    @log.level = level
-  end
-
-  def add_file_to_clean_task(name)
-    CLEAN.include(name)
-  end
-  def add_task_to_clean_task(task)
-    Rake.application["clean"].enhance([task])
-  end
-  def already_added_to_clean?(task)
-    Rake.application["clean"].prerequisites.include?task
-  end
-
-  # this is the main api for the task_maker
-  # it will create the tasks that are needed in order to create
-  # one building block
-  #
-  # a building-block can be one of the following:
-  # * a source-library-block (a static lib that will be created)
-  # * an executable-block (which itself might need other libraries)
-  # * a binary-library-block (for which we do not need to do anything since it is already done)
-  # * a custom building block
-  # * a compile-only source file block
-  def create_tasks_for_building_block(bb)
-    @log.debug "create tasks for: #{bb.name}"
-    CLOBBER.include(bb.complete_output_dir)
-
-    bb.calc_transitive_dependencies()
-
-    res = nil
-    if HasSources === bb
-      res = create_tasks_for_buildingblock_with_sources(bb)
-    else
-      if (bb.instance_of?(BinaryLibrary)) then
-        res = create_binary_lib_task(bb)
-      elsif (bb.instance_of?(CustomBuildingBlock)) then
-        # todo...
-      elsif (bb.instance_of?(CommandLine)) then
-        res = create_commandline_task(bb)
-      elsif (bb.instance_of?(Makefile)) then
-        res = create_makefile_task(bb)
-      else
-        raise 'unknown building block'
-      end
-    end
-
-    init_show_in_graph_flags(bb)
-    add_building_block_deps_as_prerequisites(bb,res)
-    res
-  end
-
-  private
-
-  def create_tasks_for_buildingblock_with_sources(bb)
-    res = nil
-    bb.calc_compiler_strings()
-    object_tasks, objects_multitask = create_tasks_for_objects(bb)
-    if (bb.instance_of?(SourceLibrary)) then
-      res = create_source_lib(bb, object_tasks, objects_multitask)
-    elsif (bb.instance_of?(Executable)) then
-      res = create_exe_task(bb, object_tasks, objects_multitask)
-    elsif (bb.instance_of?(SingleSource)) then
-      res = create_single_source_task(bb, objects_multitask)
-    elsif (bb.instance_of?(ModuleBuildingBlock)) then
-      res = task bb.get_task_name
-      res.transparent_timestamp = true
-    end
-    res
-  end
-
-  def create_binary_lib_task(bb)
-    res = task bb.get_task_name
-    def res.needed?
-      return false
-    end
-    res.transparent_timestamp = true
-    res
-  end
-
-  def init_show_in_graph_flags(bb)
-    bb.config_files.each do |cf|
-      # Rake.application[cf].showInGraph = GraphWriter::NO
-    end
-  end
-
-  # convert building block deps to rake task prerequisites (e.g. exe needs lib)
-  def add_building_block_deps_as_prerequisites(bb,res)
-    bb.dependencies.reverse.each do |d|
-      begin
-        raise "ERROR: tried to add the dependencies of \"#{d}\" to \"#{bb.name}\" but such a building block could not be found!" unless ALL_BUILDING_BLOCKS[d]
-        res.prerequisites.unshift(ALL_BUILDING_BLOCKS[d].get_task_name) 
-      rescue Exception => e
-        puts e
-        exit
-      end
-    end
-  end
-
-  def create_single_source_task(bb, objects_multitask)
-    res = nil
-    if objects_multitask
-      res = objects_multitask
-      namespace "compile" do
-        desc "compile sources in #{bb.name}-configuration"
-        task bb.name => objects_multitask
-      end
-      objects_multitask.add_description("compile sources only")
-    end
-    res
-  end
-
-  def create_tasks_for_objects(bb)
-    object_tasks = create_object_file_tasks(bb)
-    objects_multitask = []
-    if object_tasks.length > 0
-      objects_multitask = multitask bb.get_sources_task_name => object_tasks
-      def objects_multitask.needed?
-        return false
-      end
-      objects_multitask.transparent_timestamp = true
-    end
-    [object_tasks,objects_multitask]
-  end
-
-  def convert_depfile(depfile, bb)
-    deps = ""
-    File.open(depfile, "r") do |infile|
-      while (line = infile.gets)
-        deps << line
-      end
-    end
-
-    deps = deps.gsub(/\\\n/,'').split()[1..-1]
-    deps.map!{|d| File.expand_path(d)}
-
-    FileUtils.mkpath File.dirname(depfile)
-    File.open(depfile, 'wb') do |f|
-      f.write(deps.to_yaml)
-    end
-  end
-
-  def create_apply_task(depfile,outfileTask,bb)
-    res = task "#{depfile}.apply" do |task|
-      deps = nil
-      begin
-        deps = YAML.load_file(depfile)
-      rescue
-        deps = nil
-        # may happen if depfile was not converted the last time
-      end
-      if (deps)
-        outfileTask.enhance(deps)
-      else
-        def outfileTask.needed?
-          true
-        end
-      end
-    end
-    res.showInGraph = GraphWriter::NO
-    res.transparent_timestamp = true
-    res
-  end
-
-  def create_object_file_tasks(bb)
-    tasks = []
-
-    bb.sources.each do |s|
-      type = bb.get_source_type(s)
-      if type.nil?
-        puts "Warning: no valid source type for #{File.relFromTo(s,bb.project_dir)}, will be ignored!"
-        next
-      end
-
-      source = File.relFromTo(s,bb.project_dir)
-      object = bb.get_object_file(s)
-      depfile = bb.get_dep_file(object)
-
-      if bb.tcs4source().include?s
-        tcs = bb.tcs4source()[s]
-        iString = bb.get_include_string(tcs, type)
-        dString = bb.get_define_string(tcs, type)
-      else
-        tcs = bb.tcs
-        iString = bb.include_string(type)
-        dString = bb.define_string(type)
-      end
-
-      compiler = tcs[:COMPILER][type]
-      depStr = type == :ASM ? "" : (compiler[:DEP_FLAGS] + depfile) # -MMD -MF debug/src/abc.o.d
-
-      cmd = [compiler[:COMMAND], # g++
-        compiler[:COMPILE_FLAGS], # -c
-        depStr,
-        compiler[:FLAGS], # -g3
-        iString, # -I include
-        dString, # -DDEBUG
-        compiler[:OBJECT_FILE_FLAG], # -o
-        object, # debug/src/abc.o
-        source # src/abc.cpp
-      ].reject{|e| e == ""}.join(" ")
-
-      add_file_to_clean_task(depfile) if depStr != ""
-      add_file_to_clean_task(object)
-
-      outfileTask = file object => source do
-        puts cmd
-        puts `#{cmd + " 2>&1"}`
-        raise "System command failed" if $?.to_i != 0
-        convert_depfile(depfile, bb) if depStr != ""
-      end
-      outfileTask.showInGraph = GraphWriter::DETAIL
-      outfileTask.enhance(bb.config_files)
-      set_output_dir(object, outfileTask)
-      outfileTask.enhance([create_apply_task(depfile,outfileTask,bb)]) if depStr != ""
-      tasks << outfileTask
-    end
-    tasks
-  end
-
-  def create_commandline_task(bb)
-  	res = task bb.get_task_name do
-  	  cmd = bb.get_command_line
-      puts cmd
-      puts `#{cmd + " 2>&1"}`
-      raise "System command failed" if $?.to_i != 0
-  	end
-  	res.transparent_timestamp = true
-  	res
-  end
-
-  def create_makefile_task(bb)
-    mfile = bb.get_makefile()
-    cmd = [bb.tcs[:MAKE][:COMMAND], # make
-      bb.get_target, # all
-      bb.tcs[:MAKE][:MAKE_FLAGS], # ??
-      bb.tcs[:MAKE][:FLAGS], # -j
-      bb.tcs[:MAKE][:DIR_FLAG], # -C
-      File.dirname(mfile), # x/y
-      bb.tcs[:MAKE][:FILE_FLAG], # -f
-      File.basename(mfile) # x/y/makefile
-    ].reject{|e| e == ""}.join(" ")
-    mfileTask = task bb.get_task_name do
-      puts cmd
-      puts `#{cmd + " 2>&1"}`
-      raise "System command failed" if $?.to_i != 0
-    end
-    mfileTask.transparent_timestamp = true
-    mfileTask.enhance(bb.config_files)
-
-    # generate the clean task
-    if not already_added_to_clean?(mfile+"Clean")
-      cmdClean = [bb.tcs[:MAKE][:COMMAND], # make
-        bb.tcs[:MAKE][:CLEAN], # clean
-        bb.tcs[:MAKE][:DIR_FLAG], # -C
-        File.dirname(mfile), # x/y
-        bb.tcs[:MAKE][:FILE_FLAG], # -f
-        File.basename(mfile) # x/y/makefile
-      ].reject{|e| e == ""}.join(" ")
-      mfileCleanTask = task mfile+"Clean" do
-        puts cmdClean
-        puts `#{cmdClean + " 2>&1"}`
-        raise "System command failed" if $?.to_i != 0
-      end
-      add_task_to_clean_task(mfileCleanTask)
-    end
-    mfileTask
-  end
-
-  # task that will link the given object files to a static lib
-  #
-  def create_source_lib(bb, objects, object_multitask)
-    archive = bb.get_archive_name()
-
-    cmd = [bb.tcs[:ARCHIVER][:COMMAND], # ar
-      bb.tcs[:ARCHIVER][:ARCHIVE_FLAGS], # -r
-      bb.tcs[:ARCHIVER][:FLAGS], # ??
-      archive, # debug/x.a
-      objects.reject{|e| e == ""}.join(" ") # debug/src/abc.o debug/src/xy.o
-    ].reject{|e| e == ""}.join(" ")
-
-    res = file archive => object_multitask do
-      puts cmd
-      puts `#{cmd + " 2>&1"}`
-      raise "System command failed" if $?.to_i != 0
-    end
-    add_file_to_clean_task(archive)
-    res.enhance(bb.config_files)
-    set_output_dir(archive, res)
-    namespace 'lib' do
-      desc archive
-      task bb.name => archive
-    end
-    res
-  end
-
-  # create a task that will link an executable from a set of object files
-  #
-  def create_exe_task(bb, objects, object_multitask)
-    executable = bb.get_executable_name()
-    add_file_to_clean_task(executable)
-    scriptFile = ""
-    script = ""
-    if bb.linker_script
-      scriptFile = File.relFromTo(bb.linker_script, bb.project_dir)
-      script = "#{bb.tcs[:LINKER][:SCRIPT]} #{scriptFile}"  # -T xy/xy.dld
-    end
-
-    mapfile = bb.mapfile ? "#{bb.tcs[:LINKER][:MAP_FILE_FLAG]} >#{File.relFromTo(bb.mapfile, bb.complete_output_dir)}" : "" # -Wl,-m6 > xy.map
-
-    # calc linkerLibString (two steps for removing duplicates)
-    lib_searchpaths_array = []
-    libs_to_search_array = []
-    user_libs_array = []
-    libs_with_path_array = []
-    deps = bb.all_dependencies
-    deps.each do |e|
-      d = ALL_BUILDING_BLOCKS[e]
-      next if not HasLibraries === d
-      d.lib_searchpaths.each { |k| lib_searchpaths_array << File.relFromTo(k, d.project_dir) }
-      d.libs_to_search.each  { |k| libs_to_search_array  << k }
-      d.user_libs.each       { |k| user_libs_array       << k }
-      d.libs_with_path.each  { |k| libs_with_path_array  << File.relFromTo(k, d.project_dir) }
-    end
-    strArray = []
-    lib_searchpaths_array.uniq.each { |k| strArray << "#{bb.tcs[:LINKER][:LIB_PATH_FLAG]}#{k}" }
-    libs_to_search_array.uniq.each  { |k| strArray << "#{bb.tcs[:LINKER][:LIB_FLAG]}#{k}" }
-    user_libs_array.uniq.each       { |k| strArray << "#{bb.tcs[:LINKER][:USER_LIB_FLAG]}#{k}" }
-    libs_with_path_array.uniq.each  { |k| strArray << "#{k}" }
-    linkerLibString = strArray.reject{|e| e == ""}.join(" ")
-
-    cmd = [bb.tcs[:LINKER][:COMMAND], # g++
-      bb.tcs[:LINKER][:MUST_FLAGS], # ??
-      bb.tcs[:LINKER][:FLAGS], # --all_load
-      bb.tcs[:LINKER][:EXE_FLAG], # -o
-      executable, # debug/x.o
-      objects.reject{|e| e == ""}.join(" "), # debug/src/abc.o debug/src/xy.o
-      script,
-      mapfile,
-      bb.tcs[:LINKER][:LIB_PREFIX_FLAGS], # "-Wl,--whole-archive "
-      linkerLibString,
-      bb.tcs[:LINKER][:LIB_POSTFIX_FLAGS] # "-Wl,--no-whole-archive "
-    ].reject{|e| e == ""}.join(" ")
-
-    create_run_task(executable, bb.config_files, bb.name)
-
-    res = file executable => object_multitask do
-      # TempFile used, because some compilers, e.g. diab, uses ">" for piping to map files:
-      puts cmd
-      puts `#{cmd + " 2>" + get_temp_filename}`
-      puts read_temp_file
-      raise "System command failed" if $?.to_i != 0
-    end
-    res.enhance(bb.config_files)
-    res.enhance([scriptFile]) unless scriptFile==""
-    set_output_dir(executable, res)
-
-    namespace 'exe' do
-      desc executable
-      task bb.name => executable
-    end
-    res
-  end
-
-  def create_run_task(executable, configFiles, name)
-    namespace 'run' do
-      desc "run executable #{executable}"
-      task name => executable do
-        sh "#{executable}"
-      end
-    end
-  end
-
-  def set_output_dir(file, taskOfFile)
-    outputdir = File.dirname(file)
-    directory outputdir
-    taskOfFile.enhance([outputdir])
-  end
-
-  def get_temp_filename
-    Dir.tmpdir + "/lake.tmp"
-  end
-
-  def read_temp_file
-    lines = []
-    File.open(get_temp_filename, "r") do |infile|
-      while (line = infile.gets)
-        lines << line
-      end
-    end
-    lines
-  end
-
-end

data/lib/cxxproject/testinstanceeval.rb

@@ -1,65 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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/torake/compiler.rb

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

data/lib/cxxproject/torake/gcccompiler.rb

@@ -1,7 +0,0 @@
-
-class GccCompiler < Compiler
-  def initialize(output_path)
-    super(output_path)
-  end
-end
-

data/lib/cxxproject/torake/osxcompiler.rb

@@ -1,7 +0,0 @@
-
-class OsxCompiler < Compiler
-  def initialize(output_path)
-    super(output_path)
-  end
-end
-

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

@@ -1,19 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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