bake-toolkit 1.0.1

data/lib/bake/subst.rb

@@ -0,0 +1,90 @@
+module Cxxproject
+
+  class Subst
+  
+    def self.itute(config, projName, options)
+    
+      @@configName = config.name
+      @@projName = projName
+      @@options = options
+      @@mainProjectName = File::basename(options.main_dir)
+      
+      @@artifactName = ""
+      if Metamodel::ExecutableConfig === config
+        if not config.artifactName.nil?
+          @@artifactName = config.artifactName.name
+        elsif config.defaultToolchain != nil
+          basedOnToolchain = Cxxproject::Toolchain::Provider[config.defaultToolchain.basedOn]
+          if basedOnToolchain != nil
+            @@artifactName = projName+basedOnToolchain[:LINKER][:OUTPUT_ENDING]
+          end
+        end
+      end
+      
+      subst(config)    
+    end
+    
+    def self.subst(elem)
+      elem.class.ecore.eAllAttributes_derived.each do |a|
+        next if a.name == "file_name" or a.name == "line_number"
+        next if a.eType.name != "EString" 
+        str = elem.getGeneric(a.name)
+      
+        posSubst = 0
+        substStr = ""
+        while (true)
+          posStart = str.index("$(", posSubst)
+          break if posStart.nil?
+          posEnd = str.index(")", posStart)
+          break if posEnd.nil?
+          substStr << str[posSubst..posStart-1] if posStart>0
+        
+          var = str[posStart+2..posEnd-1]
+        
+          if var == "MainConfigName"
+            substStr << @@options.build_config
+          elsif var == "MainProjectName"
+            substStr << @@mainProjectName 
+          elsif var == "ConfigName"
+           substStr << @@configName
+          elsif var == "ProjectName"
+            substStr << @@projName
+          elsif var == "OutputDir"
+            if @@projName == @@mainProjectName 
+              substStr << @@options.build_config
+            else
+              substStr << (@@options.build_config + "_" + @@mainProjectName)
+            end
+          elsif var == "Time"
+            substStr << Time.now.to_s
+          elsif var == "Hostname"
+            substStr << Socket.gethostname
+          elsif var == "ArtifactName"
+            substStr << @@artifactName
+          elsif var == "ArtifactNameBase"
+            substStr << @@artifactName.chomp(File.extname(@@artifactName))
+          elsif ENV[var]
+            substStr << ENV[var]
+          elsif var == "PATH_TO_CYGWIN" # allowed to be not set
+            substStr << ""
+          else
+            Printer.printError "Error: #{elem.file_name}(#{elem.line_number}): unknown substitution variable '$(#{var})'"
+            ExitHelper.exit(1)
+          end
+        
+          posSubst = posEnd + 1
+        end
+        substStr << str[posSubst..-1]
+      
+        elem.setGeneric(a.name, substStr)
+      end    
+    
+      childsRefs = elem.class.ecore.eAllReferences.select{|r| r.containment}
+      childsRefs.each do |c|
+        elem.getGenericAsArray(c.name).each { |child| subst(child) }
+      end     
+    end
+  
+  end
+  
+end

data/lib/bake/util.rb

