cxxproject 0.4.6 → 0.5.47

data/lib/cxxproject/buildingblocks/has_sources_mixin.rb

@@ -1,85 +1,364 @@
-module HasSources
+require 'yaml'
+require 'cxxproject/utils/process'
+require 'cxxproject/utils/utils'
+require 'cxxproject/utils/printer'
 
-  def sources
-    @sources ||= []
-  end
-  def set_sources(x)
-    @sources = x
-    self
-  end
+module Cxxproject
+  module HasSources
 
-  def includes
-    @includes ||= []
-  end
-  def set_includes(x)
-    @includes = x
-    self
-  end
+    attr_writer :file_dependencies
+    attr_reader :incArray
 
-  # used when a source file shall have different tcs than the project default
-  def tcs4source
-    @tcs4source ||= {}
-  end
-  def set_tcs4source(x)
-    @tcs4source = x
-    self
-  end
+    def file_dependencies
+      @file_dependencies ||= []
+    end
 
-  def include_string(type)
-    @include_string[type] ||= ""
-  end
+    def sources
+      @sources ||= []
+    end
+    def set_sources(x)
+      @sources = x
+      self
+    end
+    
+    def deps_in_depFiles
+      @deps_in_depFiles ||= Set.new
+    end
 
-  def define_string(type)
-    @define_string[type] ||= ""
-  end
+    def source_patterns
+      @source_patterns ||= []
+    end
+    def set_source_patterns(x)
+      @source_patterns = x
+      self
+    end
+
+    def exclude_sources
+      @exclude_sources ||= []
+    end
+    def set_exclude_sources(x)
+      @exclude_sources = x
+      self
+    end
 
-  def calc_compiler_strings()
-    @include_string = {}
-    @define_string = {}
+    # used when a source file shall have different tcs than the project default
+    def tcs4source(source)
+      @tcs4source ||= {}
 
-    @incArray = []
-    all_dependencies.each do |e|
-      d = ALL_BUILDING_BLOCKS[e]
-      next if not HasSources === d
-      if d.includes.length == 0
-        @incArray << File.relFromTo("include", d.project_dir)
+      if @tcs4source.include?(source)
+        @tcs4source[source]
       else
-        d.includes.each { |k| @incArray << File.relFromTo(k, d.project_dir) }
+        @tcs
       end
     end
 
-    [:CPP, :C, :ASM].each do |type|
-      @include_string[type] = get_include_string(@tcs, type)
-      @define_string[type] = get_define_string(@tcs, type)
+    def set_tcs4source(x)
+      @tcs4source = x
+      self
     end
-  end
 
-  def get_include_string(tcs, type)
-    @incArray.uniq.map!{|k| "#{tcs[:COMPILER][type][:INCLUDE_PATH_FLAG]}#{k}"}.join(" ")
-  end
+    def include_string(type)
+      @include_string[type] ||= ""
+    end
 
-  def get_define_string(tcs, type)
-    @tcs[:COMPILER][type][:DEFINES].map {|k| "#{tcs[:COMPILER][type][:DEFINE_FLAG]}#{k}"}.join(" ")
-  end
+    def define_string(type)
+      @define_string[type] ||= ""
+    end
 
-  def get_object_file(source)
-    File.relFromTo(source, @complete_output_dir + (@output_dir_abs ? ("/" + @name) : "") ) + ".o"
-  end
+    def calc_compiler_strings()
+      @include_string = {}
+      @define_string = {}
 
-  def get_dep_file(object)
-    object + ".d"
-  end
+      @incArray = local_includes.dup
+      @incArray.concat(includes)
 
-  def get_source_type(source)
-    ex = File.extname(source)
-    [:CPP, :C, :ASM].each do |t|
-      return t if tcs[:COMPILER][t][:SOURCE_FILE_ENDINGS].include?(ex)
+      if Rake::application.deriveIncludes
+        all_dependencies.each_with_index do |d,i|
+          next if not HasIncludes === d
+          next if i == 0
+          prefix = File.rel_from_to_project(@project_dir,d.project_dir)
+          next if not prefix
+         @incArray.concat(d.includes.map {|inc| File.add_prefix(prefix,inc)})
+        end
+        @incArray.uniq!
+      end
+      
+      [:CPP, :C, :ASM].each do |type|
+        @include_string[type] = get_include_string(@tcs, type)
+        @define_string[type] = get_define_string(@tcs, type)
+      end
     end
