cxxproject 0.4.6 → 0.5.47

data/lib/cxxproject/buildingblocks/source_library.rb

@@ -1,31 +1,124 @@
 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 SourceLibrary < BuildingBlock
-  include HasLibraries
-  include HasSources
+module Cxxproject
+  class SourceLibrary < BuildingBlock
+    include HasLibraries
+    include HasSources
+    include HasIncludes
 
-  def initialize(name)
-    super(name)
-    @search_for_lib = false # false: use libs_with_path ("Eclipse mode"), true: use libs_to_search and lib_searchpaths ("Linux mode")
-  end
+    def initialize(name)
+      super(name)
+    end
 
-  def complete_init()
-    if @output_dir_abs
-      libs_to_search << @name
-      lib_searchpaths << @output_dir
-    else
-      libs_with_path << File.join(@output_dir,"lib#{@name}.a")
+    def complete_init()
+      if @output_dir_abs
+        add_lib_element(HasLibraries::SEARCH_PATH, File.join(@output_dir, 'libs'), true)
+        add_lib_element(HasLibraries::LIB, @name, true)
+      else
+        add_lib_element(HasLibraries::LIB_WITH_PATH, File.join(@output_dir,"lib#{@name}.a"), true) 
+      end
+      super
     end
-  end
 
-  def get_archive_name()
-    File.relFromTo(@complete_output_dir + "/lib" + @name + ".a", @project_dir)
-  end
+    def get_archive_name() # relative path
+      return @archive_name if @archive_name
+      parts = [@output_dir]
 
