cxxproject 0.4.6 → 0.5.47

data/lib/cxxproject/torake.rb

@@ -1,152 +1,210 @@
 require 'logger'
 require 'pp'
 require 'pathname'
-require 'cxxproject/extensions/rake_ext'
-require 'cxxproject/toolchain/gcc'
-require 'cxxproject/task_maker'
-
-class CxxProject2Rake
+require 'cxxproject/ext/rake'
+require 'cxxproject/buildingblocks/module'
+require 'cxxproject/buildingblocks/makefile'
+require 'cxxproject/buildingblocks/executable'
+require 'cxxproject/buildingblocks/source_library'
+require 'cxxproject/buildingblocks/single_source'
+require 'cxxproject/buildingblocks/binary_library'
+require 'cxxproject/buildingblocks/custom_building_block'
+require 'cxxproject/buildingblocks/command_line'
+require 'cxxproject/toolchain/colorizing_formatter'
+require 'cxxproject/eval_context'
+
+module Cxxproject
+  class CxxProject2Rake
+
+    attr_accessor :base, :all_tasks
+
+    def initialize(projects, build_dir, toolchain, base='.')
+      @projects = projects
+      @base = base
+      @build_dir = build_dir
+      @toolchain = toolchain
+      @rel_projects = @projects.map { |p| File.join(@base, p) }
+
+      # TODO: this should be cleaned up somehow...
+      if Utils::OS.linux?
+        toolchain[:LINKER][:LIB_PREFIX_FLAGS] = "-Wl,--whole-archive"
+        toolchain[:LINKER][:LIB_POSTFIX_FLAGS] = "-Wl,--no-whole-archive"
+      end
+      
+      Rake::application.deriveIncludes = true
+
+      initialize_logging
+      @all_tasks = instantiate_tasks
+
+      create_generic_tasks
+      create_console_colorization
+      create_multitask
+      create_bail_on_first_task
+      describe_clean_task
+      create_console_task
+    end
 
-  attr_accessor :base, :all_tasks
+    def create_console_task
+      require 'cxxproject/utils/console'
+    end
 
-  def initialize(projects, build_dir, toolchain, base='.', logLevel=Logger::ERROR)
-    pwd = `pwd`
-    @log = Logger.new(STDOUT)
-    @log.formatter = proc { |severity, datetime, progname, msg|
-      "#{severity}: #{msg}\n"
-    }
+    def initialize_logging
+      @log = Logger.new(STDOUT)
+      @log.formatter = proc { |severity, datetime, progname, msg|
+        "#{severity}: #{msg}\n"
+      }
+      # Logger loglevels: fatal, error, warn, info, debug
+      # Rake --verbose -> info
+      # Rake --trace -> debug
+      @log.level = Logger::ERROR
+      @log.level = Logger::INFO if RakeFileUtils.verbose == true
+      @log.level = Logger::DEBUG if Rake::application.options.trace
+      @log.debug "initializing for build_dir: \"#{@build_dir}\", base: \"#{@base}\""
+    end
+    def describe_clean_task
+      Rake::Task[:clean].add_description('clean')
+    end
+    def create_bail_on_first_task
+      desc 'set bail on first error'
+      task :bail_on_first_error do
+        Rake::Task.bail_on_first_error = true
+      end
+    end
 
-    @log.level = logLevel
-    @log.debug "starting..."
-    @base = base
-    @all_tasks = instantiate_tasks(projects, build_dir, toolchain, base)
-  end
+    def create_multitask
+      desc 'set parallelization of multitask'
+      task :multitask, :threads do |t, args|
+        arg = args.threads
+        if arg
+          Rake::application.max_parallel_tasks = arg.to_i
+        end
+      end
+    end
 
