bake-toolkit 1.8.0.1 → 2.0.10

data/lib/bake/config/loader.rb

@@ -0,0 +1,289 @@
+require 'bake/model/loader'
+
+module Bake
+
+  class Config
+    attr_reader :referencedConfigs
+    attr_reader :defaultToolchain
+    
+    @@defaultToolchainTime = nil
+    
+    def self.defaultToolchainTime
+      @@defaultToolchainTime
+    end
+    
+    def getFullProject(configs, configname) # note: configs is never empty
+      
+      if (configname == "")
+        if configs[0].parent.default != ""
+          configname = configs[0].parent.default
+        else
+          Bake.formatter.printError("No default config specified", configs[0].file_name) 
+          ExitHelper.exit(1)
+        end
+      end
+      
+      config = nil
+      configs.each do |c|
+        if c.name == configname
+          if config
+            Bake.formatter.printError("Config '#{configname}' found more than once",config.file_name)
+            ExitHelper.exit(1)
+          end
+          config = c
+        end
+      end 
+      
+      if not config
+        Bake.formatter.printError("Config '#{configname}' not found", configs[0].file_name)
+        ExitHelper.exit(1)
+      end
+      
+      if config.extends != ""
+        parent,parentConfigName = getFullProject(configs, config.extends)
+        MergeConfig.new(config, parent).merge()
+      end
+      
+      [config, configname]
+    end
+
+    def symlinkCheck(filename)
+      dirOfProjMeta = File.dirname(filename)
+      Dir.chdir(dirOfProjMeta) do
+        if Dir.pwd != dirOfProjMeta and File.dirname(Dir.pwd) != File.dirname(dirOfProjMeta)
+          isSym = false
+          begin
+            isSym = File.symlink?(dirOfProjMeta)
+          rescue
+          end
+          if isSym
+            Bake.formatter.printError("Symlinks only allowed with the same parent dir as the target: #{dirOfProjMeta} --> #{Dir.pwd}", filename)
+            ExitHelper.exit(1)
+          end
+        end
+      end
+    end
+        
+    
+    def loadProjMeta(filename)
+      
+      symlinkCheck(filename)
+      
+      @project_files << filename
+      f = @loader.load(filename)
+
+      config = nil
+      
+      if f.root_elements.length != 1 or not Metamodel::Project === f.root_elements[0]
+        Bake.formatter.printError("Config file must have exactly one 'Project' element as root element", filename)
+        ExitHelper.exit(1)
+      end
+      
+      configs = f.root_elements[0].getConfig
+      
+      if configs.length == 0
+        Bake.formatter.printError("No config found", filename)
+        ExitHelper.exit(1)
+      end
+      
+      configs.each do |config|
+        if config.respond_to?("toolchain") and config.toolchain
+          config.toolchain.compiler.each do |c|
+            if not c.internalDefines.nil? and c.internalDefines != ""
+              Bake.formatter.printError("InternalDefines only allowed in DefaultToolchain", c.internalDefines)
+              ExitHelper.exit(1)
+            end
+          end
+        end
+      end
+      configs
+    end
+    
+    
+    def validateDependencies(config)
+      config.dependency.each do |dep|
+        if dep.name.include?"$" or dep.config.include?"$"
+          Bake.formatter.printError("No variables allowed in Dependency definition", dep)
+          ExitHelper.exit(1)
+        end
+        dep.name = config.parent.name if dep.name == ""
+      end
+    end
+
+    def loadMeta(dep)
+
+      # file not loaded yet
+      if not @loadedConfigs.include?dep.name
+        
+        pmeta_filenames = []
+          
+        @potentialProjs.each do |pp|
+          if pp.include?("/" + dep.name + "/Project.meta") or pp == (dep.name + "/Project.meta") 
+            pmeta_filenames << pp
+          end
+        end
+  
+        if pmeta_filenames.empty?
+          Bake.formatter.printError("#{dep.name}/Project.meta not found", dep)
+          ExitHelper.exit(1)
+        end
+        
+        if pmeta_filenames.length > 1
+          Bake.formatter.printWarning("Project #{dep.name} exists more than once", dep)
+          chosen = " (chosen)"
+          pmeta_filenames.each do |f|
+            Bake.formatter.printWarning("  #{File.dirname(f)}#{chosen}")
+            chosen = ""
+          end
+        end
+        
+        @loadedConfigs[dep.name] = loadProjMeta(pmeta_filenames[0])
+      end
+      
+      # get config
+      config, dep.config = getFullProject(@loadedConfigs[dep.name],dep.config)
+      
+      # config not referenced yet
+      if not @referencedConfigs.include?dep.name
+        @referencedConfigs[dep.name] = [config] 
+      elsif @referencedConfigs[dep.name].index { |c| c.name == dep.config } == nil
+        @referencedConfigs[dep.name] << config
+      else
+        return
+      end
+      
+      validateDependencies(config)
+      @depsPending += config.dependency
+    end
+    
+    def loadMainMeta()
+      mainMeta = Bake.options.main_dir+"/Project.meta"
+      if not File.exist?(mainMeta)
+        Bake.formatter.printError("Error: #{mainMeta} not found")
+        ExitHelper.exit(1)
+      end
+        
+      @project_files = []
+      
+      configs = loadProjMeta(mainMeta)
+      @loadedConfigs = {}
+      @loadedConfigs[Bake.options.main_project_name] = configs
+      
+      if (Bake.options.build_config == "" and configs[0].parent.default == "")
+        ConfigNames.print(configs, nil, mainMeta)
+      end
+      
+      config, Bake.options.build_config = getFullProject(configs,Bake.options.build_config)
+      @referencedConfigs = {}
+      @referencedConfigs[Bake.options.main_project_name] = [config]
+        
+      if config.defaultToolchain == nil
+        Bake.formatter.printError("Main project configuration must contain DefaultToolchain", config)
+        ExitHelper.exit(1)
+      end
+      
+      basedOn = config.defaultToolchain.basedOn
+      @basedOnToolchain = Bake::Toolchain::Provider[basedOn]
+      if @basedOnToolchain.nil?
+        Bake.formatter.printError("DefaultToolchain based on unknown compiler '#{basedOn}'", config.defaultToolchain)
+        ExitHelper.exit(1)
+      end
+      @defaultToolchain = Utils.deep_copy(@basedOnToolchain)
+      integrateToolchain(@defaultToolchain, config.defaultToolchain)
+      @@defaultToolchainTime = File.mtime(mainMeta)
+      
+      validateDependencies(config)
+      @depsPending = config.dependency
+    end
+    
+    def checkRoots()
+      @potentialProjs = []
+      Bake.options.roots.each do |r|
+        if (r.length == 3 && r.include?(":/"))
+          r = r + Bake.options.main_project_name # glob would not work otherwise on windows (ruby bug?)
+        end
+        r = r+"/**{,/*/**}/Project.meta"
+        @potentialProjs.concat(Dir.glob(r))
+      end
+      
+      @potentialProjs = @potentialProjs.uniq.sort
+    end
+    
+    
+    def filterStep(step, globalFilterStr)
+      
+      # 1st prio: explicit single filter
+      if step.filter != "" 
+        return true if  Bake.options.exclude_filter.include?step.filter
+        return false if Bake.options.include_filter.include?step.filter
+      end 
+
+      # 2nd prio: explicit global filter
+      if globalFilterStr != nil
+        return true if  Bake.options.exclude_filter.include?globalFilterStr
+        return false if Bake.options.include_filter.include?globalFilterStr
+      end      
+
+      # 3nd prio: default
+      return true if step.default == "off"
+      false      
+    end
+        
+    def filterSteps
+      @referencedConfigs.each do |projName, configs|
+        configs.each do |config|
+          config.preSteps.step  = config.preSteps.step.delete_if  { |step| filterStep(step, "PRE") }  if config.preSteps
+          config.postSteps.step = config.postSteps.step.delete_if { |step| filterStep(step, "POST") } if config.postSteps
+          if Metamodel::CustomConfig === config and config.step
+            config.step = nil if filterStep(config.step, nil)
+          end
+        end
+      end
+    end
+
+    def load()
+      @loader = Loader.new
+      cache = CacheAccess.new()
+      @referencedConfigs = cache.load_cache unless Bake.options.nocache
+
+      # cache invalid or forced to reload
+      if @referencedConfigs.nil?
+        loadMainMeta
+        checkRoots
+        while dep = @depsPending.shift
+          loadMeta(dep)
+        end
+
+
+        
+        if (cache.defaultToolchain)
+          if @defaultToolchain[:LINKER][:FLAGS]                   == cache.defaultToolchain[:LINKER][:FLAGS] and
+            @defaultToolchain[:LINKER][:LIB_PREFIX_FLAGS]         == cache.defaultToolchain[:LINKER][:LIB_PREFIX_FLAGS] and
+            @defaultToolchain[:LINKER][:LIB_POSTFIX_FLAGS]        == cache.defaultToolchain[:LINKER][:LIB_POSTFIX_FLAGS] and
+            @defaultToolchain[:ARCHIVER][:FLAGS]                  == cache.defaultToolchain[:ARCHIVER][:FLAGS] and
+            @defaultToolchain[:COMPILER][:CPP][:FLAGS]            == cache.defaultToolchain[:COMPILER][:CPP][:FLAGS] and
+            @defaultToolchain[:COMPILER][:CPP][:DEFINES].join("") == cache.defaultToolchain[:COMPILER][:CPP][:DEFINES].join("") and
+            @defaultToolchain[:COMPILER][:C][:FLAGS]              == cache.defaultToolchain[:COMPILER][:C][:FLAGS] and
+            @defaultToolchain[:COMPILER][:C][:DEFINES].join("")   == cache.defaultToolchain[:COMPILER][:C][:DEFINES].join("") and
+            @defaultToolchain[:COMPILER][:ASM][:FLAGS]            == cache.defaultToolchain[:COMPILER][:ASM][:FLAGS] and
+            @defaultToolchain[:COMPILER][:ASM][:DEFINES].join("") == cache.defaultToolchain[:COMPILER][:ASM][:DEFINES].join("") and
+            @defaultToolchain[:LINT_POLICY].join("")              == cache.defaultToolchain[:LINT_POLICY].join("")
+            @defaultToolchain[:DOCU]                              == cache.defaultToolchain[:DOCU]
+            @@defaultToolchainTime = cache.defaultToolchainTime
+          end
+        end
+        
+        filterSteps
+        
+        cache.write_cache(@project_files, @referencedConfigs, @defaultToolchain, @@defaultToolchainTime)
+      else
+        @defaultToolchain = cache.defaultToolchain
+        @@defaultToolchainTime = cache.defaultToolchainTime
+      end
+      
+    end
+    
+    
+  end
+
+end