-  def get_task_name()
-    get_archive_name
-  end
+      if @output_dir_abs
+        parts = [@output_dir_relPath] if @output_dir_relPath
+        parts << 'libs'
+      end
+
+      parts << "lib#{@name}.a"
+
+      @archive_name = File.join(parts)
+      @archive_name
+    end
+
+    def get_task_name() # full path
+      return @task_name if @task_name
+
+      parts = [@output_dir]
+      parts << 'libs' if @output_dir_abs
+      parts << "lib#{@name}.a"
+      @task_name = File.join(parts)
+      @task_name = @project_dir + "/" + @task_name unless @output_dir_abs
+      @task_name
+    end
+
+    # task that will link the given object files to a static lib
+    #
+    def convert_to_rake()
+      object_multitask = prepare_tasks_for_objects()
+      archiver = @tcs[:ARCHIVER]
+
+      res = typed_file_task Rake::Task::LIBRARY, get_task_name => object_multitask do
+        dir = @project_dir
+        objs = @objects
+        aname = get_archive_name
+        
+        if @output_dir_abs
+          dir = @output_dir
+          prefix = File.rel_from_to_project(@project_dir, @output_dir)
+          objs.map! { |m| m[prefix.length..-1] }
+          aname = aname[prefix.length..-1]
+        end
+        
+        Dir.chdir(dir) do
+          FileUtils.rm(aname) if File.exists?(aname)
+          cmd = [archiver[:COMMAND]] # ar
+          cmd += archiver[:ARCHIVE_FLAGS].split(" ")
+          cmd += archiver[:FLAGS].split(" ") # --all_load
+          cmd << aname # -o debug/x.exe
+          cmd += objs
+
+          if Cxxproject::Utils.old_ruby?
+            cmd.map! {|c| ((c.include?" ") ? ("\""+c+"\"") : c )}
+          
+            cmdLine = cmd.join(" ")
+            if cmdLine.length > 8000
+              inputName = aname+".tmp"
+              File.open(inputName,"wb") { |f| f.write(cmd[1..-1].join(" ")) }
+              consoleOutput = `#{archiver[: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, archiver[:ERROR_PARSER], "Creating #{aname}")
+        
+          check_config_file()  
+        end
+      end
+      enhance_with_additional_files(res)
+      add_output_dir_dependency(get_task_name, res, true)
 
+      add_grouping_tasks(get_task_name)
+
+      setup_rake_dependencies(res, object_multitask)
+      return res
+    end
+
+    def add_grouping_tasks(archive)
+      namespace 'lib' do
+        desc archive
+        task @name => archive
+      end
+    end
+  end
 end

data/lib/cxxproject/errorparser/diab_compiler_error_parser.rb

@@ -0,0 +1,40 @@
+require 'cxxproject/errorparser/error_parser'
+
+module Cxxproject
+  class DiabCompilerErrorParser < ErrorParser
+
+    def initialize()
+      @error_expression_start = /\"(.+)\", line ([0-9]+): (catastrophic |fatal )*([A-Za-z]+) (.+)/  
+      @error_expression_end = /^[ \t]*\^/ # well, it may end without "^"... in this case the error will last the next one starts or console text ends
+    end
+
+    def scan_lines(consoleOutput, proj_dir)
+      res = []
+      error_severity = 255
+      consoleOutputFullnames = ""
+      consoleOutput.each_line do |l|
+        d = ErrorDesc.new
+        lstripped = l.rstrip
+        scan_res = lstripped.scan(@error_expression_start)
+        if scan_res.length == 0
+          d.severity = error_severity
+          d.message = lstripped 
+          if lstripped.scan(@error_expression_end).length > 0
+            error_severity = 255 
+          end
+        else
+          d.file_name = File.expand_path(scan_res[0][0])
+          d.line_number = scan_res[0][1].to_i
+          d.message = scan_res[0][4]
+          d.severity = get_severity(scan_res[0][3])
+          error_severity = d.severity
+          l.gsub!(scan_res[0][0],d.file_name)
+        end
+        res << d
+        consoleOutputFullnames << l
+      end
+      [res, consoleOutputFullnames]
+    end
+
+  end
+end

data/lib/cxxproject/errorparser/diab_linker_error_parser.rb

@@ -0,0 +1,33 @@
+require 'cxxproject/errorparser/error_parser'
+
+module Cxxproject
+  class DiabLinkerErrorParser < ErrorParser
+
+    def initialize()
+      @error_expression = /dld: ([A-Za-z]+): (.+)/
+    end
+
+    def scan_lines(consoleOutput, proj_dir)
+      res = []
+      error_severity = 255
+      consoleOutput.each_line do |l|
+        l.rstrip!
+        d = ErrorDesc.new
+        scan_res = l.scan(@error_expression)
+        if scan_res.length == 0 # msg will end with the beginning of the next message
+          d.severity = error_severity
+          d.message = l
+        else
+          d.file_name = proj_dir
+          d.line_number = 0
+          d.message = scan_res[0][1]
+          d.severity = get_severity(scan_res[0][0])
+          error_severity = d.severity
+        end
+        res << d
+      end
+      [res, consoleOutput]
+    end
+
+  end
+end

data/lib/cxxproject/errorparser/error_parser.rb

@@ -0,0 +1,50 @@
+module Cxxproject
+
+  class ErrorDesc
+    def initialize
+      @severity = 255
+    end
+    attr_accessor :severity
+    attr_accessor :line_number
+    attr_accessor :message
+    attr_accessor :file_name
+  end
+
+  class ErrorParser
+
+    SEVERITY_INFO = 0
+    SEVERITY_WARNING = 1
+    SEVERITY_ERROR = 2
+    SEVERITY_OK = 255
+
+    def scan(consoleOutput, proj_dir)
+      raise "Use specialized classes only"
+    end
+
+    def get_severity(str)
+      if str == "info" || str == "note"
+        SEVERITY_INFO
+      elsif str == "warning"
+        SEVERITY_WARNING
+      elsif str == "error"
+        SEVERITY_ERROR
+      else
+        raise "Unknown severity: #{str}"
+      end
+    end
+
+    # scan the output from the console line by line and return a list of ErrorDesc objects.
+    # for none-error/warning lines the description object will indicate that as severity 255
+    # for single line errors/warnings: description will contain severity, line-number, message and file-name
+    #
+    # for multi-line errors/warnings:
+    #   one description object for each line, first one will contain all single line error information,
+    #   all following desc.objects will just repeat the severity and include the message
+    #
+    def scan_lines(consoleOutput, proj_dir)
+      raise "Use specialized classes only"
+    end
+
+
+  end
+end

data/lib/cxxproject/errorparser/gcc_compiler_error_parser.rb

@@ -0,0 +1,30 @@
+require 'cxxproject/errorparser/error_parser'
+
+module Cxxproject
+  class GCCCompilerErrorParser < ErrorParser
+
+    def initialize()
+      @error_expression = /([^:]+):([0-9]+)[:0-9]* (catastrophic |fatal )*([A-Za-z]+): (.+)/
+    end
+
+    def scan_lines(consoleOutput, proj_dir)
+      res = []
+      consoleOutputFullnames = ""
+      consoleOutput.each_line do |l|
+        d = ErrorDesc.new
+        scan_res = l.gsub(/\r\n?/, "").scan(@error_expression)
+        if scan_res.length > 0
+          d.file_name = File.expand_path(scan_res[0][0])
+          d.line_number = scan_res[0][1].to_i
+          d.message = scan_res[0][4]
+          d.severity = get_severity(scan_res[0][3])
+          l.gsub!(scan_res[0][0],d.file_name)
+        end
+        res << d
+        consoleOutputFullnames << l
+      end
+      [res, consoleOutputFullnames]
+    end
+
+  end
+end

data/lib/cxxproject/errorparser/gcc_linker_error_parser.rb

@@ -0,0 +1,29 @@
+require 'cxxproject/errorparser/error_parser'
+
+module Cxxproject
+  class GCCLinkerErrorParser < ErrorParser
+
+    def initialize()
+      # todo: is every line an error?
+      # todo: some linker errors look like simple text, dunno how to parse properly...
+      # @error_expression1 = /(.*:\(\..*\)): (.*)/  # e.g. /c/Tool/Temp/ccAlar4R.o:x.cpp:(.text+0x17): undefined reference to `_a'
+      # @error_expression2 = /(.*):([0-9]+): (.*)/  # e.g. /usr/lib/gcc/i686-pc-cygwin/4.3.4/../../../../i686-pc-cygwin/bin/ld:roodi.yml.a:1: syntax error
+    end
+
+    def scan_lines(consoleOutput, proj_dir)
+      res = []
+      consoleOutput.each_line do |l|
+        l.rstrip!
+        d = ErrorDesc.new
+        d.file_name = proj_dir
+        d.line_number = 0
+        d.message = l
+        d.severity = SEVERITY_ERROR
+        res << d
+      end
+      [res, consoleOutput]
+    end
+
+
+  end
+end