@@ -0,0 +1,98 @@
+require 'bake/model/metamodel_ext'
+require 'bake/model/metamodel'
+require 'set'
+require 'cxxproject/utils/printer'
+require 'cxxproject/utils/exit_helper'
+require 'cxxproject/utils/utils'
+
+def adjustFlags(orgStr, flags)
+  orgSplitted = Cxxproject::Utils::flagSplit(orgStr)
+
+  flags.each do |f|
+    if f.overwrite != ""
+      orgSplitted = Cxxproject::Utils::flagSplit(f.overwrite)
+    end
+    
+    if f.remove != ""
+      rmSplitted = Cxxproject::Utils::flagSplit(f.remove)
+      orgSplitted.delete_if {|o| rmSplitted.any? { |r|
+        begin
+          o.match("\\A"+r+"\\Z")
+        rescue Exception => e
+          Cxxproject::Printer.printError "Error: #{f.file_name}(#{f.line_number}): " + e.message
+          Cxxproject::ExitHelper.exit(1)
+        end
+      }}
+    end
+    
+    if f.add != ""
+      Cxxproject::Utils::flagSplit(f.add).each do |a|
+        orgSplitted << a unless orgSplitted.any? { |o| o==a }
+      end
+    end
+    
+  end
+  
+  orgSplitted.join(" ")
+end
+
+def integrateToolchain(tcs, toolchain)
+  return tcs unless toolchain
+  
+  integrateLinker(tcs, toolchain.linker) if toolchain.respond_to?"linker"
+  integrateArchiver(tcs, toolchain.archiver)
+  toolchain.compiler.each do |c| 
+    integrateCompiler(tcs, c, c.ctype)
+  end
+end  
+
+
+def integrateLinker(tcs, linker)
+  return tcs unless linker
+  tcs[:LINKER][:COMMAND] = linker.command if linker.command != ""
+  tcs[:LINKER][:FLAGS] = adjustFlags(tcs[:LINKER][:FLAGS], linker.flags) 
+  tcs[:LINKER][:LIB_PREFIX_FLAGS] = adjustFlags(tcs[:LINKER][:LIB_PREFIX_FLAGS], linker.libprefixflags) 
+  tcs[:LINKER][:LIB_POSTFIX_FLAGS] = adjustFlags(tcs[:LINKER][:LIB_POSTFIX_FLAGS], linker.libpostfixflags) 
+end
+
+def integrateArchiver(tcs, archiver)
+  return tcs unless archiver
+  tcs[:ARCHIVER][:COMMAND] = archiver.command if archiver.command != ""
+  tcs[:ARCHIVER][:FLAGS] = adjustFlags(tcs[:ARCHIVER][:FLAGS], archiver.flags) 
+end
+
+def integrateCompiler(tcs, compiler, type)
+  return tcs unless compiler
+  if compiler.respond_to?"command"
+    tcs[:COMPILER][type][:COMMAND] = compiler.command if compiler.command != ""
+  end
+  tcs[:COMPILER][type][:FLAGS] = adjustFlags(tcs[:COMPILER][type][:FLAGS], compiler.flags)
+  compiler.define.each do |d|
+    tcs[:COMPILER][type][:DEFINES] << d.str
+  end
+end
+
+def integrateCompilerFile(tcs, compiler)
+  [:CPP, :C, :ASM].each do |t|
+    integrateCompiler(tcs, compiler, t)
+  end
+  return tcs
+end
+
+
+def sanitize_filename(filename)
+  filename.strip do |name|
+   # NOTE: File.basename doesn't work right with Windows paths on Unix
+   # get only the filename, not the whole path
+   name.gsub! /^.*(\\|\/)/, ''
+
+   # Finally, replace all non alphanumeric, underscore 
+   # or periods with underscore
+   # name.gsub! /[^\w\.\-]/, '_'
+   # Basically strip out the non-ascii alphabets too 
+   # and replace with x. 
+   # You don't want all _ :)
+   name.gsub!(/[^0-9A-Za-z.\-]/, 'x')
+  end
+end
+

data/lib/bake/version.rb

@@ -0,0 +1,30 @@
+module Cxxproject
+  class Version
+    def self.bake
+      "1.0.1"
+    end
+  end
+    
+  expectedCxx = "0.5.59"
+  expectedRGen = "0.6.0"
+  expectedRText = "0.2.0"
+  
+  begin
+    gem "cxxproject", "=#{expectedCxx}"
+  rescue Exception => e
+    puts "Warning: Failed to load cxxproject #{expectedCxx}, using latest version"
+  end    
+
+  begin
+    gem "rgen", "=#{expectedRGen}"
+  rescue Exception => e
+    puts "Warning: Failed to load rgen #{expectedRGen}, using latest version"
+  end    
+
+  begin
+    gem "rtext", "=#{expectedRText}"
+  rescue Exception => e
+    puts "Warning: Failed to load rtext #{expectedRText}, using latest version"
+  end    
+
+end

data/lib/bakery/loader.rb

@@ -0,0 +1,57 @@
+require 'bakery/model/metamodel'
+require 'bakery/model/language'
+require 'bake/version'
+
+require 'rgen/environment'
+require 'rgen/fragment/fragmented_model'
+
+require 'rtext/default_loader'
+
+require 'cxxproject/utils/exit_helper'
+require 'cxxproject/utils/printer'
+
+module Cxxproject
+
+class BakeryLoader
+
+attr_reader :model
+
+def initialize(options)
+  @env = RGen::Environment.new
+  @options = options
+  @model = RGen::Fragment::FragmentedModel.new(:env => @env)
+end
+
+def load(filename)
+
+  sumErrors = 0
+  
+  if not File.exists?filename
+    Printer.printError "Error: #{filename} does not exist"
+    ExitHelper.exit(1) 
+  end
+
+  loader = RText::DefaultLoader.new(
+    Cxxproject::BakeryLanguage,
+    @model,
+    :file_provider => proc { [filename] },
+    :cache => @DumpFileCache)
+  loader.load()
+
+  f = @model.fragments[0]
+  
+  f.data[:problems].each do |p|
+    Printer.printError "Error: "+p.file+"("+p.line.to_s+"): "+p.message
+  end
+  
+  if f.data[:problems].length > 0
+    ExitHelper.exit(1) 
+  end
+  
+  return @env
+
+end
+
+
+end
+end

data/lib/bakery/model/language.rb

@@ -0,0 +1,22 @@
+require 'bake/model/metamodel'
+require 'rtext/language'
+
+module Cxxproject
+
+  BakeryLanguage =
+  RText::Language.new(BakeryModel.ecore,
+    :feature_provider => proc {|c|
+      RGen::Serializer::OppositeReferenceFilter.call(c.eAllStructuralFeatures).reject {|f|
+        f.eAnnotations.any? {|a|
+          a.details.any? {|d| d.key == 'internal' && d.value == 'true'}
+        }
+      }
+    },
+    :unlabled_arguments => proc {|c|
+      ["name"]
+    },
+    :line_number_attribute => "line_number",
+    :file_name_attribute => "file_name"
+  )
+
+end

