cxxproject 0.4.6 → 0.5.47

data/lib/cxxproject/ext/rake.rb

@@ -0,0 +1,397 @@
+require 'cxxproject/ext/stdout'
+require 'cxxproject/utils/exit_helper'
+require 'cxxproject/errorparser/error_parser'
+
+
+require 'rake'
+require 'stringio'
+require 'thread'
+
+require 'cxxproject/utils/printer'
+
+module Cxxproject
+  class SystemCommandFailed < Exception
+  end
+end
+
+module Rake
+
+  class Application
+    attr_writer :max_parallel_tasks
+    attr_writer :check_unnecessary_includes
+    attr_writer :deriveIncludes
+    attr_writer :consoleOutput_fullnames
+    def max_parallel_tasks
+      @max_parallel_tasks ||= 8
+    end
+    
+    def check_unnecessary_includes
+      @check_unnecessary_includes ||= false
+    end
+
+    def idei
+      @idei ||= Cxxproject::IDEInterface.new
+    end
+
+    def idei=(value)
+      @idei = value
+    end
+
+    def command_line_number
+      @command_line_number ||= 1
+      res = @command_line_number
+      @command_line_number += 1
+      res
+    end
+    
+    def makefile_number
+      @makefile_number ||= 1
+      res = @makefile_number
+      @makefile_number += 1
+      res
+    end
+    
+    def deriveIncludes
+      @deriveIncludes ||= false
+    end
+
+    def consoleOutput_fullnames
+      @consoleOutput_fullnames ||= false
+    end
+    
+  end
+
+  class Jobs
+    def initialize(jobs, max, &block)
+      nr_of_threads = [max, jobs.length].min
+      @jobs = jobs
+      @threads = []
+      nr_of_threads.times do
+        @threads << Thread.new do
+          block.call(self)
+        end
+      end
+    end
+
+    def get_next_or_nil
+      the_next = nil
+      mutex.synchronize {
+        the_next = @jobs.shift
+      }
+      the_next
+    end
+    def join
+      @threads.each{|t| while not t.join(2) do end}
+    end
+    def mutex
+      @mutex ||= Mutex.new
+    end
+  end
+
+  #############
+  # - Limit parallel tasks
+  #############
+  class MultiTask < Task
+    def set_building_block(bb)
+      @bb = bb
+    end
+    
+    def invoke_prerequisites(args, invocation_chain)
+      super(args, invocation_chain)
+
+      return if @failure # pre step has failed
+
+      Dir.chdir(@bb.project_dir) do
+        if Dir.pwd != @bb.project_dir and File.dirname(Dir.pwd) != File.dirname(@bb.project_dir)
+          isSym = false
+          begin
+            isSym = File.symlink?(@bb.project_dir)
+          rescue
+          end
+          if isSym
+            message = "Symlinks only allowed with the same parent dir as the target: #{@bb.project_dir} --> #{Dir.pwd}"
+            res = Cxxproject::ErrorDesc.new
+            res.file_name = @bb.project_dir
+            res.line_number = 0
+            res.severity = Cxxproject::ErrorParser::SEVERITY_ERROR
+            res.message = message
+            Rake.application.idei.set_errors([res])
+            Cxxproject::Printer.printError message
+            set_failed
+            return
+          end
+        end
+      
+        file_tasks = @bb.create_object_file_tasks
+        
+        if file_tasks == nil # = error
+          set_failed
+          return
+        end
+        
+        enhance(file_tasks)
+        return if file_tasks.length == 0
+        
+        @error_strings = {}
+        
+        Jobs.new(file_tasks, application.max_parallel_tasks) do |jobs|
+          handle_jobs(jobs, args, invocation_chain)
+        end.join
+        
+        # can only happen in case of bail_on_first_error.
+        # if not sorted, it may be confusing when builing more than once and the order of the error appearances changes from build to build
+        # (it is not deterministic which file compilation finishes first)
+        @error_strings.sort.each {|es| puts es[1]} 
+      
+        if Rake.application.check_unnecessary_includes
+          if not @failure # otherwise the dependency files might be incorrect or not complete
+            @bb.incArray.each do |i|
+              next if i=="."
+              if not @bb.deps_in_depFiles.any? { |d| d.index(i) == 0 }
+                msg = "Info: Include to #{i} seems to be unnecessary"
+                Cxxproject::Printer.printInfo msg
+                res = Cxxproject::ErrorDesc.new
+                res.file_name = @project_dir
+                res.line_number = 0
+                res.severity = Cxxproject::ErrorParser::SEVERITY_INFO
+                res.message = msg
+                Rake.application.idei.set_errors([res])              
+              end
+            end
+          end
+        end
+      
+      end
+      
+      
+    end
+
+    def handle_jobs(jobs, args, invocation_chain)
+      while true do
+        job = jobs.get_next_or_nil
+        break unless job
+
+        prereq = application[job]
+        prereq.output_after_execute = false
+        prereq.invoke_with_call_chain(args, invocation_chain)
+        set_failed if prereq.failure
+        output(prereq, prereq.output_string)
+      end
+    end
+
+    def output(prereq, to_output)
+      return if Rake::Task.output_disabled
+      return unless output_after_execute
+
+      mutex.synchronize do
+        if to_output and to_output.length > 0
+          if Rake::Task.bail_on_first_error and prereq and prereq.failure
+            @error_strings[prereq.name] = to_output
+          else
+            puts to_output
+          end
+        end
+      end
+    end
+
+    def mutex
+      @mutex ||= Mutex.new
+    end
+
+  end
+
+  class Task
+    class << self
+      attr_accessor :bail_on_first_error
+      attr_accessor :output_disabled
+    end
+
+    attr_accessor :failure # specified if that task has failed
+    attr_accessor :deps # used to store deps by depfile task for the apply task (no re-read of depsfile)
+    attr_accessor :type
+    attr_accessor :transparent_timestamp
+    attr_accessor :progress_count
+    attr_accessor :output_string
+    attr_accessor :output_after_execute
+    attr_accessor :immediate_output
+
+    UNKNOWN     = 0x0000 #
+    OBJECT      = 0x0001 #
+    SOURCEMULTI = 0x0002 # x
+    DEPFILE     = 0x0004 #
+    LIBRARY     = 0x0008 # x
+    EXECUTABLE  = 0x0010 # x
+    CONFIG      = 0x0020 #
+    APPLY       = 0x0040 #
+    UTIL        = 0x0080 #
+    BINARY      = 0x0100 # x
+    MODULE      = 0x0200 # x
+    MAKE        = 0x0400 # x
+    RUN         = 0x0800 #
+    CUSTOM      = 0x1000 # x
+    COMMANDLINE = 0x2000 # x
+
+    STANDARD    = 0x371A # x above means included in STANDARD
+    attr_reader :ignore
+    execute_org = self.instance_method(:execute)
+    initialize_org = self.instance_method(:initialize)
+    timestamp_org = self.instance_method(:timestamp)
+    invoke_prerequisites_org = self.instance_method(:invoke_prerequisites)
+    invoke_org = self.instance_method(:invoke)
+
+    define_method(:initialize) do |task_name, app|
+      initialize_org.bind(self).call(task_name, app)
+      @type = UNKNOWN
+      @deps = nil
+      @transparent_timestamp = false
+      @progress_count = 0
+      @ignore = false
+      @failure = false
+      @output_after_execute = true
+      @immediate_output = false
+    end
+
+    define_method(:invoke) do |*args|
+      Cxxproject::ExitHelper.set_exit_code(0)
+      invoke_org.bind(self).call(*args)
+      if @failure or Rake.application.idei.get_abort
+        Cxxproject::ExitHelper.set_exit_code(1)
+      end
+    end
+
+    define_method(:invoke_prerequisites) do |task_args, invocation_chain|
+      new_invoke_prerequisites(task_args, invocation_chain)
+    end
+
+    def new_invoke_prerequisites(task_args, invocation_chain)
+      orgLength = 0
+      while @prerequisites.length > orgLength do
+        orgLength = @prerequisites.length
+
+        @prerequisites.dup.each do |n| # dup needed when apply tasks changes that array
+          break if Rake.application.idei.get_abort
+          #break if @failure
+
+          prereq = nil
+          begin
+            prereq = application[n, @scope]
+            prereq_args = task_args.new_scope(prereq.arg_names)
+            prereq.invoke_with_call_chain(prereq_args, invocation_chain)
+            set_failed if prereq.failure
+          rescue Cxxproject::ExitHelperException
+            raise
+          rescue Exception => e
+            if prereq and Rake::Task[n].ignore
+              @prerequisites.delete(n)
+              def self.needed?
+                true
+              end
+              return
+            end
+            Cxxproject::Printer.printError "Error #{name}: #{e.message}"
+            if RakeFileUtils.verbose
+              puts e.backtrace
+            end            
+            set_failed
+          end
+
+        end
+      end
+    end
+
+    def set_failed()
+      @failure = true
+      if Rake::Task.bail_on_first_error
+        Rake.application.idei.set_abort(true)
+      end
+    end
+
+    define_method(:execute) do |arg|
+      break if @failure # check if a prereq has failed
+      break if Rake.application.idei.get_abort
+      new_execute(execute_org, arg)
+    end
+
+    def new_execute(execute_org, arg)
+      if not @immediate_output
+        s = name == 'console' ? nil : StringIO.new
+        tmp = Thread.current[:stdout]
+        Thread.current[:stdout] = s unless tmp
+      end
+
+      begin
+        execute_org.bind(self).call(arg)
+      rescue Cxxproject::ExitHelperException
+        raise
+      rescue Cxxproject::SystemCommandFailed => scf
+        handle_error(scf, true)
+      rescue SystemExit => exSys
+        Rake.application.idei.set_abort(true)
+      rescue Exception => ex1
+        handle_error(ex1, false)
+      end
+      
+      if not @immediate_output
+        self.output_string = s.string
+        Thread.current[:stdout] = tmp
+        output(nil, self.output_string)
+      end
+    end
+
+    def handle_error(ex1, isSysCmd)
+      if not Rake.application.idei.get_abort()
+        if not isSysCmd
+          Cxxproject::Printer.printError "Error for task #{@name}: #{ex1.message}"
+        end
+      end
+      begin
+        FileUtils.rm(@name) if File.exists?(@name)
+      rescue Exception => ex2
+        Cxxproject::Printer.printError "Error: Could not delete #{@name}: #{ex2.message}"
+      end
+      set_failed
+    end
+
+    def output(name, to_output)
+      return if Rake::Task.output_disabled
+      return unless output_after_execute
+
+      if to_output and to_output.length > 0
+        puts to_output
+      end
+    end
+
+    reenable_org = self.instance_method(:reenable)
+    define_method(:reenable) do
+      reenable_org.bind(self).call
+      @failure = false
+    end
+
+    define_method(:timestamp) do
+      if @transparent_timestamp
+        ts = Rake::EARLY
+        @prerequisites.each do |pre|
+          prereq_timestamp = Rake.application[pre].timestamp
+          ts = prereq_timestamp if prereq_timestamp > ts
+        end
+      else
+        ts = timestamp_org.bind(self).call()
+      end
+      ts
+    end
+
+    def ignore_missing_file
+      @ignore = true
+    end
+
+    def visit(&block)
+      if block.call(self)
+        prerequisite_tasks.each do |t|
+          t.visit(&block)
+        end
+      end
+    end
+
+  end
+
+end

