cosmos 4.0.3-java

data/lib/cosmos/utilities/low_fragmentation_array.rb

@@ -0,0 +1,19 @@
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+if RUBY_ENGINE == 'ruby' and !ENV['COSMOS_NO_EXT']
+  require 'cosmos/ext/low_fragmentation_array'
+else
+  module Cosmos
+    class LowFragmentationArray < Array
+      # Can't implement low fragmention in native ruby easily
+    end
+  end
+end

data/lib/cosmos/utilities/message_log.rb

@@ -0,0 +1,79 @@
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'cosmos/config/config_parser'
+require 'cosmos/system/system'
+require 'fileutils'
+
+module Cosmos
+
+  # Handles writing message logs to a file
+  class MessageLog
+
+    # @return [String] The name of the message log file. Empty string until the
+    #   write or start methods are called at which point it is set to the
+    #   filename. Retains the last filename even after stop is called.
+    attr_reader :filename
+
+    # @param tool_name [String] The name of the tool creating the message log.
+    #   This will be inserted into the message log file name to help identify it.
+    # @param log_dir [String] The filesystem path to store the message log file.
+    def initialize(tool_name, log_dir = nil)
+      @tool_name = tool_name
+      @log_dir = ConfigParser.handle_nil(log_dir)
+      @log_dir = System.paths['LOGS'] unless @log_dir
+      @filename = ''
+      @file = nil
+      @start_time = nil
+      @mutex = Mutex.new
+    end
+
+    # Ensures the log file is opened and ready to write. It then writes the
+    # message to the log and flushes it to force the write.
+    #
+    # @param message [String] Message to write to the log
+    def write(message)
+      @mutex.synchronize do
+        if @file.nil? or @file.closed? or (not File.exist?(@filename))
+          start(false)
+        end
+
+        @file.write(message)
+      end
+    end
+
+    # Closes the message log and marks it read only
+    def stop(take_mutex = true)
+      @mutex.lock if take_mutex
+      if @file and not @file.closed?
+        @file.close
+        Cosmos.set_working_dir do
+          File.chmod(0444, @filename)
+        end
+      end
+      @mutex.unlock if take_mutex
+    end
+
+    # Creates a new message log and sets the filename
+    def start(take_mutex = true)
+      @mutex.lock if take_mutex
+      # Prevent starting files too fast
+      sleep(0.1) until !File.exist?(File.join(@log_dir, File.build_timestamped_filename([@tool_name, 'messages'])))
+      stop(false)
+      Cosmos.set_working_dir do
+        @filename = File.join(@log_dir, File.build_timestamped_filename([@tool_name, 'messages']))
+        @file = File.open(@filename, 'a')
+      end
+      @mutex.unlock if take_mutex
+    end
+
+  end # class MessageLog
+
+end # module Cosmos

data/lib/cosmos/utilities/quaternion.rb