-  def instantiate_tasks(project_configs, build_dir, toolchain, base='.')
-    cd base do
-      project_configs.each do |p|
-        abort "project config #{p} cannot be found!" unless File.exists?(p)
+    def create_console_colorization
+      # default is on
+      Cxxproject::ColorizingFormatter.enabled = true
+      desc 'Toggle colorization of console output (use true|t|yes|y|1|on for true ... everything else is false)'
+      task :toggle_colorize, :on_off do |t, args|
+        arg = args[:on_off] || 'false'
+        on_off = arg.match(/(true|t|yes|y|1|on)$/) != nil
+        Cxxproject::ColorizingFormatter.enabled = on_off
       end
     end
-    @log.debug "project_configs: #{project_configs}"
-    register_projects(project_configs)
-    define_project_info_task()
-    @gcc = toolchain
-    task_maker = TaskMaker.new(@log)
-    task_maker.set_loglevel(@log.level);
-    tasks = []
-
-    #todo: sort ALL_BUILDING_BLOCKS (circular deps)
-
-    ALL_BUILDING_BLOCKS.each do |name,block|
-      block.set_tcs(@gcc) unless block.has_tcs?
-      block.set_output_dir(Dir.pwd + "/" + build_dir)
-      rel_projects = project_configs.collect { |p| File.join(base,p) }
-      block.set_config_files(rel_projects)
-      block.complete_init()
+
+    def create_generic_tasks
+      [:lib, :exe, :run, nil].each { |i| create_filter_task_with_namespace(i) }
     end
 
-    ALL_BUILDING_BLOCKS.each do |name,block|
-      @log.debug "creating task for block: #{block.name}/taskname: #{block.get_task_name} (#{block})"
-      t = task_maker.create_tasks_for_building_block(block)
-      if (t != nil)
-        tasks << { :task => t, :name => name }
+    def create_filter_task_with_namespace(basename)
+      if basename
+        desc "invoke #{basename} with filter"
+        namespace basename do
+          create_filter_task("#{basename}:")
+        end
+      else
+        desc 'invoke with filter'
+        create_filter_task('')
       end
     end
-    tasks
-  end
 
-  def register_projects(projects)
-    cd(@base,:verbose => false) do |b|
-      projects.each do |project_file|
-        @log.debug "register project #{project_file}"
-        dirname = File.dirname(project_file)
-        @log.debug "dirname for project was: #{dirname}"
-        cd(dirname,:verbose => false) do | base_dir |
-          @log.debug "current dir: #{`pwd`}, #{base_dir}"
-          loadContext = EvalContext.new
-          loadContext.eval_project(File.read(File.basename(project_file)))
-          loadContext.myblock.call()
-          loadContext.all_blocks.each do |p|
-            p.set_project_dir(Dir.pwd)
-            if p.sources.instance_of?(Rake::FileList)
-              p.set_sources(p.sources.to_a)
+    def create_filter_task(basename)
+      task :filter, :filter do |t, args|
+        filter = ".*"
+        if args[:filter]
+          filter = "#{args[:filter]}"
+        end
+        filter = Regexp.new("#{basename}#{filter}")
+        Rake::Task.tasks.each do |to_check|
+          name = to_check.name
+          if ("#{basename}:filter" != name)
+            match = filter.match(name)
+            if match
+              to_check.invoke
             end
           end
         end
       end
     end
-  end
-  def define_project_info_task
-    desc "shows your defined projects"
-    task :project_info do
-      p "ProjectBase: #{@base}"
-      ALL_BUILDING_BLOCKS.each_value do |bb|
-        pp bb
-      end
-    end
-  end
 
-end
-
-class EvalContext
-
-  attr_accessor :myblock, :all_blocks
+    def instantiate_tasks
+      check_for_project_configs
 
-  def cxx_configuration(&block)
-    @myblock = block
-    @all_blocks = []
-  end
-
-  def eval_project(project_text)
-    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
+      if @log.debug?
+        @log.debug "project_configs:"
+        @projects.each { |c| @log.debug " *  #{c}" }
+      end
+      register_projects()
+      ALL_BUILDING_BLOCKS.values.each do |block|
+        prepare_block(block)
+      end
+      ALL_BUILDING_BLOCKS.values.inject([]) do |memo,block|
+        @log.debug "creating tasks for block: #{block.name}/taskname: #{block.get_task_name} (#{block})"
+        memo << block.convert_to_rake()
+      end
+    end
 
