bake-toolkit 1.8.0.1 → 2.0.10

data/lib/blocks/has_execute_command.rb

@@ -0,0 +1,31 @@
+module Bake
+  
+  module Blocks
+  
+    module HasExecuteCommand
+      
+      def executeCommand(commandLine, ignoreStr=nil)
+        puts commandLine if not Bake.options.verboseLow
+        puts "(executed in '#{@projectDir}')" if Bake.options.verboseHigh
+        cmd_result = false
+        output = ""
+        begin
+          Dir.chdir(@projectDir) do
+            cmd_result, output = ProcessHelper.run([commandLine], true)
+          end
+        rescue Exception=>e
+          puts e.message
+          puts e.backtrace if Bake.options.debug
+        end
+          
+        if (cmd_result == false and (not ignoreStr or not output.include?ignoreStr))
+          Bake.formatter.printError("Command \"#{commandLine}\" failed", @config)
+          puts "(executed in '#{@projectDir}')" if not Bake.options.verboseHigh
+          raise SystemCommandFailed.new
+        end
+      end
+          
+    end
+    
+  end
+end

data/lib/blocks/library.rb

@@ -0,0 +1,78 @@
+require 'blocks/blockBase'
+
+module Bake
+  
+  module Blocks
+    
+    class Library < BlockBase
+      
+      def initialize(block, config, referencedConfigs, tcs, compileBlock)
+        super(block,config, referencedConfigs, tcs)
+        @compileBlock = compileBlock
+        
+        block.set_library(self)
+      end
+      
+      def archive_name()
+        @archive_name ||= File.join([@output_dir, "lib#{@projectName}.a"])
+      end
+  
+      def needed?
+        return false if Bake.options.linkOnly
+        return false if Bake.options.prepro
+        
+        # lib
+        return "because library does not exist" if not File.exists?(archive_name)
+
+        aTime = File.mtime(archive_name)
+        
+        # config
+        return "because config file has been changed" if aTime < File.mtime(@config.file_name)
+        return "because DefaultToolchain has been changed" if aTime < Bake::Config.defaultToolchainTime
+                
+        # sources
+        @compileBlock.objects.each do |obj|
+          return "because object #{obj} does not exist" if not File.exists?(obj)
+          return "because object #{obj} is newer than executable" if aTime < File.mtime(obj)
+        end
+        
+        false
+      end
+      
+      def execute
+
+        Dir.chdir(@projectDir) do
+          reason = needed?
+          return unless reason
+          
+          prepareOutput(archive_name)
+        
+          archiver = @tcs[:ARCHIVER]
+       
+          cmd = Utils.flagSplit(archiver[:COMMAND], false) # ar
+          cmd += Bake::Utils::flagSplit(archiver[:FLAGS],true) # --all_load
+          cmd += archiver[:ARCHIVE_FLAGS].split(" ")
+          cmd << archive_name
+          cmd += @compileBlock.objects
+          
+          success, consoleOutput = ProcessHelper.run(cmd, false, false)
+          process_result(cmd, consoleOutput, archiver[:ERROR_PARSER], "Creating #{archive_name}", reason, success)
+         
+          check_config_file()
+        end
+      end
+      
+      def clean
+        Dir.chdir(@projectDir) do 
+          if File.exist?@output_dir 
+            puts "Deleting folder #{@output_dir}" if Bake.options.verboseHigh
+            FileUtils.rm_rf(@output_dir)
+          end
+        end unless Bake.options.filename
+      end
+   
+      
+    end
+    
+  end
+end

data/lib/blocks/lint.rb

@@ -0,0 +1,53 @@
+require 'blocks/compile'
+
+module Bake
+  module Blocks
+    class Lint < Compile
+  
+      def initialize(block, config, referencedConfigs, tcs)
+        super(block,config, referencedConfigs, tcs)
+      end
+  
+      def execute
+        Dir.chdir(@projectDir) do
+          compiler = @tcs[:COMPILER][:CPP]
+          calcSources
+          
+          noFilesToLint = (@source_files.length == 0)
+          
+          if Bake.options.lint_min >= 1 and Bake.options.lint_min >= @source_files.length
+            noFilesToLint = true 
+          end
+          
+          if Bake.options.lint_max >= 0 and Bake.options.lint_max < Bake.options.lint_min
+            noFilesToLint = true 
+          end
+                    
+          if noFilesToLint
+            Bake.formatter.printInfo("No files to lint", @config)
+          else
+            @source_files = @source_files[Bake.options.lint_min..Bake.options.lint_max]    
+            
+            cmd = [compiler[:COMMAND]]
+            cmd += compiler[:COMPILE_FLAGS]
+              
+            cmd += @include_array[:CPP]
+            cmd += @define_array[:CPP]
+              
+            cmd += @tcs[:LINT_POLICY]
+            
+            cmd += @source_files
+                   
+            printCmd(cmd, "Linting #{@source_files.length} file(s)...", nil, false)
+            success, consoleOutput = ProcessHelper.run(cmd, false)
+            process_result(cmd, consoleOutput, compiler[:ERROR_PARSER], "Linting...", nil, success)
+          end
+        end
+      end  
+      
+      def clean
+      end
+      
+    end
+  end
+end

