cxxproject 0.2 → 0.4.6

data/Rakefile.rb

@@ -1,47 +1,69 @@
 require 'rake/gempackagetask'
-require 'roodi'
-require 'roodi_task'
-require 'spec/rake/spectask'
+begin
+  require 'roodi'
+  require 'roodi_task'
+rescue LoadError # don't bail out when people do not have roodi installed!
+  warn "roodi not installed...will not be checked!"
+end
+
+begin
+  require 'spec/rake/spectask' # old rspec
+rescue LoadError
+  begin
+		require 'rspec/core/rake_task' # rspec 2.5.x
+  rescue LoadError
+    warn "spec not installed...will not be checked!"
+  end
+end
+
+
 
 desc "Default Task"
-task :default => [:package, :roodi]
+task :default => [:install]
 
-PKG_VERSION = '0.2'
 PKG_FILES = FileList[
-    'lib/**/*.rb',
-    'Rakefile.rb',
-    'spec/**/*.rb'
-#    'doc/**/*'
-  ]
-
-spec = Gem::Specification.new do |s|
-  s.name = 'cxxproject'
-  s.version = PKG_VERSION
-  s.summary = "Cpp Support for Rake."
-  s.description = <<-EOF
-    Some more high level building blocks for cpp projects.
-  EOF
-  s.files = PKG_FILES.to_a
-  s.require_path = 'lib'
-  s.author = ''
-  s.email = ''
-  s.homepage = ''
-end
+  'lib/**/*.rb',
+  'lib/tools/**/*.template',
+  'Rakefile.rb',
+  'spec/**/*.rb'
+]
 
-RoodiTask.new
-Rake::GemPackageTask.new(spec) {|pkg|}
+task :gem
+spec = Gem::Specification.load('cxx.gemspec')
+Rake::GemPackageTask.new(spec)
 
-task :gem => [:spec, :roodi]
+if self.class.const_defined?(:RoodiTask) then
+  RoodiTask.new  'roodi', PKG_FILES, 'roodi.yml'
+  task :gem => [:roodi]
+end
 
-desc "Run all examples"
-Spec::Rake::SpecTask.new() do |t|
-  t.spec_files = FileList['spec/**/*.rb']
+# old rspec
+if self.class.const_defined?(:SpecTask) then
+  desc "Run all examples"
+  Spec::Rake::SpecTask.new() do |t|
+    t.spec_files = FileList['spec/**/*_spec.rb']
+  end
+#  task :gem => [:spec]
 end
 
-task :default => [:install]
+# new rspec
+begin # const_defined? did not work?
+  desc "Run all examples"
+  RSpec::Core::RakeTask.new() do |t|
+    puts Dir.glob 'spec/**/*_spec.rb'
+    t.pattern = 'spec/**/*_spec.rb'
+  end
+#  task :gem => [:spec]
+rescue
+end
+
+desc 'build gem only'
+task :gem_only do
+  sh "gem build cxx.gemspec"
+  mv FileList["*.gem"], "pkg"
+end
 
 desc "install gem globally"
-task :install => :gem do
+task :install => [:gem] do
   sh "gem install pkg/#{spec.name}-#{spec.version}.gem"
 end
-

data/bin/cxx

@@ -0,0 +1,10 @@
+#!/usr/bin/ruby
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+
+require 'tools/projectWizard'
+
+if ARGV.size < 1 
+	puts "usage: cxx project-dir" 
+	exit 0
+end
+prepare_project(ARGV[0])

data/lib/cxxproject/buildingblocks/binary_library.rb

@@ -0,0 +1,16 @@
+require 'cxxproject/buildingblocks/building_block'
+require 'cxxproject/buildingblocks/has_libraries_mixin'
+
+class BinaryLibrary < BuildingBlock
+  include HasLibraries
+
+  def initialize(name)
+    super(name)
+    libs_to_search << name
+  end
+
+  def get_task_name()
+    libs_to_search[0]
+  end
+
+end

data/lib/cxxproject/buildingblocks/building_block.rb