data/lib/cxxproject/errorparser/ti_compiler_error_parser.rb

@@ -0,0 +1,30 @@
+require 'cxxproject/errorparser/error_parser'
+
+module Cxxproject
+  class TICompilerErrorParser < ErrorParser
+
+    def initialize()
+      @error_expression = /\"([^,^\"]+)\", line ([0-9]+)[:0-9]* (catastrophic |fatal )*([A-Za-z]+): (.+)/
+    end
+
+    def scan_lines(consoleOutput, proj_dir)
+      res = []
+      consoleOutputFullnames = ""
+      consoleOutput.each_line do |l|
+        d = ErrorDesc.new
+        scan_res = l.gsub(/\r\n?/, "").scan(@error_expression)
+        if scan_res.length > 0
+          d.file_name = File.expand_path(scan_res[0][0])
+          d.line_number = scan_res[0][1].to_i
+          d.message = scan_res[0][4]
+          d.severity = get_severity(scan_res[0][3])
+          l.gsub!(scan_res[0][0],d.file_name)
+        end
+        res << d
+        consoleOutputFullnames << l
+      end
+      [res, consoleOutputFullnames]
+    end
+
+  end
+end

data/lib/cxxproject/errorparser/ti_linker_error_parser.rb

@@ -0,0 +1,29 @@
+require 'cxxproject/errorparser/error_parser'
+
+module Cxxproject
+  class TILinkerErrorParser < ErrorParser
+
+    def initialize()
+      # todo: is every line an error?
+      # todo: some linker errors look like simple text, dunno how to parse properly...
+      # @error_expression1 = /(.*:\(\..*\)): (.*)/  # e.g. /c/Tool/Temp/ccAlar4R.o:x.cpp:(.text+0x17): undefined reference to `_a'
+      # @error_expression2 = /(.*):([0-9]+): (.*)/  # e.g. /usr/lib/gcc/i686-pc-cygwin/4.3.4/../../../../i686-pc-cygwin/bin/ld:roodi.yml.a:1: syntax error
+    end
+
+    def scan_lines(consoleOutput, proj_dir)
+      res = []
+      consoleOutput.each_line do |l|
+        l.rstrip!
+        d = ErrorDesc.new
+        d.file_name = proj_dir
+        d.line_number = 0
+        d.message = l
+        d.severity = SEVERITY_ERROR
+        res << d
+      end
+      [res, consoleOutput]
+    end
+
+
+  end
+end