data/lib/bake/libElement.rb

@@ -0,0 +1,134 @@
+module Bake
+  
+  class LibElement
+    
+    LIB = 1
+    USERLIB = 2
+    LIB_WITH_PATH = 3
+    SEARCH_PATH = 4
+    DEPENDENCY = 5
+
+    attr_reader :type, :value
+    
+    def initialize(type, value)
+      @type = type
+      @value = value
+    end
+  end
+  
+  class LibElements  
+      
+    def self.calc_linker_lib_string(block, tcs)
+      @@lib_path_set = []
+      @@dep_set = Set.new
+      @@linker = tcs[:LINKER]
+      @@projectDir = block.projectDir
+      @@source_libraries = []
+      @@linker_libs_array = []
+      
+      collect_recursive(block)
+      
+      if @@linker[:LIST_MODE] and not @@lib_path_set.empty?
+        @@linker_libs_array << (@@linker[:LIB_PATH_FLAG] + @@lib_path_set.join(","));
+      end
+      
+      return [@@source_libraries, @@linker_libs_array] 
+    end
+    
+    def self.adaptPath(path, block, prefix)
+      adaptedPath = path
+      if not File.is_absolute?(path)
+        prefix ||= File.rel_from_to_project(@@projectDir,block.projectDir)
+        adaptedPath = prefix + path if prefix
+      end
+      #adaptedPath = "\"" + adaptedPath + "\"" if adaptedPath.include?(" ")
+      [adaptedPath, prefix]
+    end
+    
+    def self.collect_recursive(block)
+      return if @@dep_set.include?block
+      @@dep_set << block
+        
+      prefix = nil
+
+      if block.library
+        adaptedPath, prefix = adaptPath(block.library.archive_name, block, prefix)
+        @@linker_libs_array << adaptedPath
+        @@source_libraries << adaptedPath
+      end
+     
+      block.lib_elements.each_key.sort.each do |line_num|
+        block.lib_elements[line_num].each do |elem|
+       
+          case elem.type
+          when LibElement::LIB
+            @@linker_libs_array << "#{@@linker[:LIB_FLAG]}#{elem.value}"
+          when LibElement::USERLIB
+            @@linker_libs_array << "#{@@linker[:USER_LIB_FLAG]}#{elem.value}"
+          when LibElement::LIB_WITH_PATH
+            adaptedPath, prefix = adaptPath(elem.value, block, prefix)
+            @@linker_libs_array <<  adaptedPath
+          when LibElement::SEARCH_PATH
+            adaptedPath, prefix = adaptPath(elem.value, block, prefix)
+            if not @@lib_path_set.include?adaptedPath
+              @@lib_path_set << adaptedPath
+              @@linker_libs_array << "#{@@linker[:LIB_PATH_FLAG]}#{adaptedPath}" if @@linker[:LIST_MODE] == false
+            end
+          when LibElement::DEPENDENCY
+            if Blocks::ALL_BLOCKS.include?elem.value
+              bb = Blocks::ALL_BLOCKS[elem.value]
+              collect_recursive(bb)
+            else
+              # TODO: warning or error?
+            end
+          end
+        end
+      end
+    end      
+    
+    
+    
+    
+    def self.calcLibElements(block)
+      lib_elements = {} # key = line number, value = array pairs [type, name/path string]
+        
+      block.config.userLibrary.each do |l|
+        ln = l.lib
+        ls = nil
+        if l.lib.include?("/")
+          pos = l.lib.rindex("/")
+          ls = block.convPath(l.lib[0..pos-1], l)
+          ln = l.lib[pos+1..-1]
+        end
+        lib_elements[l.line_number] = ls.nil? ? [] : [LibElement.new(LibElement::SEARCH_PATH, ls)] 
+        lib_elements[l.line_number] << LibElement.new(LibElement::USERLIB, ln)
+      end
+      
+      block.config.exLib.each do |exLib|
+        ln = exLib.name
+        ls = nil
+        if exLib.name.include?("/")
+          pos = exLib.name.rindex("/")
+          ls = block.convPath(exLib.name[0..pos-1], exLib)
+          ln = exLib.name[pos+1..-1]
+        end
+        if exLib.search
+          lib_elements[exLib.line_number] = ls.nil? ? [] : [LibElement.new(LibElement::SEARCH_PATH, ls)] 
+          lib_elements[exLib.line_number] << LibElement.new(LibElement::LIB, ln)
+        else
+          ln = ls + "/" + ln unless ls.nil?
+          lib_elements[exLib.line_number] = [LibElement.new(LibElement::LIB_WITH_PATH, ln)]
+        end
+      end
+      
+      block.config.exLibSearchPath.each do |exLibSP|
+        lib_elements[exLibSP.line_number] = [LibElement.new(LibElement::SEARCH_PATH, block.convPath(exLibSP))] 
+      end
+    
+      block.config.dependency.each { |dep| lib_elements[dep.line_number] = [LibElement.new(LibElement::DEPENDENCY, dep.name+","+dep.config)]}
+      return lib_elements
+    end      
+     
+  end
+  
+end