@@ -0,0 +1,93 @@
+require 'cxxproject/buildingblocks/has_dependencies_mixin'
+require 'cxxproject/utils/dot/graph_writer'
+
+# stores all defined buildingblocks by name (the name should be unique)
+ALL_BUILDING_BLOCKS = {}
+
+class BuildingBlock
+  include HasDependencies
+
+  attr_reader :name
+  attr_reader :graph_name
+  attr_reader :config_files
+  attr_reader :project_dir
+  attr_reader :output_dir
+  attr_reader :complete_output_dir
+
+  def set_name(x)
+    @name = x
+    self
+  end
+
+  def set_tcs(x)
+    @tcs = x
+    self
+  end
+  
+  def has_tcs?
+    @tcs != nil
+  end
+
+  def tcs()
+    raise "Toolchain settings must be set before!" if @tcs.nil?
+    @tcs
+  end
+
+  def set_config_files(x)
+    @config_files = x
+    self
+  end
+
+  def set_project_dir(x)
+    @project_dir = x
+    calc_complete_output_dir
+    self
+  end
+
+  # if output dir is absolute, -L and -l is used for linker ("linux mode")
+  def set_output_dir(x)
+    @output_dir = x
+    @output_dir_abs = File.is_absolute?(@output_dir)
+    calc_complete_output_dir
+    self
+  end
+
+  def calc_complete_output_dir
+    if @output_dir_abs
+      @complete_output_dir = @output_dir
+    else
+      @complete_output_dir = @project_dir + "/" + @output_dir
+    end
+  end
+
+  def set_graph_name(x)
+    @graph_name = x
+    self
+  end
+
+  def initialize(name)
+    @name = name
+    @graph_name = name
+    @config_files = []
+    @project_dir = "."
+    @output_dir = "."
+    @complete_output_dir = "."
+    @tcs = nil
+    @output_dir_abs = false
+
+    begin
+      raise "building block already exists: #{name}" if ALL_BUILDING_BLOCKS.include?@name
+      ALL_BUILDING_BLOCKS[@name] = self
+    rescue Exception => e 
+      puts e
+    end
+  end
+
+  def complete_init()
+  end
+
+  def get_task_name()
+    raise "this method must be implemented by decendants"
+  end
+
+end

data/lib/cxxproject/buildingblocks/command_line.rb

@@ -0,0 +1,30 @@
+require 'cxxproject/buildingblocks/building_block'
+
+class CommandLine < BuildingBlock
+
+  def set_command_line(x)
+    @line = x
+    self
+  end
+
+  def get_command_line
+    @line
+  end
+
+  def get_target
+    @target
+  end
+
+  @@command_line_num = 0
+  def initialize(name)
+    super(name)
+    @line = name
+    @@command_line_num = @@command_line_num + 1
+    @num = @@command_line_num
+  end
+
+  def get_task_name()
+    "command line (#{@num}): " + get_command_line
+  end
+
+end

data/lib/cxxproject/buildingblocks/custom_building_block.rb

@@ -0,0 +1,17 @@
+require 'cxxproject/buildingblocks/building_block'
+
+# todo...
+
+class CustomBuildingBlock < BuildingBlock
+  attr_reader :custom_command
+
+  def set_custom_command(c)
+    @custom_command = c
+    self
+  end
+
+  def get_task_name()
+    raise "todo"
+  end
+
+end

data/lib/cxxproject/buildingblocks/executable.rb

@@ -0,0 +1,49 @@
+require 'cxxproject/buildingblocks/building_block'
+require 'cxxproject/buildingblocks/has_libraries_mixin'
+require 'cxxproject/buildingblocks/has_sources_mixin'
+
+class Executable < BuildingBlock
+  include HasLibraries
+  include HasSources
+
+  attr_reader :linker_script
+  attr_reader :mapfile
+  attr_reader :output_file
+
+  def set_linker_script(x)
+    @linker_script = x
+    self
+  end
+
+  def set_mapfile(x)
+    @mapfile = x
+    self
+  end
+
+  # set during creating the task - note: depends on the used tcs
+  def set_output_file(x)
+    @output_file = x
+    self
+  end
+
+  def initialize(name)
+    super(name)
+    @linker_script = nil
+    @mapfile = nil
+  end
+
+  def linker_libs_string
+    @linkerString ||= ""
+  end
+
+
+  def get_executable_name()
+    File.relFromTo(@complete_output_dir + "/" + @name + @tcs[:LINKER][:OUTPUT_ENDING], @project_dir)
+  end
+
+  def get_task_name()
+    get_executable_name()
+  end
+
+
+end

data/lib/cxxproject/buildingblocks/has_dependencies_mixin.rb

