bake-toolkit 1.8.0.1 → 2.0.10

data/lib/common/ext/stdout.rb

@@ -0,0 +1,45 @@
+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/common/ide_interface.rb

@@ -0,0 +1,194 @@
+require 'bake/toolchain/errorparser/error_parser'
+require 'bake/toolchain/colorizing_formatter'
+require 'thread'
+
+module Bake
+
+  # header of tcp msg from bake 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 self.instance
+      @@ide ||= IDEInterface.new
+    end
+    
+
+    def mutex
+      @mutex ||= Mutex.new
+    end
+
+    def connect(port)
+      begin
+        @socket = TCPSocket.new('localhost', port)
+
+        @thread = Thread.new do
+          while true do
+          begin
+            @socket.recv_nonblock(1)
+            set_abort(true)
+            break
+          rescue Errno::EWOULDBLOCK
+            sleep 0.1
+          rescue Errno::EAGAIN
+            sleep 0.1
+          rescue Exception => e
+            break
+          end
+          end
+        end
+
+      rescue Exception => e
+        Bake.formatter.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.close
+        rescue Exception => e
+          Bake.formatter.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.severity != 255
+            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
+        end
+
+        merged_messages.each do |msg|
+          msg.message.rstrip!
+          packet = create_error_packet(msg)
+          begin
+            mutex.synchronize { @socket.write(packet) }
+          rescue Exception => e
+            Bake.formatter.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
+        Bake.formatter.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(false) if @abort
+    end
+
+  end
+end

data/lib/common/options/option.rb

@@ -0,0 +1,13 @@
+module Bake
+
+class Option
+  attr_reader :param, :arg, :block
+  def initialize(param, arg, &f)
+    @param = param
+    @arg = arg # true / false
+    @block = f
+    f
+  end
+end
+
+end

data/lib/common/options/parser.rb

@@ -0,0 +1,59 @@
+require 'bake/toolchain/colorizing_formatter'
+require 'common/exit_helper'
+
+module Bake
+
+  class Parser
+    
+    def initialize(argv)
+      @arguments = {}
+      @argv = argv
+      @default = nil
+    end
+    
+    def add_option(opt)
+      @arguments[opt.param] = opt
+    end
+    
+    def add_default(opt)
+      @default = opt
+    end
+    
+    def parse_internal(ignoreInvalid = true)
+      pos = 0
+      begin
+        while pos < @argv.length do
+          if not @arguments.include?@argv[pos]
+            if @default
+              res = @default.call(@argv[pos])
+              if (not res and not ignoreInvalid)
+                raise "Option #{@argv[pos]} unknown"
+              end
+            end
+          else
+            option = @arguments[@argv[pos]]
+            if option.arg
+              if pos+1 < @argv.length and @argv[pos+1][0] != "-"
+                option.block.call(@argv[pos+1])
+                pos = pos + 1
+              else
+                raise "Argument for option #{@argv[pos]} missing" 
+              end
+            else
+              option.block.call()
+            end
+          end
+          pos = pos + 1
+        end
+      rescue SystemExit => e
+        raise
+      rescue Exception => e
+        Bake.formatter.printError("Error: " + e.message)
+        ExitHelper.exit(1)
+      end
+      
+    end
+  
+  end
+
+end

data/lib/common/process.rb

@@ -0,0 +1,64 @@
+module Bake
+
+  class ProcessHelper
+    @@pid = nil
+    @@rd = nil
+
+    def self.run(cmdLineArray, immediateOutput=false, force=true, outpipe=nil)
+      rd, wr = IO.pipe
+      @@rd = rd if force
+      cmdLineArray << { :err=>wr, :out=>(outpipe ? outpipe : wr) }
+      begin
+        pid = spawn(*cmdLineArray)
+      rescue Exception => e
+        return [false, e.message]
+      end
+      @@pid = pid if force
+      wr.close
+      output = ""
+      begin
+        while not rd.eof?
+          tmp = rd.read(1)
+          if (tmp != nil)
+            tmp.encode!('UTF-8',  :invalid => :replace, :undef => :replace, :replace => '')
+            tmp.encode!('binary', :invalid => :replace, :undef => :replace, :replace => '')
+            output << tmp
+            
+            print tmp if immediateOutput
+          end
+        end
+      rescue
+        # 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
+      
+      begin
+        rd.close
+      rescue
+      end 
+      pid, status = Process.wait2(pid)
+      @@pid = nil
+      @@rd = nil
+      cmdLineArray.pop
+      return [false, output] if status.nil?
+      [status.success?, output]
+    end
+       
+    def self.killProcess(force) # do not kill compile processes or implement rd and pid array if really needed
+      begin
+        @@rd.close
+      rescue Exception => e
+      end
+      begin
+        Process.kill("KILL",@@pid)
+      rescue Exception => e
+      end
+      @@rd = nil
+      @@pid = nil
+    end
+    
+  end
+
+end

data/lib/common/utils.rb

@@ -0,0 +1,52 @@
+module Bake
+  
+  module Utils
+  
+    def self.flagSplit(str, removeQuotes)
+      return [] if str == ""
+      return [str] unless str.include?" "
+      
+      hasQuote = false
+      hasDoubleQuote = false
+      hadQuote = false
+      ar = []
+      s = ""
+  
+      str.split("").each do |i|
+        hasDoubleQuote = !hasDoubleQuote if !hasQuote and i == '"'
+        hasQuote = !hasQuote if !hasDoubleQuote and i == '\''
+        hadQuote = true if hasDoubleQuote
+        if i == ' '
+          if not hasDoubleQuote and not hasQuote
+            if hadQuote and removeQuotes
+              ar << s[1..-2] if s.length > 2
+              hadQuote = false
+            else
+              ar << s if s.length > 0
+            end
+            s = ""
+            next
+          end
+        end
+        s << i
+      end
+      ar << s if s.length > 0
+      ar
+    end  
+  
+    # Simple helper query the operating system we are running in
+    module OS
+
+      # Is it windows
+      def OS.windows?
+        (RUBY_PLATFORM =~ /cygwin|mswin|mingw|bccwin|wince|emx/) != nil
+      end
+
+    end
+
+    def self.deep_copy(x)
+      Marshal.load(Marshal.dump(x))
+    end
+
+  end
+end

data/lib/{bake → common}/version.rb

@@ -1,20 +1,13 @@
-module Cxxproject
+module Bake
   class Version
-    def self.bake
-      "1.8.0.1"
+    def self.number
+      "2.0.10"
     end
   end
     
-  expectedCxx = "0.5.76"
   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