data/lib/cxxproject/{extensions/rake_listener_ext.rb → ext/rake_listener.rb}

@@ -4,47 +4,53 @@ module Rake
 
   def self.add_listener(l)
     get_listener() << l
-    puts "add->" + @@listener.inspect
   end
 
   def self.get_listener
-    @@listener ||= []
+    @listener ||= []
   end
+
   def self.remove_listener(l)
     get_listener().delete(l)
-    puts "remove->" + @@listener.inspect
+  end
+
+  def self.notify_listener(symbol, name)
+    Rake::get_listener().each do |l|
+      if l.respond_to?(symbol)
+        l.send(symbol, name)
+      end
+    end
   end
 
   class MultiTask
     invoke_prerequisites_original = self.instance_method(:invoke_prerequisites)
     define_method(:invoke_prerequisites) do |task_args, invocation_chain|
-      Rake::get_listener().each {|l|l.before_prerequisites(name)}
+      Rake::notify_listener(:before_prerequisites, name)
       invoke_prerequisites_original.bind(self).call(task_args, invocation_chain)
-      Rake::get_listener().each {|l|l.after_prerequisites(name)}
+      Rake::notify_listener(:after_prerequisites, name)
       if !needed?
-        Rake::get_listener().each{|l|l.after_execute(name)}
+        Rake::notify_listener(:after_execute, name)
       end
     end
   end
 
   class Task