-    nil
-  end
 
-  def get_sources_task_name
-    "Sources of #{name}"
-  end
+    def get_include_string(tcs, type)
+      @incArray.map {|k| "#{tcs[:COMPILER][type][:INCLUDE_PATH_FLAG]}#{k}"}
+    end
+
+    def get_define_string(tcs, type)
+      tcs[:COMPILER][type][:DEFINES].map {|k| "#{tcs[:COMPILER][type][:DEFINE_FLAG]}#{k}"}
+    end
+
+    def get_object_file(sourceRel)
+      parts = [@output_dir]
+      if @output_dir_abs
+        parts = [@output_dir_relPath] if @output_dir_relPath
+        parts << 'objects'
+        parts << @name
+      end
+
+      parts << sourceRel.chomp(File.extname(sourceRel))
+      File.join(parts) + ".o"
+    end
+
+    def get_dep_file(object)
+      object + ".d"
+    end
+
+    def get_source_type(source)
+      ex = File.extname(source)
+      [:CPP, :C, :ASM].each do |t|
+        return t if tcs[:COMPILER][t][:SOURCE_FILE_ENDINGS].include?(ex)
+      end
+      nil
+    end
+
+    def get_sources_task_name
+      "Objects of #{name}"
+    end
 
+    def parse_includes(deps)
+      #deps look like "test.o: test.cpp test.h" -> remove .o and .cpp from list
+      return deps.gsub(/\\\n/,'').split()[2..-1]
+    end
+
+    def convert_depfile(depfile)
+      deps_string = read_file_or_empty_string(depfile)
+      deps = parse_includes(deps_string)
+      if deps.nil?
+        return # ok, because next run the source will be recompiled due to invalid depfile
+      end
+      expanded_deps = deps.map do |d|
+        tmp = d.gsub(/[\\]/,'/')
+        deps_in_depFiles << tmp
+        tmp
+      end
+
+      FileUtils.mkpath File.dirname(depfile)
+      File.open(depfile, 'wb') do |f|
+        f.write(expanded_deps.to_yaml)
+      end
+    end
+
+    def apply_depfile(depfile,outfileTask)
+      deps = nil
+      begin
+        deps = YAML.load_file(depfile)
+        deps.each do |d|
+          deps_in_depFiles << d
+          f = file d
+          f.ignore_missing_file
+        end
+        outfileTask.enhance(deps)
+      rescue
+        # may happen if depfile was not converted the last time
+        def outfileTask.needed?
+          true
+        end
+      end
+    end
+
+    def create_object_file_tasks()
+
+      sources_to_build = {}
+
+      exclude_files = Set.new
+      exclude_sources.each do |p|
+        if p.include?".."
+          Printer.printError "Error: Exclude source file pattern '#{p}' must not include '..'"
+          return nil
+        end
+              
+        Dir.glob(p).each {|f| exclude_files << f}
+      end
+      files = Set.new  # do not build the same file twice
+
+      sources.each do |f|
+        if f.include?".."
+          Printer.printError "Error: Source file '#{f}' must not include '..'"
+          return nil
+        end
+
+        next if exclude_files.include?(f)
+        next if files.include?(f)
+        files << f
+        sources_to_build[f] = tcs4source(f)
+      end
+
+      source_patterns.each do |p|
+        if p.include?".."
+          Printer.printError "Error: Source file pattern '#{p}' must not include '..'"
+          return nil
+        end
+      
+        globRes = Dir.glob(p)
+        if (globRes.length == 0)
+          Printer.printWarning "Warning: Source file pattern '#{p}' did not match to any file"
+        end
+        globRes.each do |f|
+          next if exclude_files.include?(f)
+          next if files.include?(f)
+          files << f
+          t = tcs4source(f)
+          t = tcs4source(p) if t == nil 
+          sources_to_build[f] = t
+        end
+      end
+      
+      ordered = sources_to_build.keys.sort()
+      dirs = []
+      filemap = {}      
+      ordered.reverse.each do |o|
+        d = File.dirname(o)
+        if filemap.include?(d)
+          filemap[d] << o
+        else
+          filemap[d] = [o]
+	      dirs << d
+        end
+      end 
+      
+      obj_tasks = []
+      dirs.each do |d|
+        filemap[d].reverse.each do |f|
+          obj_task = create_object_file_task(f, sources_to_build[f])
+          obj_tasks << obj_task unless obj_task.nil?
+        end
+      end
+      obj_tasks
+    end
+
+    def create_object_file_task(sourceRel, the_tcs)
+      if File.is_absolute?(sourceRel)
+        sourceRel = File.rel_from_to_project(@project_dir, sourceRel, false)
+      end
+    
+      type = get_source_type(sourceRel)
+      return nil if type.nil?
+
+      objectRel = get_object_file(sourceRel)
+      @objects << objectRel
+      object = File.expand_path(objectRel)
+      source = File.expand_path(sourceRel)
+
+      depStr = ""
+      dep_file = nil
+      if type != :ASM
+        dep_file = get_dep_file(objectRel)
+        dep_file = "\""+dep_file+"\"" if dep_file.include?" "
+        depStr = the_tcs[:COMPILER][type][:DEP_FLAGS]
+      end
+
+      res = typed_file_task Rake::Task::OBJECT, object => source do
+        i_array = the_tcs == @tcs ? @include_string[type] : get_include_string(the_tcs, type)
+        d_array = the_tcs == @tcs ? @define_string[type] : get_define_string(the_tcs, type)
+
+        compiler = the_tcs[:COMPILER][type]
+        cmd = [compiler[:COMMAND]]
+        cmd += compiler[:COMPILE_FLAGS].split(" ")
+        if dep_file
+          cmd += depStr.split(" ")
+          if the_tcs[:COMPILER][type][:DEP_FLAGS_SPACE]
+            cmd << dep_file
+          else
+            cmd[cmd.length-1] << dep_file
+          end
+        end
+        cmd += compiler[:FLAGS].gsub(/\"/,"").split(" ") # double quotes within string do not work on windows...
+        cmd += i_array
+        cmd += d_array
+        cmd += (compiler[:OBJECT_FILE_FLAG] + objectRel).split(" ")
+        cmd << sourceRel
+
+        if Cxxproject::Utils.old_ruby?
+          cmd.map! {|c| ((c.include?" ") ? ("\""+c+"\"") : c )}
+          cmdLine = cmd.join(" ")
+          if cmdLine.length > 8000
+            inputName = objectRel+".tmp"
+            File.open(inputName,"wb") { |f| f.write(cmd[1..-1].join(" ")) }
+            inputName = "\""+inputName+"\"" if inputName.include?" "
+            consoleOutput = `#{compiler[:COMMAND] + " @" + inputName}`
+          else
+            consoleOutput = `#{cmd.join(" ")} 2>&1`
+          end
+        else
+          rd, wr = IO.pipe
+          cmd << {
+           :err=>wr,
+           :out=>wr
+          }
+          sp = spawn(*cmd)
+          cmd.pop
+          consoleOutput = ProcessHelper.readOutput(sp, rd, wr)
+        end
+
+        process_result(cmd, consoleOutput, compiler[:ERROR_PARSER], "Compiling #{sourceRel}")
+        
+        convert_depfile(dep_file) if dep_file
+        
+        check_config_file()
+      end
+      enhance_with_additional_files(res)
+      add_output_dir_dependency(object, res, false)
+      apply_depfile(dep_file, res) if depStr != ""
+      res
+    end
+
+    def enhance_with_additional_files(task)
+      task.enhance(file_dependencies)
+      task.enhance(@config_files)
+    end
+
+    def process_console_output(console_output, error_parser)
+      ret = false
+      if not console_output.empty?
+        if error_parser
+          begin
+            error_descs, console_output_full = error_parser.scan_lines(console_output, @project_dir)
+            
+            console_output = console_output_full if Rake::application.consoleOutput_fullnames
+          
+            ret = error_descs.any? { |e| e.severity == ErrorParser::SEVERITY_ERROR }
+          
+            console_output.gsub!(/[\r]/, "")
+            highlighter = @tcs[:CONSOLE_HIGHLIGHTER]
+            if (highlighter and highlighter.enabled?)
+              puts highlighter.format(console_output, error_descs, error_parser)
+            else
+              puts console_output
+            end
+
+            Rake.application.idei.set_errors(error_descs)
+          rescue Exception => e
+            Printer.printWarning "Parsing output failed (maybe language not set to English?): " + e.message 
+            puts "Original output:"
+            puts console_output
+          end
+        end
+      end
+      ret
+    end
+
+    def prepare_tasks_for_objects
+      if (@output_dir_abs)
+        CLEAN.include(@output_dir + "/objects/" + @name)
+      end    
+    
+      @objects = []
+      t = multitask get_sources_task_name
+      t.type = Rake::Task::SOURCEMULTI
+      t.transparent_timestamp = true
+      t.set_building_block(self)
+      t
+    end
+
+  end
 end

data/lib/cxxproject/buildingblocks/makefile.rb

@@ -1,35 +1,153 @@
 require 'cxxproject/buildingblocks/building_block'
 require 'cxxproject/buildingblocks/has_libraries_mixin'
+require 'cxxproject/utils/printer'
+require 'cxxproject/utils/process'
 
-class Makefile < BuildingBlock
-  include HasLibraries
+module Cxxproject
+  class Makefile < BuildingBlock
+    include HasLibraries
 
-  def set_target(x)
-    @target = x
-    self
-  end
+    def set_target(x)
+      @target = x
+      self
+    end
+    
+    def set_flags(x)
+      @flags = x
+      self
+    end  
+      
+    def get_flags(x)
+      @flags
+    end    
+      
 
-  def set_makefile(x)
-    @makefile = x
-    self
-  end
+    def set_makefile(x)
+      @makefile = x
+      self
+    end
 
-  def get_makefile
-    File.relFromTo(@makefile, @project_dir)
-  end
+    def set_path_to(hash)
+      @path_to = hash
+      self
+    end
 
-  def get_target
-    @target
-  end
+    def get_makefile
+      @makefile
+    end
 
-  def initialize(name)
-    super(name)
-    @target = "all"
-    @makefile = nil
-  end
+    def get_target
+      @target
+    end
+    
+    def initialize(mfile, mtarget)
+      @target = mtarget != "" ? mtarget : "all"
+      @makefile = mfile
+      @flags = ""
+      @path_to = {}
+      @num = Rake.application.makefile_number  
+      super(get_task_name)
+    end
 
-  def get_task_name()
-    get_makefile+"_"+get_target
-  end
+    def get_task_name()
+      "makefile (#{@num}): " + get_makefile + (get_target ? ("_"+get_target) : "")    
+    end
 
+    def calc_pathes_to_projects
+      vars = []
+      @path_to.each do |k,v|
+        bb = ALL_BUILDING_BLOCKS[p]
+        if bb
+          pref = File.rel_from_to_project(@project_dir,bb.project_dir)
+          rex = Regexp.new "\\.\\.\\/(.*)#{p}"
+          var = pref.scan(rex)[0]
+          if var
+            vars << "PATH_TO_#{p}=#{var[0]}"
+          end
+        else
+          vars << "PATH_TO_#{k}=#{v}"
+        end
+      end
+      vars.join(" ")
+    end
+
+    def executeCmd(cmd)
+        Dir.chdir(@project_dir) do      
+          check_config_file      
+          puts cmd + (RakeFileUtils.verbose ? " (executed in '#{@project_dir}')" : "")
+          cmd_result = false
+          begin
+            cmd_result = ProcessHelper.spawnProcess(cmd + " 2>&1")
+          rescue
+          end
+          if (cmd_result == false)
+            if Rake.application.idei
+              err_res = ErrorDesc.new
+              err_res.file_name = @project_dir + "/" + get_makefile()
+              err_res.line_number = 1
+              err_res.severity = ErrorParser::SEVERITY_ERROR
+              if get_target != ""
+                err_res.message = "Target \"#{get_target}\" failed"
+              else
+                err_res.message = "Failed"
+              end
+              Rake.application.idei.set_errors([err_res])
+            end
+            Printer.printError "Error: command \"#{cmd}\" failed" + (RakeFileUtils.verbose ? "" : " (executed in '#{@project_dir}')")
+            raise SystemCommandFailed.new
+          end          
+        end      
+    end
+
+    def convert_to_rake()
+      pathes_to_projects = calc_pathes_to_projects
+    
+      mfile = get_makefile()
+      make = @tcs[:MAKE]
+      cmd = remove_empty_strings_and_join([
+        make[:COMMAND], # make
+        get_target, # all
+        make[:MAKE_FLAGS],
+        @flags, # -j
+        make[:DIR_FLAG], # -C
+        File.dirname(mfile), # x/y
+        make[:FILE_FLAG], # -f
+        File.basename(mfile), # x/y/makefile
+        pathes_to_projects
+      ])
+      
+      mfileTask = task get_task_name do
+        executeCmd(cmd)
+      end
+      
+      mfileTask.immediate_output = true
+      mfileTask.transparent_timestamp = true
+      mfileTask.type = Rake::Task::MAKE
+      mfileTask.enhance(@config_files)
+
+      create_clean_task(@project_dir+"/"+mfile, pathes_to_projects)
+      setup_rake_dependencies(mfileTask)
+      mfileTask
+    end
+
+    def create_clean_task(mfile, pathes_to_projects)
+      # generate the clean task
+      if not Rake.application["clean"].prerequisites.include?(mfile+"Clean")
+        cmd = remove_empty_strings_and_join([@tcs[:MAKE][:COMMAND], # make
+          @tcs[:MAKE][:CLEAN], # clean
+          @tcs[:MAKE][:DIR_FLAG], # -C
+          File.dirname(mfile), # x/y
+          @tcs[:MAKE][:FILE_FLAG], # -f
+          File.basename(mfile), # x/y/makefile
+          pathes_to_projects
+        ])
+        mfileCleanTask = task mfile+"Clean" do
+          executeCmd(cmd)
+        end
+        mfileCleanTask.immediate_output = true
+        Rake.application["clean"].enhance([mfileCleanTask])
+      end
+    end
+
+  end
 end

data/lib/cxxproject/buildingblocks/module.rb

@@ -1,14 +1,35 @@
 require 'cxxproject/buildingblocks/building_block'
 require 'cxxproject/buildingblocks/has_libraries_mixin'
 require 'cxxproject/buildingblocks/has_sources_mixin'
+require 'cxxproject/buildingblocks/has_includes_mixin'
+
 
 # can be used as wrapper for other tasks
-class ModuleBuildingBlock < BuildingBlock
-  include HasLibraries
-  include HasSources
+module Cxxproject
+  class ModuleBuildingBlock < BuildingBlock
 
-  def get_task_name()
-    name
-  end
+    attr_accessor :contents
+    attr_accessor :main_content
+    attr_accessor :last_content
+
+    def initialize(name)
+      super
+      @contents = []
+      @last_content = self
+      @main_content = nil
+    end
 
+    def get_task_name()
+      name
+    end
+
+    def convert_to_rake()
+      res = task get_task_name
+      res.type = Rake::Task::MODULE
+      res.transparent_timestamp = true
+
+      setup_rake_dependencies(res)
+      res
+    end
+  end
 end

data/lib/cxxproject/buildingblocks/single_source.rb

@@ -1,11 +1,33 @@
 require 'cxxproject/buildingblocks/building_block'
 require 'cxxproject/buildingblocks/has_sources_mixin'
+require 'cxxproject/buildingblocks/has_includes_mixin'
 
-class SingleSource < BuildingBlock
-  include HasSources
+module Cxxproject
+  module SingleSourceModule
+    def get_task_name()
+      get_sources_task_name
+    end
 
-  def get_task_name()
-    get_sources_task_name
+    def convert_to_rake()
+      objects_multitask = prepare_tasks_for_objects()
+
+      if objects_multitask
+        namespace "compile" do
+          desc "compile sources in #{@name}-configuration"
+          task @name => objects_multitask
+        end
+        objects_multitask.add_description("compile sources only")
+      end
+
+      setup_rake_dependencies(objects_multitask)
+      objects_multitask
+    end
   end
 
+  class SingleSource < BuildingBlock
+    include HasSources
+    include HasIncludes
+
+    include SingleSourceModule
+  end
 end