cxxproject 0.4.6 → 0.5.47

data/lib/cxxproject/buildingblocks/executable.rb

@@ -1,49 +1,244 @@
 require 'cxxproject/buildingblocks/building_block'
 require 'cxxproject/buildingblocks/has_libraries_mixin'
 require 'cxxproject/buildingblocks/has_sources_mixin'
+require 'cxxproject/buildingblocks/has_includes_mixin'
+require 'cxxproject/utils/process'
+require 'cxxproject/utils/utils'
 
-class Executable < BuildingBlock
-  include HasLibraries
-  include HasSources
+require 'tmpdir'
+require 'set'
+require 'etc'
 
-  attr_reader :linker_script
-  attr_reader :mapfile
-  attr_reader :output_file
+module Cxxproject
 
-  def set_linker_script(x)
-    @linker_script = x
-    self
-  end
+  class Executable < BuildingBlock
+    include HasLibraries
+    include HasSources
+    include HasIncludes
 
-  def set_mapfile(x)
-    @mapfile = x
-    self
-  end
+    def set_linker_script(x)
+      @linker_script = x
+      self
+    end
 
-  # set during creating the task - note: depends on the used tcs
-  def set_output_file(x)
-    @output_file = x
-    self
-  end
+    def set_mapfile(x)
+      @mapfile = x
+      self
+    end
+    
+    def initialize(name)
+      super(name)
+      @linker_script = nil
+      @mapfile = nil
+    end
 
-  def initialize(name)
-    super(name)
-    @linker_script = nil
-    @mapfile = nil
-  end
+    def set_executable_name(name) # ensure it's relative
+      @exe_name = name
+    end
 
-  def linker_libs_string
-    @linkerString ||= ""
-  end
+    def get_executable_name() # relative path
+      return @exe_name if @exe_name
 
+      parts = [@output_dir]
 
-  def get_executable_name()
-    File.relFromTo(@complete_output_dir + "/" + @name + @tcs[:LINKER][:OUTPUT_ENDING], @project_dir)
-  end
+      if @output_dir_abs
+        parts = [@output_dir_relPath] if @output_dir_relPath
+      end
 
-  def get_task_name()
-    get_executable_name()
-  end
+      parts << "#{@name}#{@tcs[:LINKER][:OUTPUT_ENDING]}"
+
+      @exe_name = File.join(parts)
+      @exe_name
+    end
+
+    def get_task_name() # full path
+      @project_dir + "/" + get_executable_name
+    end
+
+    def collect_unique(array, set)
+      ret = []
+      array.each do |v|
+        if set.add?(v)
+          ret << v
+        end
+      end
+      ret
+    end
+
+    def adaptPath(v, d, prefix)
+      tmp = nil
+      if File.is_absolute?(v)
+        tmp = v
+      else
+        prefix ||= File.rel_from_to_project(@project_dir,d.project_dir)
+        tmp = File.add_prefix(prefix, v)
+      end
+      tmp = "\"" + tmp + "\"" if tmp.include?(" ")
+      [tmp, prefix]
+    end
+
+    def linker_lib_string()
+      @lib_path_set = Set.new
+      @dep_set = Set.new
+      calc_linker_lib_string_recursive(self)
+    end
+
+    def calc_linker_lib_string_recursive(d)
+      res = []
+    
+      return res if @dep_set.include?d
+      @dep_set << d
+    
+      if HasLibraries === d
+        prefix = nil
+        linker = @tcs[:LINKER]
+      
+        d.lib_elements.each do |elem|
+          case elem[0]
+            when HasLibraries::LIB
+              res << "#{linker[:LIB_FLAG]}#{elem[1]}"
+            when HasLibraries::USERLIB
+              res << "#{linker[:USER_LIB_FLAG]}#{elem[1]}"
+            when HasLibraries::LIB_WITH_PATH
+              tmp, prefix = adaptPath(elem[1], d, prefix)
+              res <<  tmp
+            when HasLibraries::SEARCH_PATH
+              tmp, prefix = adaptPath(elem[1], d, prefix)
+              if not @lib_path_set.include?tmp
+                @lib_path_set << tmp
+                res << "#{linker[:LIB_PATH_FLAG]}#{tmp}"
+              end
+            when HasLibraries::DEPENDENCY
+              if ALL_BUILDING_BLOCKS.include?elem[1]
+                bb = ALL_BUILDING_BLOCKS[elem[1]]
+                res += calc_linker_lib_string_recursive(bb)
+              end
+          end
+        end
+      end
+      
+      res
+    end
 
+    # create a task that will link an executable from a set of object files
+    #
+    def convert_to_rake()
+      object_multitask = prepare_tasks_for_objects()
 