data/lib/blocks/makefile.rb

@@ -0,0 +1,87 @@
+require 'blocks/has_execute_command'
+
+module Bake
+  module Blocks
+    
+    class Makefile
+      include HasExecuteCommand
+
+      MAKE_COMMAND = "make"
+      MAKE_FILE_FLAG = "-f"
+      MAKE_DIR_FLAG = "-C"
+      MAKE_CLEAN = "clean"
+      
+      def initialize(config, referencedConfigs, block)
+        @config = config
+        @projectDir = config.get_project_dir
+        @path_to = ""
+        @flags = adjustFlags("",config.flags) if config.flags
+        @makefile = config.name
+        @target = config.target != "" ? config.target : "all"
+        calcPathTo(referencedConfigs)
+        calcCommandLine
+        calcCleanLine
+
+        block.lib_elements[config.line_number] = [LibElement.new(LibElement::LIB_WITH_PATH, config.lib)] if config.lib != ""
+      end
+      
+      def calcCommandLine
+        @commandLine = remove_empty_strings_and_join([
+          MAKE_COMMAND, @target,
+          @flags,
+          MAKE_DIR_FLAG,  File.dirname(@makefile),
+          MAKE_FILE_FLAG, File.basename(@makefile),
+          @path_to])        
+      end
+      
+      def calcCleanLine
+        @cleanLine = remove_empty_strings_and_join([
+          MAKE_COMMAND, MAKE_CLEAN, 
+          MAKE_DIR_FLAG,  File.dirname(@makefile),
+          MAKE_FILE_FLAG, File.basename(@makefile),
+          @path_to]) 
+      end      
+      
+      def calcPathTo(referencedConfigs)
+        @path_to = ""
+        if @config.pathTo != ""
+          pathHash = {}
+          @config.pathTo.split(",").each do |p|
+            nameOfP = p.strip
+            dirOfP = nil
+            if referencedConfigs.include?nameOfP
+              dirOfP = referencedConfigs[nameOfP].first.get_project_dir
+            else
+              Bake.options.roots.each do |r|
+                absIncDir = r+"/"+nameOfP
+                if File.exists?(absIncDir)
+                  dirOfP = absIncDir
+                  break
+                end
+              end
+            end
+            if dirOfP == nil
+              Bake.formatter.printError("Project '#{nameOfP}' not found", @config)
+              ExitHelper.exit(1)
+            end
+            pathHash[nameOfP] = File.rel_from_to_project(File.dirname(@projectDir),File.dirname(dirOfP))
+          end
+          path_to_array = []
+          pathHash.each { |k,v| path_to_array << "PATH_TO_#{k}=#{v}" }
+          @path_to = path_to_array.join(" ")
+        end
+        
+      end
+      
+      def execute
+        executeCommand(@commandLine)
+       end
+      
+      def clean
+        executeCommand(@cleanLine, "No rule to make target 'clean'.") unless Bake.options.filename
+      end
+    
+    end
+    
+  end
+end

data/lib/blocks/showIncludes.rb