-
     invoke_prerequisites_original = self.instance_method(:invoke_prerequisites)
     execute_original = self.instance_method(:execute)
 
     define_method (:invoke_prerequisites) do |task_args, invocation_chain|
-      Rake::get_listener().each {|l|l.before_prerequisites(name)}
+      Rake::notify_listener(:before_prerequisites, name)
       invoke_prerequisites_original.bind(self).call(task_args, invocation_chain)
-      Rake::get_listener().each {|l|l.after_prerequisites(name)}
+      Rake::notify_listener(:after_prerequisites, name)
       if !needed?
-        Rake::get_listener().each{|l|l.after_execute(name)}
+        Rake::notify_listener(:after_execute, name)
       end
     end
 
     define_method(:execute) do |args|
-      Rake::get_listener.each {|l|l.before_execute(name)}
+      Rake::notify_listener(:before_execute, name)
       execute_original.bind(self).call(args)
-      Rake::get_listener.each {|l|l.after_execute(name)}
+      Rake::notify_listener(:after_execute, name)
     end
 
   end

data/lib/cxxproject/ext/stdout.rb

@@ -0,0 +1,44 @@
+require 'stringio'
+
+class ThreadOut
+
+  def initialize(out)
+    @out = out
+  end
+
+  def write(stuff='')
+    if Thread.current[:stdout] then
+      Thread.current[:stdout].write stuff
+    else
+      @out.write stuff
+    end
+  end
+
+  def puts(stuff='')
+    if Thread.current[:stdout] then
+      Thread.current[:stdout].puts stuff
+    else
+      @out.puts stuff
+    end
+  end
+  def print(stuff='')
+    if Thread.current[:stdout] then
+      Thread.current[:stdout].puts stuff
+    else
+      @out.print stuff
+    end
+  end
+
+  def flush
+    if Thread.current[:stdout] then
+      Thread.current[:stdout].flush
+    else
+      @out.flush
+    end
+  end
+end
+
+STDOUT.sync = true
+STDERR.sync = true
+$stdout = ThreadOut.new(STDOUT)
+$stderr = ThreadOut.new(STDERR)