@@ -0,0 +1,258 @@
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'cosmos/core_ext/matrix'
+
+include Math
+
+module Cosmos
+
+  # A quaternion where q[3] is the scalar component
+  class Quaternion
+
+    # Create a Quaternion given the initial components
+    #
+    # @param array [Array<Float, Float, Float, Float>] Initial values where
+    # the forth value is the scalar
+    # or [Array<Float, Float, Float>] which as an axis of rotation
+    # @param angle [Float] if axis given for array parameter
+    def initialize(array = [0.0, 0.0, 0.0, 0.0], angle = nil)
+      if array.length == 4
+        @data = array.clone
+      elsif array.length == 3 and angle
+        a = 0.5 * angle
+        s = sin(a) / sqrt(array[0]*array[0] + array[1]*array[1] + array[2]*array[2])
+        @data = []
+        @data[0] = array[0] * s
+        @data[1] = array[1] * s
+        @data[2] = array[2] * s
+        @data[3] = cos(a)
+      else
+        raise "Invalid arguments given to Quaternion.new"
+      end
+    end
+
+    # @return [String] The name of the class and the object_id followed by the
+    #   data
+    def to_s
+      "#<Cosmos::Quaternion:0x#{self.object_id.to_s(16)}> #{@data}"
+    end
+
+    # @param index [Integer] Which component to access
+    # @return [Float] The quaternion component
+    def [](index)
+      return data[index]
+    end
+
+    # @param index [Integer] The component to set
+    # @param value [Float] The quaternion component
+    def []=(index, value)
+      @data[index] = value
+    end
+
+    # @return [Array<Float, Float, Float, Float>] The entire quaternion where the
+    # the last element is the scalar
+    def data
+      return @data
+    end
+
+    # @param array [Array<Float, Float, Float, Float>] The entire quaternion
+    # where the the last element is the scalar
+    def data=(array)
+      @data = array
+    end
+
+    # @return [Float] The first element
+    def q0
+      return @data[0]
+    end
+    alias x q0
+
+    # @return [Float] The second element
+    def q1
+      return @data[1]
+    end
+    alias y q1
+
+    # @return [Float] The third element
+    def q2
+      return @data[2]
+    end
+    alias z q2
+
+    # @return [Float] The scalar element
+    def q3
+      return @data[3]
+    end
+    alias w q3
+
+    # @param value [Float] Set the first element
+    def q0=(value)
+      @data[0] = value
+    end
+
+    # @param value [Float] Set the second element
+    def q1=(value)
+      @data[1] = value
+    end
+
+    # @param value [Float] Set the third element
+    def q2=(value)
+      @data[2] = value
+    end
+
+    # @param value [Float] Set the scalar element
+    def q3=(value)
+      @data[3] = value
+    end
+
+    # @param other [Quaternion] Quaternion to multiply with
+    # @return [Quaternion] New quaternion resulting from the muliplication
+    def *(other)
+      q = Quaternion.new()
+
+      q[0] =  (@data[3] * other[0]) - (@data[2] * other[1]) +
+        (@data[1] * other[2]) + (@data[0] * other[3])
+      q[1] =  (@data[2] * other[0]) + (@data[3] * other[1]) -
+        (@data[0] * other[2]) + (@data[1] * other[3])
+      q[2] = -(@data[1] * other[0]) + (@data[0] * other[1]) +
+        (@data[3] * other[2]) + (@data[2] * other[3])
+      q[3] = -(@data[0] * other[0]) - (@data[1] * other[1]) -
+        (@data[2] * other[2]) + (@data[3] * other[3])
+
+      return q
+    end
+    alias qmult *
+
+    # @return [Quaternion] The inverse of the current quaternion
+    def inverse
+      Quaternion.new([-@data[0], -@data[1], -@data[2], @data[3]])
+    end
+    alias inv inverse
+
+    # @return [Quaternion] The normalized version of the current quaternion
+    def normalize
+      t = @data[0]*@data[0] + @data[1]*@data[1] + @data[2]*@data[2] + @data[3]*@data[3]
+      if t > 0.0
+        f = 1.0 / sqrt(t)
+        @data[0] *= f
+        @data[1] *= f
+        @data[2] *= f
+        @data[3] *= f
+      end
+      return self
+    end
+
+    # Rotate a vector using this quaternion
+    #
+    # @param vector [Array<Float, Float Float>] Vector to rotate
+    # @return [Array<Float, Float, Float>] New rotated vector
+    def vecrot(vector)
+      temp_q = self.inverse * (Quaternion.new([vector[0], vector[1], vector[2], 0]) * self)
+      return [temp_q[0], temp_q[1], temp_q[2]]
+    end
+
+    def self.arc(f, t)
+      dot = f[0]*t[0] + f[1]*t[1] + f[2]*t[2]
+      if dot > 0.999999
+        x = 0.0
+        y = 0.0
+        z = 0.0
+        w = 1.0
+      elsif dot < -0.999999
+        if (f.z.abs < f.x.abs) && (f.z.abs < f.y.abs)
+          x = f[0]*f[2] - f[2]*f[1]
+          y = f[2]*f[0] + f[1]*f[2]
+          z = -f[1]*f[1] - f[0]*f[0]
+        elsif f.y.abs < f.x.abs
+          x = f[1]*f[2] - f[0]*f[1]
+          y = f[0]*f[0] + f[2]*f[2]
+          z = -f[2]*f[1] - f[1]*f[0]
+        else
+          x = -f[2]*f[2] - f[1]*f[1]
+          y = f[1]*f[0] - f[0]*f[2]
+          z = f[0]*f[1] + f[2]*f[0]
+        end
+
+        dot = x*x + y*y + z*z
+        div = sqrt(dot)
+        x /= div
+        y /= div
+        z /= div
+        w = 0.0
+      else
+        div = sqrt((dot + 1.0) * 2.0)
+        x = (f[1]*t[2] - f[2]*t[1]) / div
+        y = (f[2]*t[0] - f[0]*t[2]) / div
+        z = (f[0]*t[1] - f[1]*t[0]) / div
+        w = div * 0.5
+      end
+      return Quaternion.new([x,y,z,w])
+    end
+
+    # @param value [Numeric]
+    # @return [Float] The sign of a number as 1.0 = positive, -1.0 = negative
+    def self.signnz(value)
+      if value >= 0.0
+        return 1.0
+      else
+        return -1.0
+      end
+    end
+
+    # Create a quaternion from a direction-cosine matrix (rotation matrix).
+    # Reference Article: J. Spacecraft Vol.13, No.12 Dec.1976 p754
+    #
+    # @param rotation_matrix [Matrix] The rotation matrix
+    # @return [Quaternion] New quaternion resulting from the matrix
+    def self.qfromc(rotation_matrix)
+      tracec = rotation_matrix.trace()
+      p = 1.0 + tracec
+      if p < 0.0
+        p = 0.0
+      end
+      q = Quaternion.new([0.0, 0.0, 0.0, sqrt(p) / 2.0])
+      if q[3] >= 0.1
+        factor = 1.0 / (4.0 * q[3])
+        q[0] = (rotation_matrix[1][2] - rotation_matrix[2][1]) * factor
+        q[1] = (rotation_matrix[2][0] - rotation_matrix[0][2]) * factor
+        q[2] = (rotation_matrix[0][1] - rotation_matrix[1][0]) * factor
+      else # For rotations near 180 degrees
+        q[0] = sqrt(((2.0 * rotation_matrix[0][0]) + 1.0 - tracec) / 4.0)
+        q[1] = sqrt(((2.0 * rotation_matrix[1][1]) + 1.0 - tracec) / 4.0)
+        q[2] = sqrt(((2.0 * rotation_matrix[2][2]) + 1.0 - tracec) / 4.0)
+
+        i = 0
+        if q[1] >= q[i]
+          i = 1
+        end
+        if q[2] >= q[i]
+          i = 2
+        end
+        case i
+        when 0
+          q[0] = q[0].abs * Quaternion.signnz(rotation_matrix[1][2] - rotation_matrix[2][1])
+          q[1] = q[1].abs * Quaternion.signnz((rotation_matrix[1][0] + rotation_matrix[0][1]) * q[0])
+          q[2] = q[2].abs * Quaternion.signnz((rotation_matrix[2][0] + rotation_matrix[0][2]) * q[0])
+        when 1
+          q[1] = q[1].abs * Quaternion.signnz(rotation_matrix[2][0] - rotation_matrix[0][2])
+          q[0] = q[0].abs * Quaternion.signnz((rotation_matrix[1][0] + rotation_matrix[0][1]) * q[1])
+          q[2] = q[2].abs * Quaternion.signnz((rotation_matrix[2][1] + rotation_matrix[1][2]) * q[1])
+        else
+          q[2] = q[2].abs * Quaternion.signnz(rotation_matrix[0][1] - rotation_matrix[1][0])
+          q[0] = q[0].abs * Quaternion.signnz((rotation_matrix[0][2] + rotation_matrix[2][0]) * q[2])
+          q[1] = q[1].abs * Quaternion.signnz((rotation_matrix[1][2] + rotation_matrix[2][1]) * q[2])
+        end
+      end
+
+      return q
+    end
+  end
+end