-  def check_hash(hash,allowed)
-    hash.keys.map {|k| raise "#{k} is not a valid specifier!" unless allowed.include?(k) }
-  end
+    def check_for_project_configs
+      cd(@base, :verbose => false) do
+        @projects.each do |p|
+          abort "project config #{p} cannot be found!" unless File.exists?(p)
+        end
+      end
+    end
 
-  def exe(name, hash)
-    raise "not a hash" unless hash.is_a?(Hash)
-    check_hash hash,[:sources,:includes,:dependencies]
-    bblock = Executable.new(name)
-    bblock.set_sources(hash[:sources]) if hash.has_key?(:sources)
-    bblock.set_includes(hash[:includes]) if hash.has_key?(:includes)
-    bblock.set_dependencies(hash[:dependencies]) if hash.has_key?(:dependencies)
+    def prepare_block(block)
+      block.set_tcs(@toolchain) unless block.has_tcs?
+      block.set_output_dir(Dir.pwd + "/" + @build_dir)
+      block.complete_init()
+    end
 
-    if OS.linux?
-      bblock.set_lib_searchpaths(["/usr/local/lib","/usr/lib"])
-    else
-      bblock.set_lib_searchpaths(["C:/tool/cygwin/lib"])
+    def register_projects()
+      cd(@base,:verbose => false) do |b|
+        @projects.each_with_index do |project_file, i|
+          @log.debug "register project #{project_file}"
+          dirname = File.dirname(project_file)
+          @log.debug "dirname for project was: #{dirname}"
+          cd(dirname,:verbose => false) do | base_dir |
+            @log.debug "register project #{project_file} from within directory: #{Dir.pwd}"
+            eval_file(b, File.basename(project_file))
+          end
+        end
+      end
     end
-    all_blocks << bblock
-  end
+    def eval_file(b, project_file)
+      loadContext = EvalContext.new
+      begin
+        loadContext.eval_project(File.read(File.basename(project_file)), project_file, Dir.pwd)
+      rescue Exception => e
+        puts "problems with #{File.join(b, project_file)} in dir: #{Dir.pwd}"
+        raise e
+      end
+      begin
+        loadContext.myblock.call()
+      rescue Exception => e
+        error_string = "error while evaluating \"#{Dir.pwd}/#{project_file}\""
+        puts error_string
+        raise e
+      end
 
-  def source_lib(name, hash)
-    raise "not a hash" unless hash.is_a?(Hash)
-    check_hash hash,[:sources,:includes,:dependencies,:toolchain]
-    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)
-    bblock.set_dependencies(hash[:dependencies]) if hash.has_key?(:dependencies)
-    all_blocks << bblock
-  end
+      loadContext.all_blocks.each do |block|
+        block.
+          set_project_dir(Dir.pwd).
+          set_config_files([Dir.pwd + "/" + project_file])
+        if block.respond_to?(:sources) && block.sources.instance_of?(Rake::FileList)
+          block.set_sources(block.sources.to_a)
+        end
+      end
+    end
+    def define_project_info_task
+      desc "shows your defined projects"
+      task :project_info do
+        p "ProjectBase: #{@base}"
+        ALL_BUILDING_BLOCKS.each_value do |bb|
+          pp bb
+        end
+      end
+    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
-
 end

data/lib/cxxproject/utils/cleanup.rb

@@ -0,0 +1,20 @@
+require 'rake'
+require 'rake/clean'
+require 'cxxproject/ext/filelist'
+
+module Cxxproject
+  module Utils
+
+    def self.cleanup_rake()
+      ALL_BUILDING_BLOCKS.clear
+      Rake.application.clear
+      Rake.application.idei.set_abort(false)
+      CLEAN.pending_add.clear
+      CLEAN.items.clear
+      task :clean do
+        CLEAN.each { |fn| rm_r fn rescue nil }
+      end
+    end
+
+  end
+end