data/lib/bake/mergeConfig.rb

@@ -1,4 +1,4 @@
-module Cxxproject
+module Bake
 
   class MergeConfig
   

data/lib/bake/model/language.rb

@@ -4,7 +4,7 @@ require 'rtext/language'
 
 
 
-module Cxxproject
+module Bake
 
   class Idp
     def call(e,unused)

data/lib/bake/model/loader.rb

@@ -0,0 +1,88 @@
+require 'bake/model/metamodel'
+require 'bake/model/language'
+require 'common/version'
+
+require 'rgen/environment'
+require 'rgen/fragment/dump_file_cache'
+require 'rgen/fragment/fragmented_model'
+require 'rgen/util/file_cache_map'
+
+require 'rtext/default_loader'
+
+require 'common/exit_helper'
+require 'bake/toolchain/colorizing_formatter'
+require 'bake/options/options'
+
+module Bake
+
+  class Loader
+  
+    attr_reader :model
+  
+    def initialize
+      @env = RGen::Environment.new
+    
+      fcm = RGen::Util::FileCacheMap.new(".bake", ".cache")
+      fcm.version_info = Version.number
+      @DumpFileCache = RGen::Fragment::DumpFileCache.new(fcm)
+      @model = RGen::Fragment::FragmentedModel.new(:env => @env)
+    end
+    
+    def load(filename)
+      sumErrors = 0
+
+      if Bake.options.nocache
+        def @DumpFileCache.load(fragment)
+          :invalid
+        end
+      end
+            
+      if not File.exists?filename
+        Bake.formatter.printError("Error: #{filename} does not exist")
+        ExitHelper.exit(1) 
+      end
+    
+      loader = RText::DefaultLoader.new(
+        Bake::Language,
+        @model,
+        :file_provider => proc { [filename] },
+        :cache => @DumpFileCache)
+      loader.load(:before_load => proc {|fragment, kind|
+        case kind
+        when :load_update_cache
+          if Bake.options.verboseHigh
+            puts "Loading and caching #{fragment.location}"
+          else
+            puts "Loading #{fragment.location}"
+          end
+        when :load_cached
+          if Bake.options.verboseHigh
+            puts "Loading cached #{fragment.location}"
+          else
+            puts "Loading #{fragment.location}"
+          end
+        when :load
+          puts "Loading #{fragment.location}"
+        else
+          Bake.formatter.printError("Error: Could not load #{fragment.location}")
+          ExitHelper.exit(1)     
+        end
+      })
+    
+      f = @model.fragments[0]
+      @model.remove_fragment(f)
+    
+      f.data[:problems].each do |p|
+        Bake.formatter.printError(p.message, p.file, p.line)
+      end
+      
+      if f.data[:problems].length > 0
+        ExitHelper.exit(1) 
+      end
+      
+      return f
+    
+    end
+  
+  end
+end