data/lib/cosmos/utilities/ruby_lex_utils.rb

@@ -0,0 +1,313 @@
+# encoding: ascii-8bit
+
+# Copyright 2014 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is free software; you can modify and/or redistribute it
+# under the terms of the GNU General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+
+require 'irb/ruby-lex'
+require 'stringio'
+
+# Clear the $VERBOSE global since we're overriding methods
+old_verbose = $VERBOSE; $VERBOSE = nil
+class RubyLex
+  if self.method_defined?(:indent)
+    attr_writer :indent
+  else
+    attr_accessor :indent
+  end
+  # @return [Integer] The expression line number. This can differ from the
+  #   actual line number due to white space and Ruby control keywords.
+  attr_accessor :exp_line_no
+
+  # Resets the RubyLex in preparation of parsing a line
+  def reinitialize
+    @seek                      = 0
+    @exp_line_no               = 1
+    @line_no                   = 1
+    @base_char_no              = 0
+    @char_no                   = 0
+    @rests.clear
+    @readed.clear
+    @here_readed.clear
+    @indent                    = 0
+    @indent_stack.clear
+    @lex_state                 = EXPR_BEG
+    @space_seen                = false
+    @here_header               = false
+    @continue                  = false
+    @line                      = ''
+    @skip_space                = false
+    @readed_auto_clean_up      = false
+    @exception_on_syntax_error = true
+    @prompt                    = nil
+  end
+
+  # Monkey patch to fix performance issue caused by call to reverse
+  def get_readed
+    if idx = @readed.rindex("\n")
+      @base_char_no = @readed.size - (idx + 1)
+    else
+      @base_char_no += @readed.size
+    end
+
+    readed = @readed.join("")
+    @readed = []
+    readed
+  end
+
+  # Monkey patch to fix performance issue caused by call to reverse
+  def ungetc(c = nil)
+    if @here_readed.empty?
+      c2 = @readed.pop
+    else
+      c2 = @here_readed.pop
+    end
+    c = c2 unless c
+    @rests.unshift c #c =
+    @seek -= 1
+    if c == "\n"
+      @line_no -= 1
+      if idx = @readed.rindex("\n")
+        @char_no = idx + 1
+      else
+        @char_no = @base_char_no + @readed.size
+      end
+    else
+      @char_no -= 1
+    end
+  end
+end
+$VERBOSE = old_verbose
+
+class RubyLexUtils
+  # Regular expression to detect blank lines
+  BLANK_LINE_REGEX  = /^\s*$/
+  # Regular expression to detect lines containing only 'else'
+  LONELY_ELSE_REGEX = /^\s*else\s*$/
+
+  # Ruby keywords
+  KEYWORD_TOKENS = [RubyToken::TkCLASS,
+                    RubyToken::TkMODULE,
+                    RubyToken::TkDEF,
+                    RubyToken::TkUNDEF,
+                    RubyToken::TkBEGIN,
+                    RubyToken::TkRESCUE,
+                    RubyToken::TkENSURE,
+                    RubyToken::TkEND,
+                    RubyToken::TkIF,
+                    RubyToken::TkUNLESS,
+                    RubyToken::TkTHEN,
+                    RubyToken::TkELSIF,
+                    RubyToken::TkELSE,
+                    RubyToken::TkCASE,
+                    RubyToken::TkWHEN,
+                    RubyToken::TkWHILE,
+                    RubyToken::TkUNTIL,
+                    RubyToken::TkFOR,
+                    RubyToken::TkBREAK,
+                    RubyToken::TkNEXT,
+                    RubyToken::TkREDO,
+                    RubyToken::TkRETRY,
+                    RubyToken::TkIN,
+                    RubyToken::TkDO,
+                    RubyToken::TkRETURN,
+                    RubyToken::TkIF_MOD,
+                    RubyToken::TkUNLESS_MOD,
+                    RubyToken::TkWHILE_MOD,
+                    RubyToken::TkUNTIL_MOD,
+                    RubyToken::TkALIAS,
+                    RubyToken::TklBEGIN,
+                    RubyToken::TklEND,
+                    RubyToken::TkfLBRACE]
+
+  # Ruby keywords which define the beginning of a block: do, {, begin
+  BLOCK_BEGINNING_TOKENS = [RubyToken::TkDO,
+                            RubyToken::TkfLBRACE,
+                            RubyToken::TkBEGIN]
+
+  # Create a new RubyLex and StringIO to hold the text to operate on
+  def initialize
+    @lex    = RubyLex.new
+    @lex_io = StringIO.new('')
+  end
+
+  # @param text [String]
+  # @return [Boolean] Whether the text contains the 'begin' keyword
+  def contains_begin?(text)
+    @lex.reinitialize
+    @lex.exception_on_syntax_error = false
+    @lex_io.string = text
+    @lex.set_input(@lex_io)
+    while token = @lex.token
+      if token.class == RubyToken::TkBEGIN
+        return true
+      end
+    end
+    return false
+  end
+
+  # @param text [String]
+  # @return [Boolean] Whether the text contains a Ruby keyword
+  def contains_keyword?(text)
+    @lex.reinitialize
+    @lex.exception_on_syntax_error = false
+    @lex_io.string = text
+    @lex.set_input(@lex_io)
+    while token = @lex.token
+      if KEYWORD_TOKENS.include?(token.class)
+        return true
+      end
+    end
+    return false
+  end
+
+  # @param text [String]
+  # @return [Boolean] Whether the text contains a keyword which starts a block.
+  #   i.e. 'do', '{', or 'begin'
+  def contains_block_beginning?(text)
+    @lex.reinitialize
+    @lex.exception_on_syntax_error = false
+    @lex_io.string = text
+    @lex.set_input(@lex_io)
+    while token = @lex.token
+      if BLOCK_BEGINNING_TOKENS.include?(token.class)
+        return true
+      end
+    end
+    return false
+  end
+
+  # @param text [String]
+  # @param progress_dialog [Cosmos::ProgressDialog] If this is set, the overall
+  #   progress will be set as the processing progresses
+  # @return [String] The text with all comments removed
+  def remove_comments(text, progress_dialog = nil)
+    comments_removed = text.clone
+    @lex.reinitialize
+    @lex.exception_on_syntax_error = false
+    @lex_io.string = text
+    @lex.set_input(@lex_io)
+    need_remove = nil
+    delete_ranges = []
+    token_count = 0
+    progress = 0.0
+    while token = @lex.token
+      token_count += 1
+      if need_remove
+        delete_ranges << (need_remove..(token.seek - 1))
+        need_remove = nil
+      end
+      if token.class == RubyToken::TkCOMMENT
+        need_remove = token.seek
+      end
+      if progress_dialog and token_count % 10000 == 0
+        progress += 0.01
+        progress = 0.0 if progress >= 0.99
+        progress_dialog.set_overall_progress(progress)
+      end
+    end
+
+    if need_remove
+      delete_ranges << (need_remove..(text.length - 1))
+      need_remove = nil
+    end
+
+    delete_count = 0
+    delete_ranges.reverse_each do |range|
+      delete_count += 1
+      comments_removed[range] = ''
+      if progress_dialog and delete_count % 10000 == 0
+        progress += 0.01
+        progress = 0.0 if progress >= 0.99
+        progress_dialog.set_overall_progress(progress)
+      end
+    end
+
+    return comments_removed
+  end
+
+  # Yields each lexed segment and if the segment is instrumentable
+  #
+  # @param text [String]
+  # @yieldparam line [String] The entire line
+  # @yieldparam instrumentable [Boolean] Whether the line is instrumentable
+  # @yieldparam inside_begin [Integer] The level of indentation
+  # @yieldparam line_no [Integer] The current line number
+  def each_lexed_segment(text)
+    lex = RubyLex.new
+    lex.exception_on_syntax_error = false
+    lex_io = StringIO.new(text)
+    lex.set_input(lex_io)
+
+    while lexed = lex.lex
+      line_no = lex.exp_line_no
+
+      if contains_begin?(lexed)
+        inside_begin = lex.indent - 1
+      end
+
+      if lex.indent == inside_begin
+        inside_begin = nil
+      end
+
+      loop do # loop to allow restarting for nested conditions
+
+        # Yield blank lines and lonely else lines before the actual line
+        while (index = lexed.index("\n"))
+          line = lexed[0..index]
+          if line =~ BLANK_LINE_REGEX
+            yield line, true, inside_begin, line_no
+            line_no += 1
+            lexed = lexed[(index + 1)..-1]
+          elsif line =~ LONELY_ELSE_REGEX
+            yield line, false, inside_begin, line_no
+            line_no += 1
+            lexed = lexed[(index + 1)..-1]
+          else
+            break
+          end
+        end
+
+        if contains_keyword?(lexed)
+          if contains_block_beginning?(lexed)
+            section = ''
+            lexed.each_line do |lexed_part|
+              section << lexed_part
+              if contains_block_beginning?(section)
+                yield section, false, inside_begin, line_no
+                break
+              end
+              line_no += 1
+            end
+            line_no += 1
+            remainder = lexed[(section.length)..-1]
+            lexed = remainder
+            next unless remainder.empty?
+          else
+            yield lexed, false, inside_begin, line_no
+          end
+        else
+          num_left_brackets  = lexed.count('{')
+          num_right_brackets = lexed.count('}')
+          if num_left_brackets != num_right_brackets
+            # Don't instrument lines with unequal numbers of { and } brackets
+            yield lexed, false, inside_begin, line_no
+          else
+            yield lexed, true, inside_begin, line_no
+          end
+        end
+
+        lex.exp_line_no = lex.line_no
+
+        break
+      end # loop do
+
+    end # while lexed
+
+  end # def each_lexed_segment
+
+end