data/lib/cxxproject/utils/console.rb

@@ -0,0 +1,6 @@
+desc 'start a rake console'
+task :console do
+  require 'irb'
+  ARGV.clear
+  IRB.start
+end

data/lib/cxxproject/utils/exit_helper.rb

@@ -0,0 +1,40 @@
+module Cxxproject
+  class ExitHelperException < StandardError
+  end
+
+  class ExitHelper
+    @@exit_code = 0
+    @@exit_test = false
+    
+    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.enable_exit_test()
+      @@exit_test = true
+    end    
+    
+    def self.disable_exit_test()
+      @@exit_test = false
+    end
+        
+    def self.exit(val)
+      raise ExitHelperException.new if @@exit_test
+      @@exit_code = val
+      Kernel::exit
+    end
+
+  end
+end
+
+at_exit do
+  exit(Cxxproject::ExitHelper.exit_code)
+end

data/lib/cxxproject/utils/graphstream.rb

@@ -0,0 +1,154 @@
+module Cxxproject
+  module Utils
+    define_graphstream = lambda do
+      require 'socket'
+      require 'thread'
+
+      class GraphStream
+        def initialize
+          begin
+            @server = TCPSocket.open('localhost', 31217)
+            @queue = Queue.new
+            Thread.new do
+              while true
+                command = @queue.pop
+                @server.puts(command)
+              end
+            end
+          rescue Exception => bang
+            puts bang
+          end
+        end
+        def send(command)
+          @queue << command
+        end
+
+        def clear
+          send('Clear()')
+        end
+
+        def set_stylesheet(s)
+          send("SetStylesheet(#{s})")
+        end
+        def add_vertex(id)
+          send("AddVertex(#{id})")
+        end
+        def add_edge(from, to)
+          send("AddEdge(#{from},#{to})")
+        end
+        def set_class(id, clazz)
+          send("SetClass(#{id},#{clazz})")
+        end
+      end
+
+      class GraphStreamSupport
+
+        def object?(name)
+          name.match(/.*\.o\Z/) != nil
+        end
+
+        def exe?(name)
+          name.match(/.*\.exe\Z/) != nil
+        end
+        def library?(name)
+          name.match(/.*\.a\Z/) != nil
+        end
+        def multitask?(name)
+          name.index("Objects of") == 0
+        end
+        def interesting?(name)
+          exe?(name) || object?(name) || library?(name) || multitask?(name)
+        end
+
+        def initialize(gs)
+          @gs = gs
+
+          @interesting_tasks = Rake::Task.tasks.select { |i| interesting?(i.name) }
+          create_vertices
+          create_edges
+
+          @vertices.each do |name, task|
+            set_attributes(name, task)
+          end
+
+        end
+
+        def create_vertices
+          @vertices = {}
+          @interesting_tasks.each do |task|
+            @vertices[task.name] = task
+            @gs.add_vertex(task.name)
+          end
+        end
+
+        def create_edges
+          @interesting_tasks.each do |task|
+            from = task.name
+            task.prerequisites.each do |to|
+              @gs.add_edge(from, to)
+            end
+          end
+        end
+
+        def set_attributes(name, task)
+          @gs.set_class(name, state2color(task))
+        end
+
+        def state2color(t)
+          begin
+            if t.dirty?
+              return 'dirty'
+            else
+              return 'ready'
+            end
+          rescue StandardError => bang
+            puts bang
+            return '#ff00ff'
+          end
+        end
+
+        def update(name, color)
+          @gs.set_class(name, color)
+        end
+
+        def before_prerequisites(name)
+          update(name, 'before_prerequisites')
+        end
+
+        def after_prerequisites(name)
+          update(name, 'after_prerequisites')
+        end
+
+        def before_execute(name)
+          update(name, 'before_execute')
+        end
+
+        def after_execute(name)
+          update(name, 'after_execute')
+        end
+      end
+
+      namespace :graphstream do
+        gs = nil
+        task :init do
+          gs = GraphStream.new
+        end
+
+        desc 'clear graphstream'
+        task :clear => :init do
+          gs.clear
+        end
+
+        desc 'update graphstream'
+        task :update => :init do
+          gs.set_stylesheet('node {fill-color:green;}node.dirty{fill-color:red;}node.before_prerequisites{fill-color:yellow;}node.after_prerequisites{fill-color:orange;}node.before_execute{fill-color:blue;}node.after_execute{fill-color:green;}node.ready{fill-color:yellow;}')
+          require 'cxxproject/ext/rake_listener'
+          require 'cxxproject/ext/rake_dirty'
+          Rake::add_listener(GraphStreamSupport.new(gs))
+        end
+      end
+    end
+
+    optional_package(define_graphstream, nil)
+  end
+end