data/lib/cxxproject/ide_interface.rb

@@ -0,0 +1,181 @@
+require 'cxxproject/errorparser/error_parser'
+require 'cxxproject/utils/printer'
+require 'thread'
+
+module Cxxproject
+
+  # header of tcp msg from lake to eclipse:
+  # 1 byte = type (problem = 0x01)
+  # 4 bytes = length of msg
+
+  # payload of problem type:
+  # 4 bytes = length filename
+  # x bytes = filename
+  # 4 bytes = linenumber
+  # 1 byte = severity (0..2)
+  # rest    = error msg
+  class IDEInterface < ErrorParser
+
+    def initialize()
+      @socket = nil
+      @abort = false
+      @thread = nil
+    end
+
+    def mutex
+      @mutex ||= Mutex.new
+    end
+
+    def connect(port)
+      begin
+        @socket = TCPSocket.new('localhost', port)
+
+        @thread = Thread.new do
+          begin
+            @socket.recv(1)
+            set_abort(true)
+          rescue Exception => e
+          end
+        end
+        
+      rescue Exception => e
+        Printer.printError "Error: #{e.message}"
+        ExitHelper.exit(1)
+      end
+    end
+
+    def disconnect()
+      if @socket
+        sleep 0.1 # hack to let ruby send all data via streams before closing ... strange .. perhaps this should be synchronized!
+        begin
+          @socket.shutdown
+          @socket.close
+        rescue Exception => e
+          Printer.printError "Error: #{e.message}"
+          ExitHelper.exit(1)
+        end
+        @socket = nil
+      end
+      
+      begin
+        @thread.join if @thread
+      rescue
+      end      
+      @thread = nil
+    end
+
+    def write_long(packet, l)
+      4.times do
+        packet << (l & 0xff)
+        l = l >> 8
+      end
+    end
+
+    def force_encoding(s)
+      s.force_encoding("binary") if s.respond_to?("force_encoding") # for ruby >= 1.9
+    end
+
+    def set_length_in_header(packet)
+      l = packet.length - 5
+      if packet.respond_to?("setbyte")
+        (1..4).each { |i| packet.setbyte(i, (l & 0xFF)); l = l >> 8 } # ruby >= 1.9
+      else
+        (1..4).each { |i| packet[i] = (l & 0xFF); l = l >> 8 } # ruby < 1.9
+      end
+    end
+
+    def write_string(packet, s)
+      write_long(packet, s.length)
+      packet << s
+    end
+
+    def set_errors(error_array)
+      if @socket
+        
+        merged_messages = []
+        last_msg = nil
+        error_array.each do |msg|
+          if msg.file_name.nil?
+            last_msg.message += "\r\n#{msg.message}" if last_msg 
+          else
+            last_msg = msg.dup
+            merged_messages << last_msg
+          end
+        end
+        
+        merged_messages.each do |msg|
+          msg.message.rstrip!  
+          packet = create_error_packet(msg)
+          begin
+            mutex.synchronize { @socket.write(packet) }
+          rescue Exception => e
+            Printer.printError "Error: #{e.message}"            
+            set_abort(true)
+          end
+        end
+        
+      end
+    end
+
+    def create_error_packet(msg)
+      packet = ""
+      [packet, msg.file_name, msg.message].each {|s|force_encoding(s)}
+
+      packet << 1 # error type
+      write_long(packet,0) # length (will be corrected below)
+
+      write_string(packet, msg.file_name)
+      write_long(packet,msg.line_number)
+      packet << (msg.severity & 0xFF)
+      packet << msg.message
+
+      set_length_in_header(packet)
+      packet
+    end
+
+    def set_build_info(name_attr, config_name_attr, num = -1)
+      @num = num if (num >= 0)
+      name = String.new(name_attr)
+      config_name = String.new(config_name_attr)
+    
+      packet = ""
+      [packet, name, config_name].each {|s|force_encoding(s)}
+
+      lname = name.length
+      lconfig = config_name.length
+      lsum = 4 + lname + 4 + lconfig + 4 
+
+      packet << 10 # build info type
+
+      write_long(packet, lsum)
+      write_long(packet, lname)
+      packet << name
+      write_long(packet, lconfig)
+      packet << config_name
+      write_long(packet, num >=0 ? num : 0)
+
+      begin
+        mutex.synchronize { @socket.write(packet) if @socket }
+      rescue Exception => e
+        Printer.printError "Error: #{e.message}"            
+        set_abort(true)
+      end
+      
+    end
+    
+    def get_number_of_projects
+      @num ||= 0
+    end
+
+    def get_abort()
+      @abort
+    end
+
+    def set_abort(value)
+      @abort = value
+      ProcessHelper.killProcess if @abort
+    end
+
+  end
+end
+