@@ -0,0 +1,57 @@
+module HasDependencies
+
+  def dependencies
+    @dependencies ||= []
+  end
+  def set_dependencies(deps)
+    @dependencies = deps.map { |dep| dep.instance_of?(String) ? dep : dep.name }
+    self
+  end
+
+  # if set, includes and libs are taken from this array, not from @dependencies.
+  # task deps are still taken from @dependencies.
+  # use case: circular deps are allowed on "include-level", but not on "task-level".
+  def helper_dependencies
+    @helper_dependencies ||= []
+  end
+
+  def set_helper_dependencies(deps)
+    @helper_dependencies = deps.map { |dep| dep.instance_of?(String) ? dep : dep.name }
+  end
+
+  # will be calculated at the beginning of creating the building block task
+  def all_dependencies
+    @all_dependencies ||= []
+  end
+
+  # inclusive self!!
+  def calc_transitive_dependencies
+    deps = [self.name]
+    @all_dependencies = get_transitive_dependencies_internal(deps)
+  end
+
+  def get_transitive_dependencies_internal(deps)
+    depsToCheck = []
+    depList = helper_dependencies.length > 0 ? helper_dependencies : dependencies
+    depList.each do |d|
+      if not deps.include?d
+        deps << d
+        depsToCheck << d
+      end
+    end
+
+    # two-step needed to keep order of dependencies for includes, lib dirs, etc
+    depsToCheck.each do |d|
+      begin
+        raise "ERROR: while reading config file for #{self.name}: dependent building block \"#{d}\" was specified but not found!" unless ALL_BUILDING_BLOCKS[d]
+        ALL_BUILDING_BLOCKS[d].get_transitive_dependencies_internal(deps)
+      rescue Exception => e
+        puts e
+        exit
+      end
+    end
+    deps
+
+  end
+
+end

data/lib/cxxproject/buildingblocks/has_libraries_mixin.rb

@@ -0,0 +1,35 @@
+module HasLibraries
+
+  def user_libs
+    @user_libs ||= []
+  end
+  def set_user_libs(x)
+    @user_libs = x
+    self
+  end
+
+  def libs_to_search
+    @libs_to_search ||= []
+  end
+  def set_libs_to_search(x)
+    @libs_to_search = x
+    self
+  end
+
+  def lib_searchpaths
+    @lib_searchpaths ||= []
+  end
+  def set_lib_searchpaths(x)
+    @lib_searchpaths = x
+    self
+  end
+
+  def libs_with_path
+    @libs_with_path ||= []
+  end
+  def set_libs_with_path(x)
+    @libs_with_path = x
+    self
+  end
+
+end

data/lib/cxxproject/buildingblocks/has_sources_mixin.rb

@@ -0,0 +1,85 @@
+module HasSources
+
+  def sources
+    @sources ||= []
+  end
+  def set_sources(x)
+    @sources = x
+    self
+  end
+
+  def includes
+    @includes ||= []
+  end
+  def set_includes(x)
+    @includes = x
+    self
+  end
+
+  # 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 include_string(type)
+    @include_string[type] ||= ""
+  end
+
+  def define_string(type)
+    @define_string[type] ||= ""
+  end
+
+  def calc_compiler_strings()
+    @include_string = {}
+    @define_string = {}
+
+    @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)
+      else
+        d.includes.each { |k| @incArray << File.relFromTo(k, d.project_dir) }
+      end
+    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
+
+  def get_include_string(tcs, type)
+    @incArray.uniq.map!{|k| "#{tcs[:COMPILER][type][:INCLUDE_PATH_FLAG]}#{k}"}.join(" ")
+  end
+
+  def get_define_string(tcs, type)
+    @tcs[:COMPILER][type][:DEFINES].map {|k| "#{tcs[:COMPILER][type][:DEFINE_FLAG]}#{k}"}.join(" ")
+  end
+
+  def get_object_file(source)
+    File.relFromTo(source, @complete_output_dir + (@output_dir_abs ? ("/" + @name) : "") ) + ".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
+    "Sources of #{name}"
+  end
+
+end

data/lib/cxxproject/buildingblocks/makefile.rb