data/lib/cxxproject/utils/optional.rb

@@ -0,0 +1,16 @@
+require 'rake'
+
+module Cxxproject
+  module Utils
+    def self.optional_package(block1, block2)
+      begin
+        block1.call
+      rescue LoadError => e
+        if RakeFileUtils.verbose == true
+          puts e
+        end
+        block2.call if block2
+      end
+    end
+  end
+end

data/lib/cxxproject/utils/printer.rb

@@ -0,0 +1,50 @@
+require 'cxxproject/toolchain/colorizing_formatter'
+
+module Cxxproject
+  
+  class Printer
+    @@cf = ColorizingFormatter.new
+    
+    def self.printInfo(str)
+      if @@cf.enabled?
+        puts @@cf.printInfo(str)
+      else
+        puts str
+      end
+    end
+    
+    def self.printAdditionalInfo(str)
+      if @@cf.enabled?
+        puts @@cf.printAdditionalInfo(str)
+      else
+        puts str
+      end
+    end
+    
+    def self.printWarning(str)
+      if @@cf.enabled?
+        puts @@cf.printWarning(str)
+      else
+        puts str
+      end
+    end
+
+    def self.printError(str)
+      if @@cf.enabled?
+        puts @@cf.printError(str)
+      else
+        puts str
+      end
+    end
+
+    def self.printSuccess(str)
+      if @@cf.enabled?
+        puts @@cf.printSuccess(str)
+      else
+        puts str
+      end
+    end
+   
+  end
+  
+end

data/lib/cxxproject/utils/process.rb

@@ -0,0 +1,53 @@
+module Cxxproject
+
+  class ProcessHelper
+    @@pid = nil
+
+    def self.readOutput(sp, rd, wr)
+      wr.close
+        
+      consoleOutput = ""
+      begin
+        while not rd.eof? 
+           tmp = rd.read(1000)
+           if (tmp != nil)
+             consoleOutput << tmp
+           end  
+        end
+      rescue Exception=>e
+        # Seems to be a bug in ruby: sometimes there is a bad file descriptor on Windows instead of eof, which causes
+        # an exception on read(). However, this happens not before everything is read, so there is no practical difference
+        # how to "break" the loop.
+        # This problem occurs on Windows command shell and Cygwin.
+      end
+        
+      Process.wait(sp)
+      rd.close
+      
+      # seems that pipe cannot handle non-ascii characters right on windows (even with correct encoding)  
+      consoleOutput.gsub!(/\xE2\x80\x98/,"`") # ���
+      consoleOutput.gsub!(/\xE2\x80\x99/,"'") # ���
+      
+      consoleOutput
+    end
+
+    def self.spawnProcess(cmdLine)
+      return system cmdLine if Cxxproject::Utils.old_ruby?
+      
+      @@pid = spawn(cmdLine)
+      pid, status = Process.wait2(@@pid)
+      @@pid = nil
+      status.success? 
+    end
+
+    def self.killProcess
+      begin
+        Process.kill("KILL",@@pid)
+      rescue
+      end
+      @@pid = nil
+    end
+    
+  end
+
+end