data/lib/cxxproject/eval_context.rb

@@ -0,0 +1,136 @@
+
+module Cxxproject
+  class BinaryLibs
+    class << self
+      def [](*libs)
+        libraries = Array.new
+        libs.each do |x|
+          libraries << BinaryLibrary.new(x)
+        end
+        libraries
+      end
+    end
+  end
+
+  class EvalContext
+
+    attr_accessor :myblock, :all_blocks
+
+    # must be called to add building blocks
+    def cxx_configuration(&block)
+      @myblock = block
+      @all_blocks = []
+    end
+
+    def eval_project(project_text, project_file, pwd)
+      @current_project_file = project_file
+      @current_working_dir = pwd
+      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 do |k|
+        error_string = ["error while evaluating \"#{@current_working_dir}/#{@current_project_file}\"",
+                        "\"#{k}\" is not a valid specifier!"].join($/)
+        raise error_string unless allowed.include?(k)
+      end
+    end
+
+    # specify an executable
+    # hash supports:
+    # * :sources
+    # * :includes
+    # * :dependencies
+    # * :libpath
+    # * :output_dir
+    def exe(name, hash)
+      raise "not a hash" unless hash.is_a?(Hash)
+      check_hash hash,[:sources,:includes,:dependencies,:libpath,:output_dir]
+      bblock = Executable.new(name)
+      bblock.set_sources(hash[:sources]) if hash.has_key?(:sources)
+      bblock.set_includes(hash[:includes]) if hash.has_key?(:includes)
+      calc_lib_searchpath(hash).each { |sp| bblock.add_lib_element(HasLibraries::SEARCH_PATH, sp) }
+      if hash.has_key?(:dependencies)
+        bblock.set_dependencies(hash[:dependencies])
+        hash[:dependencies].each { |d| bblock.add_lib_element(HasLibraries::DEPENDENCY, d) }
+      end
+      bblock.set_output_dir(hash[:output_dir]) if hash.has_key?(:output_dir)
+      all_blocks << bblock
+    end
+
+    def calc_lib_searchpath(hash)
+      if hash.has_key?(:libpath)
+        hash[:libpath]
+      else
+        if Utils::OS.linux? || Utils::OS.mac?
+          ["/usr/local/lib","/usr/lib"]
+        elsif Utils::OS.windows?
+          ["C:/tool/cygwin/lib", "C:/Tool/cygwin/usr/local/lib"]
+        end
+      end
+    end
+
+    # specify a sourcelib
+    # hash supports:
+    # * :sources
+    # * :includes
+    # * :dependencies
+    # * :toolchain
+    # * :file_dependencies
+    # * :output_dir
+    def source_lib(name, hash)
+      raise "not a hash" unless hash.is_a?(Hash)
+      check_hash hash,[:sources, :includes, :dependencies, :toolchain, :file_dependencies, :output_dir]
+      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)
+      if hash.has_key?(:dependencies)
+        bblock.set_dependencies(hash[:dependencies]) 
+        hash[:dependencies].each { |d| bblock.add_lib_element(HasLibraries::DEPENDENCY, d) }
+      end
+      bblock.file_dependencies = hash[:file_dependencies] if hash.has_key?(:file_dependencies)
+      bblock.set_output_dir(hash[:output_dir]) if hash.has_key?(:output_dir)
+      all_blocks << bblock
+    end
+
+    # specify some binary libs
+    # returns all binary libs as array
+    def bin_libs(*names)
+      res = []
+      mapped = names.map{|n|n.to_s}
+      mapped.each do |name|
+        res << BinaryLibrary.new(name)
+      end
+      mapped
+    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
+
+    def custom(name, hash)
+      raise "not a hash" unless hash.is_a?(Hash)
+      check_hash hash,[:execute, :dependencies]
+      bblock = CustomBuildingBlock.new(name)
+      bblock.set_actions(hash[:execute]) if hash.has_key?(:execute)
+      if hash.has_key?(:dependencies)
+        bblock.set_dependencies(hash[:dependencies])
+      end
+      all_blocks << bblock
+    end
+
+  end
+end