@@ -0,0 +1,114 @@
+module Bake
+  module Blocks
+    class Show
+      
+      def self.secureShow
+        begin
+          yield
+        rescue Exception => e
+          if (not SystemExit === e)
+            puts e
+            puts e.backtrace
+            ExitHelper.exit(1)
+          else
+            raise e
+          end
+        end
+      end  
+      
+      def self.includes
+        secureShow {
+        Blocks::ALL_COMPILE_BLOCKS.sort.each do |projName, blocks|
+          print projName
+          incs = []
+          blocks.each { |block| incs += block.include_list }
+          incs.uniq.each { |inc| print "##{inc}" }
+          print "\n"
+        end
+        ExitHelper.exit(0) }
+      end
+      
+      def self.readInternalIncludes(mainConfig, mainBlock, mainTcs)
+        intIncs = []
+        iinc = mainConfig.defaultToolchain.internalIncludes
+        Dir.chdir(Bake.options.main_dir) do
+          if (iinc)
+            
+            cppExe      = File.which(mainTcs[:COMPILER][:CPP][:COMMAND]) 
+            cExe        = File.which(mainTcs[:COMPILER][:C][:COMMAND])
+            asmExe      = File.which(mainTcs[:COMPILER][:ASM][:COMMAND])
+            archiverExe = File.which(mainTcs[:ARCHIVER][:COMMAND])
+            linkerExe   = File.which(mainTcs[:LINKER][:COMMAND])
+            
+            iname = mainBlock.convPath(iinc)
+            if iname != ""
+              if not File.exists?(iname)
+                Bake.formatter.printError("InternalIncludes file #{iname} does not exist", iinc)
+                ExitHelper.exit(1)
+              end
+              IO.foreach(iname) do |x|
+                x.sub!("$(CPPPath)",      cppExe)
+                x.sub!("$(CPath)",        cExe)
+                x.sub!("$(ASMPath)",      asmExe)
+                x.sub!("$(ArchiverPath)", archiverExe)
+                x.sub!("$(LinkerPath)",   linkerExe)
+                add_line_if_no_comment(intIncs,x)
+              end
+            end
+          end
+        end
+        return intIncs
+      end
+      
+      def self.readInternalDefines(mainConfig, mainBlock)
+        intDefs = {:CPP => [], :C => [], :ASM => []}
+        Dir.chdir(Bake.options.main_dir) do
+          mainConfig.defaultToolchain.compiler.each do |c|
+            if (c.internalDefines)
+              dname = mainBlock.convPath(c.internalDefines)
+              if dname != ""
+                if not File.exists?(dname)
+                  Bake.formatter.printError("InternalDefines file #{dname} does not exist", c.internalDefines)
+                  ExitHelper.exit(1)
+                end
+                IO.foreach(dname) {|x| add_line_if_no_comment(intDefs[c.ctype],x)  }
+              end
+            end
+          end
+        end
+        return intDefs
+      end
+      
+      def self.includesAndDefines(mainConfig, mainTcs)
+        secureShow {
+        mainBlock = Blocks::ALL_BLOCKS[Bake.options.main_project_name+","+Bake.options.build_config]
+
+        intIncs = readInternalIncludes(mainConfig, mainBlock, mainTcs)
+        intDefs = readInternalDefines(mainConfig, mainBlock)
+
+      
+        Blocks::ALL_COMPILE_BLOCKS.sort.each do |projName, blocks|
+
+          blockIncs = []
+          blockDefs = {:CPP => [], :C => [], :ASM => []}
+          blocks.each do |block|
+            blockIncs += block.include_list 
+            [:CPP, :C, :ASM].each { |type| blockDefs[type] += block.tcs[:COMPILER][type][:DEFINES] }
+          end
+          
+          puts projName
+          puts " includes"
+          (blockIncs + intIncs).uniq.each { |i| puts "  #{i}" }
+          [:CPP, :C, :ASM].each do |type|
+            puts " #{type} defines"
+            (blockDefs[type] + intDefs[type]).uniq.each { |d| puts "  #{d}" }
+          end
+          puts " done"
+          
+        end
+        ExitHelper.exit(0) }
+      end
+
+    end
+  end
+end

data/lib/common/abortException.rb

@@ -0,0 +1,4 @@
+module Bake
+  class AbortException < StandardError
+  end
+end

data/lib/common/cleanup.rb

@@ -0,0 +1,9 @@
+module Bake
+
+    def self.cleanup()
+      Blocks::ALL_BLOCKS.clear
+      Blocks::ALL_COMPILE_BLOCKS.clear
+      Bake::IDEInterface.instance.set_abort(false)
+    end
+
+end

data/lib/common/exit_helper.rb

@@ -0,0 +1,28 @@
+module Bake
+
+  class ExitHelper
+    @@exit_code = 0
+
+    def self.set_exit_code(val)
+      @@exit_code = val
+    end
+    
+    def self.exit_code()
+      @@exit_code
+    end
+
+    def self.reset_exit_code()
+      @@exit_code = 0
+    end    
+
+    def self.exit(val)
+      @@exit_code = val
+      Kernel::exit
+    end
+
+  end
+end
+
+at_exit do
+  exit(Bake::ExitHelper.exit_code)
+end

data/lib/common/ext/file.rb

@@ -0,0 +1,88 @@
+require 'common/utils'
+
+class File
+
+  SLASH = '/'
+
+  def self.is_absolute?(filename)
+    filename[0] == SLASH or filename[1] == ':'
+  end
+
+  # seems both are rel or both are abs in all cases
+  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
+    toIsWindowsAbs = false
+    if toSplitted[0].length > 1 and fromSplitted[0].length > 1
+      toIsWindowsAbs = toSplitted[0][1] == ':'
+      i = 1  if toIsWindowsAbs and fromSplitted[0][1] == ':' and toSplitted[0][0].downcase == fromSplitted[0][0].downcase
+    end
+    
+    if (toIsWindowsAbs and i==0)
+      res = to
+      res += "/" if endWithSlash 
+      return res	  
+    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
+
+  def self.which(cmd)
+    return "" if not cmd
+    exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+    ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+      exts.each { |ext|
+        exe = File.join(path, "#{cmd}#{ext}")
+        if File.executable?(exe) && !File.directory?(exe)
+          return File.dirname(exe.gsub(/[\\]/,'/'))
+        end 
+      }
+    end
+    return ""
+  end
+  
+end