+      linker = @tcs[:LINKER]
+
+      res = typed_file_task Rake::Task::EXECUTABLE, get_task_name => object_multitask do
+        Dir.chdir(@project_dir) do
+
+          cmd = [linker[:COMMAND]] # g++
+          cmd += linker[:MUST_FLAGS].split(" ")
+          cmd += linker[:FLAGS].gsub(/\"/,"").split(" ") # double quotes within string do not work on windows...
+          cmd << linker[:EXE_FLAG]
+          cmd << get_executable_name # -o debug/x.exe
+          cmd += @objects
+          cmd << linker[:SCRIPT] if @linker_script # -T
+          cmd << @linker_script if @linker_script # xy/xy.dld
+          cmd << linker[:MAP_FILE_FLAG] if @mapfile # -Wl,-m6
+          cmd += linker[:LIB_PREFIX_FLAGS].split(" ") # "-Wl,--whole-archive "
+          cmd += linker_lib_string
+          cmd += linker[:LIB_POSTFIX_FLAGS].split(" ") # "-Wl,--no-whole-archive "
+
+          mapfileStr = @mapfile ? " >#{@mapfile}" : ""
+          if Cxxproject::Utils.old_ruby?
+            cmd.map! {|c| ((c.include?" ") ? ("\""+c+"\"") : c )}
+
+            # TempFile used, because some compilers, e.g. diab, uses ">" for piping to map files:
+            cmdLine = cmd.join(" ") + " 2>" + get_temp_filename
+            if cmdLine.length > 8000
+              inputName = get_executable_name+".tmp"
+              File.open(inputName,"wb") { |f| f.write(cmd[1..-1].join(" ")) }
+              inputName = "\""+inputName+"\"" if inputName.include?" "
+              consoleOutput = `#{linker[:COMMAND] + " @" + inputName + mapfileStr + " 2>" + get_temp_filename}`
+            else
+              consoleOutput = `#{cmd.join(" ") + mapfileStr + " 2>" + get_temp_filename}`
+            end
+            consoleOutput.concat(read_file_or_empty_string(get_temp_filename))          
+          else
+            rd, wr = IO.pipe
+            cmd << {
+             :out=> @mapfile ? "#{@mapfile}" : wr, # > xy.map
+             :err=>wr
+            }
+            sp = spawn(*cmd)
+            cmd.pop
+
+            # for console print
+            cmd << " >#{@mapfile}" if @mapfile
+            consoleOutput = ProcessHelper.readOutput(sp, rd, wr)
+          end
+          
+          process_result(cmd, consoleOutput, linker[:ERROR_PARSER], "Linking #{get_executable_name}")
+            
+          check_config_file()
+        end
+      end
+      res.enhance(@config_files)
+      res.enhance([@project_dir + "/" + @linker_script]) if @linker_script
+
+      add_output_dir_dependency(get_task_name, res, true)
+      add_grouping_tasks(get_task_name)
+      setup_rake_dependencies(res, object_multitask)
+      
+      # check that all source libs are checked even if they are not a real rake dependency (can happen if "build this project only")
+      begin
+        libChecker = task get_task_name+"LibChecker" do
+          if File.exists?(get_task_name) # otherwise the task will be executed anyway
+            all_dependencies.each do |bb|
+              if bb and SourceLibrary === bb
+                f = bb.get_task_name # = abs path of library
+                if not File.exists?(f) or File.mtime(f) > File.mtime(get_task_name)
+                  def res.needed?
+                    true
+                  end
+                  break
+                end
+              end
+            end
+          end
+        end
+      rescue
+        def res.needed?
+          true
+        end
+      end
+      libChecker.transparent_timestamp = true
+      res.enhance([libChecker])
+
+      
+      return res
+    end
+
+    def add_grouping_tasks(executable)
+      namespace 'exe' do
+        desc executable
+        task @name => executable
+      end
+      create_run_task(executable, @name)
+    end
+
+    def create_run_task(executable, name)
+      namespace 'run' do
+        desc "run executable #{executable}"
+        res = task name => executable do |t|
+          run_command(t, executable)
+        end
+        res.type = Rake::Task::RUN
+        res
+      end
+    end
+
+    def run_command(task, command)
+      sh "#{command}"
+    end
+
+    def get_temp_filename
+      Dir.tmpdir + "/lake.tmp"
+    end
+
+  end
 end

data/lib/cxxproject/buildingblocks/has_dependencies_mixin.rb

@@ -1,57 +1,83 @@
-module HasDependencies
+module Cxxproject
+  module HasDependencies
 
-  def dependencies
-    @dependencies ||= []
-  end
-  def set_dependencies(deps)
-    @dependencies = deps.map { |dep| dep.instance_of?(String) ? dep : dep.name }
-    self
-  end
+    def dependencies
+      @dependencies ||= []
+    end
 
-  # if set, includes and libs are taken from this array, not from @dependencies.
-  # task deps are still taken from @dependencies.
-  # use case: circular deps are allowed on "include-level", but not on "task-level".
-  def helper_dependencies
-    @helper_dependencies ||= []
-  end
+    def helper_dependencies
+      @helper_dependencies ||= []
+    end
+    
+   def set_dependencies(deps)
+      @dependencies = deps.map { |dep| dep.instance_of?(String) ? dep : dep.name }
+      self
+    end
+    
+    def set_helper_dependencies(deps)
+      @helper_dependencies = deps.map { |dep| dep.instance_of?(String) ? dep : dep.name }
+      self
+    end
 
-  def set_helper_dependencies(deps)
-    @helper_dependencies = deps.map { |dep| dep.instance_of?(String) ? dep : dep.name }
-  end
+    def direct_deps
+      return @direct_deps if @direct_deps
 
-  # will be calculated at the beginning of creating the building block task
-  def all_dependencies
-    @all_dependencies ||= []
-  end
+      @all_dependencies_set = Set.new
+      @all_dependencies_set << self
+      @all_dependencies = [self]
 
-  # inclusive self!!
-  def calc_transitive_dependencies
-    deps = [self.name]
-    @all_dependencies = get_transitive_dependencies_internal(deps)
-  end
+      depList = helper_dependencies.length > 0 ? helper_dependencies : dependencies
+
+      depList.each do |d|
+        bb = ALL_BUILDING_BLOCKS[d]
+        if not bb
+          raise "Error: while reading config file for #{self.name}: dependent building block \"#{d}\" was specified but not found!"
+        end
+        next if @all_dependencies_set.include?bb
+
+        @all_dependencies << bb
+        @all_dependencies_set << bb
+
+        # deps in modules may be splitted into its contents
+        if ModuleBuildingBlock === bb
+          bb.contents.each do |c|
+            next if @all_dependencies_set.include?c
+            @all_dependencies << c
+            @all_dependencies_set << c
+          end
+        end
 
-  def get_transitive_dependencies_internal(deps)
-    depsToCheck = []
-    depList = helper_dependencies.length > 0 ? helper_dependencies : dependencies
-    depList.each do |d|
-      if not deps.include?d
-        deps << d
-        depsToCheck << d
       end
+
+      @direct_deps = @all_dependencies.dup
+      @direct_deps
     end
 
-    # two-step needed to keep order of dependencies for includes, lib dirs, etc
-    depsToCheck.each do |d|
-      begin
-        raise "ERROR: while reading config file for #{self.name}: dependent building block \"#{d}\" was specified but not found!" unless ALL_BUILDING_BLOCKS[d]
-        ALL_BUILDING_BLOCKS[d].get_transitive_dependencies_internal(deps)
-      rescue Exception => e
-        puts e
-        exit
+    def all_dependencies()
+      return @all_dependencies if @all_deps_calculated
+
+      direct_deps.each do |d|
+        d.all_dependencies_recursive(@all_dependencies, @all_dependencies_set)
       end
+
+      @all_deps_calculated = true
+      @all_dependencies
     end
-    deps
 
-  end
+    def all_dependencies_recursive(all_deps, all_deps_set)
+      deps = [] # needed to keep order
+
+      direct_deps.each do |d|
+        next if all_deps_set.include?d
+        all_deps << d
+        all_deps_set << d
+        deps << d
+      end
+
+      deps.each do |d|
+        d.all_dependencies_recursive(all_deps, all_deps_set)
+      end
+    end
 
+  end
 end

data/lib/cxxproject/buildingblocks/has_includes_mixin.rb

@@ -0,0 +1,20 @@
+module Cxxproject
+  module HasIncludes
+    def includes
+      @includes ||= []
+    end
+    def set_includes(x)
+      @includes = x
+      self
+    end
+    
+    def local_includes
+      @local_includes ||= []
+    end
+    def set_local_includes(x)
+      @local_includes = x
+      self
+    end    
+    
+  end
+end

data/lib/cxxproject/buildingblocks/has_libraries_mixin.rb

@@ -1,35 +1,34 @@
-module HasLibraries
+module Cxxproject
+  module HasLibraries
+    LIB = 1
+    USERLIB = 2
+    LIB_WITH_PATH = 3
+    SEARCH_PATH = 4
+    DEPENDENCY = 5
+   
+    def lib_elements
+      @lib_elements ||= []
+    end
 
-  def user_libs
-    @user_libs ||= []
-  end
-  def set_user_libs(x)
-    @user_libs = x
-    self
-  end
+    # value: can be string or building block
+    def add_lib_element(type, value, front = false)
+      elem = [type, value.instance_of?(String) ? value : value.name]
+      if front
+        lib_elements.unshift(elem)
+      else
+        lib_elements << elem
+      end
+    end
 
-  def libs_to_search
-    @libs_to_search ||= []
-  end
-  def set_libs_to_search(x)
-    @libs_to_search = x
-    self
-  end
+    # 1. element: type
+    # 2. element: name, must not be a building block
+    def add_lib_elements(array_of_tuples, front = false)
+      if front
+        @lib_elements = array_of_tuples+lib_elements
+      else
+        lib_elements.concat(array_of_tuples)
+      end
+    end
 
-  def lib_searchpaths
-    @lib_searchpaths ||= []
-  end
-  def set_lib_searchpaths(x)
-    @lib_searchpaths = x
-    self
   end
-
-  def libs_with_path
-    @libs_with_path ||= []
-  end
-  def set_libs_with_path(x)
-    @libs_with_path = x
-    self
-  end
-
 end