data/lib/cxxproject/ext/file.rb

@@ -0,0 +1,71 @@
+require 'cxxproject/utils/utils'
+
+class File
+
+  SLASH = '/'
+
+  def self.is_absolute?(filename)
+    if Cxxproject::Utils.old_ruby?
+      filename[0] == 47 or filename[1] == 58 # 47 = /, 58 = :
+    else
+      filename[0] == SLASH or filename[1] == ':'
+    end
+  end
+
+  def self.rel_from_to_project(from,to,endWithSlash = true)
+    return nil if from.nil? or to.nil?
+    
+	toSplitted = to.split('/')
+	fromSplitted = from.split('/')
+	
+	max = [toSplitted.length, fromSplitted.length].min
+	
+	return nil if max < 1
+	
+	i = 0
+
+	# path letter in windows may be case different
+	if toSplitted[0].length > 1 and fromSplitted[0].length > 1
+      if Cxxproject::Utils.old_ruby?
+        i = 1 if toSplitted[0][1] == 58 and fromSplitted[0][1] == 58 and toSplitted[0].swapcase[0] == fromSplitted[0][0] 
+      else
+        i = 1  if toSplitted[0][1] == ':' and fromSplitted[0][1] == ':' and toSplitted[0].swapcase[0] == fromSplitted[0][0]
+      end	
+	end
+	
+	while i < max
+      break if toSplitted[i] != fromSplitted[i] 
+	  i += 1
+	end
+	j = i
+	
+	res = []
+	while i < fromSplitted.length
+	  res << ".."
+	  i += 1
+	end
+	
+	while j < toSplitted.length
+	  res << toSplitted[j]
+	  j += 1
+	end
+	
+	if res.length == 0
+	  return ""
+	end
+	
+	res = res.join('/')
+	res += "/" if endWithSlash 
+	res
+  end
+
+  
+  def self.add_prefix(prefix, file)
+    if not prefix or is_absolute?(file)
+      file
+    else
+      prefix + file
+    end
+  end
+
+end

data/lib/cxxproject/ext/filelist.rb

@@ -0,0 +1,6 @@
+module Rake
+  class FileList
+    attr_accessor :pending_add
+    attr_accessor :items
+  end
+end

data/lib/cxxproject/ext/progressbar.rb

@@ -0,0 +1,20 @@
+class ::ProgressBar
+  attr_writer :title
+
+  def title_width=(w)
+    @title_width = w
+    @format = "%-#{@title_width}s #{'%3d%%'.red} #{'%s'.green} #{'%s'.blue}"
+  end
+
+  show_original = self.instance_method(:show)
+  define_method(:show) do
+    if @unblocked && !RakeFileUtils.verbose
+      show_original.bind(self).call
+    end
+  end
+
+  def unblock
+    @unblocked = true
+    show
+  end
+end