@@ -0,0 +1,35 @@
+require 'cxxproject/buildingblocks/building_block'
+require 'cxxproject/buildingblocks/has_libraries_mixin'
+
+class Makefile < BuildingBlock
+  include HasLibraries
+
+  def set_target(x)
+    @target = x
+    self
+  end
+
+  def set_makefile(x)
+    @makefile = x
+    self
+  end
+
+  def get_makefile
+    File.relFromTo(@makefile, @project_dir)
+  end
+
+  def get_target
+    @target
+  end
+
+  def initialize(name)
+    super(name)
+    @target = "all"
+    @makefile = nil
+  end
+
+  def get_task_name()
+    get_makefile+"_"+get_target
+  end
+
+end

data/lib/cxxproject/buildingblocks/module.rb

@@ -0,0 +1,14 @@
+require 'cxxproject/buildingblocks/building_block'
+require 'cxxproject/buildingblocks/has_libraries_mixin'
+require 'cxxproject/buildingblocks/has_sources_mixin'
+
+# can be used as wrapper for other tasks
+class ModuleBuildingBlock < BuildingBlock
+  include HasLibraries
+  include HasSources
+
+  def get_task_name()
+    name
+  end
+
+end

data/lib/cxxproject/buildingblocks/single_source.rb

@@ -0,0 +1,11 @@
+require 'cxxproject/buildingblocks/building_block'
+require 'cxxproject/buildingblocks/has_sources_mixin'
+
+class SingleSource < BuildingBlock
+  include HasSources
+
+  def get_task_name()
+    get_sources_task_name
+  end
+
+end

data/lib/cxxproject/buildingblocks/source_library.rb

@@ -0,0 +1,31 @@
+require 'cxxproject/buildingblocks/building_block'
+require 'cxxproject/buildingblocks/has_libraries_mixin'
+require 'cxxproject/buildingblocks/has_sources_mixin'
+
+class SourceLibrary < BuildingBlock
+  include HasLibraries
+  include HasSources
+
+  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 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")
+    end
+  end
+
+  def get_archive_name()
+    File.relFromTo(@complete_output_dir + "/lib" + @name + ".a", @project_dir)
+  end
+
+  def get_task_name()
+    get_archive_name
+  end
+
+end

data/lib/cxxproject/extensions/file_ext.rb

@@ -0,0 +1,47 @@
+class File
+
+  @@oldRuby = RUBY_VERSION[0..2] == "1.8"
+
+  def self.is_absolute?(filename)
+    if @@oldRuby
+      filename[0] == 47 or filename[1] == 58 # 47 = /, 58 = :
+    else
+      filename[0] == '/' or filename[1] == ':'
+    end
+  end
+
+  # filename relative to nowRelToThisDir (if absolute, nowRelToThisDir can be nil)
+  # return: filename which is relative to thenRelToThisDir
+  def self.relFromTo(filename,nowRelToThisDir,thenRelToThisDirOrg = Dir.pwd)
+
+    absFilename = filename
+    thenRelToThisDir = thenRelToThisDirOrg + "/"
+
+    if not File.is_absolute?(filename)
+      absFilename = File.expand_path(nowRelToThisDir + "/" + filename)
+    end
+
+    maxLength = thenRelToThisDir.length > absFilename.length ? absFilename.length : thenRelToThisDir.length
+
+    lastEqDir = -1
+    for i in 0..maxLength-1
+      break if thenRelToThisDir[i] != absFilename[i]
+    end
+    lastEqDir = thenRelToThisDir.rindex("/",i)
+
+    if lastEqDir
+      dotdot = thenRelToThisDir[lastEqDir+1..-1].split("/").length
+      res = ""
+      dotdot.times  { res << "../" }
+      res << absFilename[lastEqDir+1..-1]
+      return absFilename if res.length > absFilename.length # avoid something like "../../../../../../usr/local/lib"
+      return res
+    else
+      return absFilename
+    end
+
+
+
+  end
+
+end

data/lib/cxxproject/extensions/rake_dirty_ext.rb

@@ -0,0 +1,30 @@
+require 'rake'
+module Rake
+  class Task
+    # return true if this or one of the prerequisites is dirty
+    def dirty?
+      return calc_dirty_for_prerequsites if apply?(name)
+
+      if needed?
+        return true
+      end
+      return calc_dirty_for_prerequsites
+    end
+
+    def calc_dirty_for_prerequsites
+      res = prerequisites.find do |p|
+        t = Task[p]
+        if t != nil
+          if t.dirty?
+            true
+          else
+            false
+          end
+        else
+          false
+        end
+      end
+      return res != nil
+    end
+  end
+end