data/lib/bakery/model/metamodel.rb

@@ -0,0 +1,44 @@
+require 'rgen/metamodel_builder'
+require 'rgen/metamodel_builder/data_types'
+
+module Cxxproject
+
+  module BakeryModel
+    extend RGen::MetamodelBuilder::ModuleExtension
+
+    class ModelElement < RGen::MetamodelBuilder::MMBase
+      abstract
+      has_attr 'line_number', Integer do
+        annotation :details => {'internal' => 'true'}
+      end
+      has_attr 'file_name', String do
+        annotation :details => {'internal' => 'true'}
+      end
+    end
+
+    class Project < ModelElement
+      has_attr 'name', String, :defaultValueLiteral => ""
+      has_attr 'config', String, :defaultValueLiteral => ""
+    end
+    class Exclude < ModelElement
+      has_attr 'name', String, :defaultValueLiteral => ""
+      has_attr 'config', String, :defaultValueLiteral => ""
+    end
+    class Collection < ModelElement
+      has_attr 'name', String, :defaultValueLiteral => ""
+      contains_many 'project', Project, 'collection'
+      contains_many 'exclude', Exclude, 'collection'
+    end
+
+    module Project::ClassModule
+      def isFound
+        @isFound ||= false 
+      end
+      def found
+        @isFound = true 
+      end
+    end
+
+  end
+
+end

data/lib/bakery/options.rb

@@ -0,0 +1,98 @@
+require 'cxxproject/utils/printer'
+require "cxxproject/toolchain/colorizing_formatter"
+require "option/parser"
+
+module Cxxproject
+
+  class BakeryOptions < Parser
+    attr_reader :collection_name, :collection_dir # String
+    attr_reader :roots # String List
+    attr_reader :color, :error # Boolean
+    attr_reader :socket # Fixnum
+
+    def initialize(argv)
+      super(argv)
+      
+      @collection_name = nil
+      @collection_dir = nil      
+      @color = nil
+      @error = false
+      @roots = []
+      @socket = 0
+      @def_root = nil
+            
+      add_option(Option.new("-b",true)        { |x| set_collection_name(x)    })
+      add_option(Option.new("-m",true)        { |x| set_collection_dir(x)     })
+      add_option(Option.new("-r",false)       {     set_error                 })
+      add_option(Option.new("-a",true)        { |x| set_color(x)              })
+      add_option(Option.new("-w",true)        { |x| set_root(x)               })
+      add_option(Option.new("--socket",true)  { |x| set_socket(x)             })
+      add_option(Option.new("-h",false)       {     usage; ExitHelper.exit(0) })
+    end
+    
+    def usage
+      puts "\nUsage: bake [options]"
+      puts " -b <name>         Name of the collection to build."
+      puts " -m <dir>          Directory containing the collection file (default is current directory)."
+      puts " -r                Stop on first error."
+      puts " -a <scheme>       Use ansi color sequences (console must support it). Possible values are 'white' and 'black'."
+      puts " -h                Print this help."
+      puts " -w <root>         Add a workspace root (can be used multiple times)."
+      puts "                   If no root is specified, the parent directory of Collection.meta is added automatically."
+      puts " --socket <num>    Set socket for sending errors, receiving commands, etc. - used by e.g. Eclipse."
+      puts "Note: all parameters except -b, -p and -h will be passed to bake - see bake help for more options." 
+    end
+  
+    def parse_options()
+      parse_internal(true)
+      set_collection_dir(Dir.pwd) if @collection_dir.nil?
+      @roots << @def_root if @roots.length == 0
+    end
+    
+    def check_valid_dir(dir)
+     if not File.exists?(dir)
+        Printer.printError "Error: Directory #{dir} does not exist"
+        ExitHelper.exit(1)
+      end
+      if not File.directory?(dir)
+        Printer.printError "Error: #{dir} is not a directory"
+        ExitHelper.exit(1)
+      end      
+    end    
+    
+    def set_collection_name(collection_name)
+      @collection_name = collection_name
+    end
+    
+    def set_collection_dir(dir)
+      check_valid_dir(dir)
+      @collection_dir = File.expand_path(dir.gsub(/[\\]/,'/'))
+      @def_root = File.dirname(@collection_dir)
+    end
+    
+    def set_color(x)
+      if (x != "black" and x != "white")
+        Printer.printError "Error: color scheme must be 'black' or 'white'"
+        ExitHelper.exit(1)
+      end      
+      @color = x
+      ColorizingFormatter.enabled = true
+      ColorizingFormatter::setColorScheme(x.to_sym)
+    end    
+    def set_error()
+      @error = true
+    end
+
+    def set_root(dir)
+      check_valid_dir(dir)
+      r = File.expand_path(dir.gsub(/[\\]/,'/'))
+      @roots << r if not @roots.include?r
+    end
+        
+    def set_socket(num)
+      @socket = String === num ? num.to_i : num
+    end  
+  
+  end
+
+end