cosmos 3.0.1 → 3.1.0

data/autohotkey/tools/tlm_viewer2.ahk

@@ -1,49 +1,50 @@
-SetWinDelay 500
-SetKeyDelay 10
-
-Sleep 1000
-WinActivate Screen
-Send {Tab}
-Sleep 500
-Send {Enter}
-
-Sleep 2000
-Run ruby.exe %A_ScriptDir%/CmdTlmServer
-Sleep 2000
-Run ruby.exe %A_ScriptDir%/ScriptRunner -w 600 -t 600
-
-WinWaitActive Script
-Send display("INST ADCS"){Enter}
-Send wait 2{Enter}
-Send clear("INST ADCS"){Enter}
-Sleep 500
-Click 400 90
-
-; Allow the script time to run
-Sleep 5000
-
-WinActivate Script
-Send ^q
-Sleep 500
-Send n
-
-; Close down command and telemetry server
-WinActivate Command and Telemetry Server
-Send ^q
-Sleep 500
-Send {Enter}
-
-; Quit Telemetry Viewer
-WinActivate Telemetry
-Sleep 500
-Send ^q
-Sleep 500
-Send y
-
-; Quit Telemetry Viewer
-WinActivate Telemetry
-Sleep 500
-Send ^q
-Sleep 500
-Send y
-
+SetWinDelay 500
+SetKeyDelay 10
+
+Sleep 1000
+WinActivate Screen
+Sleep 2000
+Send {Tab}
+Sleep 500
+Send {Enter}
+
+Sleep 2000
+Run ruby.exe %A_ScriptDir%/CmdTlmServer
+Sleep 2000
+Run ruby.exe %A_ScriptDir%/ScriptRunner -w 600 -t 600
+
+WinWaitActive Script
+Send display("INST ADCS"){Enter}
+Send wait 2{Enter}
+Send clear("INST ADCS"){Enter}
+Sleep 500
+Click 400 90
+
+; Allow the script time to run
+Sleep 5000
+
+WinActivate Script
+Send ^q
+Sleep 500
+Send n
+
+; Close down command and telemetry server
+WinActivate Command and Telemetry Server
+Send ^q
+Sleep 500
+Send {Enter}
+
+; Quit Telemetry Viewer
+WinActivate Telemetry
+Sleep 500
+Send ^q
+Sleep 500
+Send y
+
+; Quit Telemetry Viewer
+WinActivate Telemetry
+Sleep 500
+Send ^q
+Sleep 500
+Send y
+

data/autohotkey/tools/tlm_viewer4.ahk

@@ -1,4 +1,4 @@
-WinWaitActive Error
-Sleep 500
-Send {Enter}
-
+WinWaitActive Error
+Sleep 500
+Send {Enter}
+

data/autohotkey/tools/tlm_viewer5.ahk

@@ -1,20 +1,20 @@
-SetWinDelay 500
-SetKeyDelay 10
-
-Sleep 2000
-Run ruby.exe %A_ScriptDir%/CmdTlmServer
-WinActivate "INST ADCS"
-Sleep 4000
-
-; Close down command and telemetry server
-WinActivate Command and Telemetry Server
-Send ^q
-Sleep 500
-Send {Enter}
-
-; Quit Telemetry Viewer
-WinActivate "INST ADCS"
-Sleep 500
-Click 497 10 ; Close the window
-Sleep 500
-
+SetWinDelay 500
+SetKeyDelay 10
+
+Sleep 2000
+Run ruby.exe %A_ScriptDir%/CmdTlmServer
+WinActivate "INST ADCS"
+Sleep 4000
+
+; Close down command and telemetry server
+WinActivate Command and Telemetry Server
+Send ^q
+Sleep 500
+Send {Enter}
+
+; Quit Telemetry Viewer
+WinActivate "INST ADCS"
+Sleep 2000
+Click 497 10 ; Close the window
+Sleep 500
+

data/bin/cosmos

@@ -1,96 +1,96 @@
-#!/usr/bin/env ruby
-# 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
-
-# This file will handle COSMOS tasks such as instantiating a new project
-
-require 'cosmos'
-require 'fileutils'
-require 'find'
-
-# Prints the usage text for the cosmos executable
-def print_usage
-  puts "Usage:"
-  puts "  cosmos help                   # Displays this information"
-  puts "  cosmos install directory_name # Creates a barebones COSMOS user directory"
-  puts "  cosmos demo directory_name    # Creates a demo COSMOS user directory"
-  puts "  cosmos docs                   # Launches the documentation server"
-  puts ""
-  puts "Other Tools included with COSMOS:"
-  puts "  rubysloc                      # Counts Ruby SLOC recursively"
-  puts "  cstol_converter               # Converts all *.prc files recursively to COSMOS"
-  puts ""
-end
-
-def install(install_type, install_folder)
-  dir_name = ARGV[1]
-  unless dir_name.nil?
-    puts "Attempting COSMOS #{install_type} Installation to: #{dir_name}"
-
-    #Determine if directory exists
-    unless File.directory?(dir_name)
-      #Create Directory
-      FileUtils.makedirs(dir_name, {:verbose => true})
-
-      #Copy files from gem install directory into new project
-      FileUtils.cp_r(File.join(::Cosmos::PATH, install_folder, '.'), dir_name, {:verbose => true})
-
-      puts "Complete"
-    else
-      puts "ERROR: Directory #{dir_name} already exists... aborting"
-    end
-  else
-    puts "ERROR: Directory must be given to install to"
-  end
-end
-
-if not ARGV[0].nil? # argument(s) given
-
-  # Handle each task
-  case ARGV[0].downcase
-  when 'docs'
-    thread = Thread.new do
-      system('yard server --gems')
-    end
-    sleep 3
-    Cosmos.open_in_web_browser('http://localhost:8808/docs/cosmos/frames')
-    thread.join
-
-  when 'install'
-    ####################################
-    # Create a COSMOS barebones user directory
-    ####################################
-    install('', 'install')
-
-  when 'demo'
-    ####################################
-    # Create a COSMOS demo user directory
-    ####################################
-    install('Demo', 'demo')
-
-  when 'help'
-    ####################################
-    # Print Usage
-    ####################################
-
-    print_usage()
-
-  else # Unknown task
-    ####################################
-    # Unknown task
-    ####################################
-
-    puts "Unknown task: #{ARGV[0]}\n"
-    print_usage()
-  end
-
-else # No arguments given
-  print_usage()
-end
+#!/usr/bin/env ruby
+# 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
+
+# This file will handle COSMOS tasks such as instantiating a new project
+
+require 'cosmos'
+require 'fileutils'
+require 'find'
+
+# Prints the usage text for the cosmos executable
+def print_usage
+  puts "Usage:"
+  puts "  cosmos help                   # Displays this information"
+  puts "  cosmos install directory_name # Creates a barebones COSMOS user directory"
+  puts "  cosmos demo directory_name    # Creates a demo COSMOS user directory"
+  puts "  cosmos docs                   # Launches the documentation server"
+  puts ""
+  puts "Other Tools included with COSMOS:"
+  puts "  rubysloc                      # Counts Ruby SLOC recursively"
+  puts "  cstol_converter               # Converts all *.prc files recursively to COSMOS"
+  puts ""
+end
+
+def install(install_type, install_folder)
+  dir_name = ARGV[1]
+  unless dir_name.nil?
+    puts "Attempting COSMOS #{install_type} Installation to: #{dir_name}"
+
+    #Determine if directory exists
+    unless File.directory?(dir_name)
+      #Create Directory
+      FileUtils.makedirs(dir_name, {:verbose => true})
+
+      #Copy files from gem install directory into new project
+      FileUtils.cp_r(File.join(::Cosmos::PATH, install_folder, '.'), dir_name, {:verbose => true})
+
+      puts "Complete"
+    else
+      puts "ERROR: Directory #{dir_name} already exists... aborting"
+    end
+  else
+    puts "ERROR: Directory must be given to install to"
+  end
+end
+
+if not ARGV[0].nil? # argument(s) given
+
+  # Handle each task
+  case ARGV[0].downcase
+  when 'docs'
+    thread = Thread.new do
+      system('yard server --gems')
+    end
+    sleep 3
+    Cosmos.open_in_web_browser('http://localhost:8808/docs/cosmos/frames')
+    thread.join
+
+  when 'install'
+    ####################################
+    # Create a COSMOS barebones user directory
+    ####################################
+    install('', 'install')
+
+  when 'demo'
+    ####################################
+    # Create a COSMOS demo user directory
+    ####################################
+    install('Demo', 'demo')
+
+  when 'help'
+    ####################################
+    # Print Usage
+    ####################################
+
+    print_usage()
+
+  else # Unknown task
+    ####################################
+    # Unknown task
+    ####################################
+
+    puts "Unknown task: #{ARGV[0]}\n"
+    print_usage()
+  end
+
+else # No arguments given
+  print_usage()
+end

data/bin/cstol_converter

@@ -1,1166 +1,1166 @@
-#!/usr/bin/env ruby
-# 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
-
-# This file converts OASIS CSTOL files to COSMOS scripts
-
-require 'cosmos'
-require 'cosmos/script'
-require 'cosmos/system'
-
-# TODO: capitalized string from ask statement may not match expression (gmi.rb:70)
-# TODO: handle V, C other units specifications...
-# TODO: handle unary operators (-1, not - 1) => although Ruby handles this fine
-
-def parse_cmd(words)
-  # Convert the part that's common to all commands
-  str = "cmd(\"" + words[1].upcase + " " + words[2].upcase
-
-  # If it has parameters
-  if words.length == 5
-    str = str + " " + parse_id(words[4], true, false, true, true)
-
-  elsif words.length > 5
-    str = str + " with"
-
-    # Join the rest of the list and remove the commas
-    args = words[4..-1].join(" ").split(",")
-    args.length.times do |i|
-      # Only prepend comma if it is not the first argument pair
-      if i != 0
-        str = str + ","
-      end
-      params = args[i].split(" ")
-
-      str = str + " " + params[0].upcase + " " + parse_id(params[1],true, false, true)
-    end
-  end
-  str = str + "\")"
-end
-
-def parse_cond_operator(op, is_set_tlm = false)
-  str = ""
-  # Convert CSTOL operators into Ruby operators
-  if op.match("/=")
-    str = " != "
-  elsif op.match(">=")
-    str = " >= "
-  elsif op.match("<=")
-    str = " <= "
-  elsif op.match(">")
-    str = " > "
-  elsif op.match("<")
-    str = " < "
-  elsif op.match("=")
-    str = " == "
-    if is_set_tlm
-      str = " = "
-    end
-  elsif op.match(/VS/i)
-    str = " == "
-  end
-  str
-end
-
-def parse_expression(vars, quoted=false, in_eval=false)
-  i=0
-  str = ""
-  finished = false
-  # Make sure there are spaces around the operators
-  if vars.length > 1
-    vars = vars.join(" ")
-  else
-    vars = vars.to_s
-  end
-  vars = vars.gsub("(", " ( ")
-  vars = vars.gsub(")", " ) ")
-  vars = vars.gsub("+", " + ")
-  vars = vars.gsub("-", " - ")
-  vars = vars.gsub("*", " * ")
-  vars = vars.gsub("==", " == ")
-  vars = vars.gsub("/=", " /= ")
-  vars = vars.gsub("<=", " <= ")
-  vars = vars.gsub(">=", " >= ")
-  vars = vars.gsub(";", " ; ")
-  # Add spaces around single character operators (/ < >)
-  offset = 0
-  while((idx = vars.index(/[\/<>][^=]/,offset)) != nil)
-    # Add space before and after operator and increment offset
-    vars = vars.insert(idx," ")
-    vars = vars.insert(idx+2," ")
-    offset = idx + 2
-  end
-  # Add spaces around single = operator (not /=, ==, <=, or >=)
-  offset = 0
-  while((idx = vars.index(/[^\/=<>]=[^=]/,offset)) != nil)
-    # Add space before and after operator and increment offset
-    vars = vars.insert(idx+1," ")
-    vars = vars.insert(idx+3," ")
-    offset = idx + 3
-  end
-
-  # Split the expression on spaces
-  vars = vars.split(" ")
-
-  last = nil
-  while (vars[i] != nil and finished != true)
-    case vars[i].tr('[]"', '')
-    when "("
-      if quoted == false
-        str = str + "("
-      end
-
-    when ")"
-      if quoted == false
-        str = str + ")"
-      end
-
-    when /\bOR\b/i
-      str = str + " || "
-
-    when /\bAND\b/i
-      str = str + " && "
-
-    when /\b\$[0-9]\b/ # $0, $1, etc are function inputs
-      str = str + "inVar" + vars[0][1..-1]
-
-    when /\$/ # $varName
-      str = str + parse_id(vars[i].tr('[]"', ''),quoted,in_eval)
-
-    when /RAW/i
-      if quoted
-        str = str + "tlm_raw('" + parse_tlm_item(vars[i+1..i+2]) + "')"
-      else
-        str = str + "tlm_raw(\"" + parse_tlm_item(vars[i+1..i+2]) + "\")"
-      end
-      i = i + 2
-    when /x#[0-9a-fA-F]+/i # Hex number
-      str = str + parse_id(vars[i].tr('[]"', ''),quoted)
-    when /b#[0-1]+/i # Binary number
-      str = str + parse_id(vars[i].tr('[]"', ''),quoted)
-
-    when /(\AVS\z|=|\/=|>|>=|<|<=)/ # Conditional operator
-      str = str + parse_cond_operator(vars[i])
-    when /(\+|-|\*|\/)/ # Arithmetic operator
-      str = str + " " + vars[i].tr('[]"', '') + " "
-
-    # Verfies Number followed immediately by units
-    when /\dDN\z|\ddn\z|\dDEG\z|\ddeg\z|\dRAD\z|\drad\z|\dV\z|\dA\z|\dv\z|\da\z|\dc\z|\dC\z|\df\z|\dF\z|\dDPS\z|\dM\z|\dMPS\z|\dm\z|\dmps\z/ # Checks for decimal/degrees/volts and amps
-      temp = vars[i].tr('[]"', '')
-      temp = temp.gsub(/DN\z|dn\z|DEG\z|deg\z|RAD\z|rad\z|V\z|A\z|v\z|a\z|c\z|C\z|f\z|F\z|DPS\z|M\z|MPS\z|m\z|mps\z/, '')
-      if temp.match(/[a-zA-Z]/)
-        str = str + parse_id(vars[i].tr('[]"', ''),quoted)
-      else
-        str = str + temp
-      end
-
-    # Verifies units are standalone
-    when last != '=' && /DN\z|dn\z|DEG\z|deg\z|RAD\z|rad\z|V\z|A\z|v\z|a\z|c\z|C\z|f\z|F\z|DPS\z|M\z|MPS\z|m\z|mps\z/ # Checks for decimal/degrees/volts and amps
-      # Verify it is not a target
-      if(vars[i] != nil and $targetList.include?(vars[i].tr('[]"', '').upcase))
-        if quoted
-          str = str + "tlm('" + parse_tlm_item(vars[i..i+1]) + "')"
-        else
-          str = str + "tlm(\"" + parse_tlm_item(vars[i..i+1]) + "\")"
-        end
-        i = i + 1
-      else
-        str = str + parse_id(vars[i].tr('[]"', ''),quoted)
-      end
-    when /[0-9]*:[0-9]*:[0-9]+/ # Timestamp
-      str = str + parse_time(vars[i].tr('[]"', ''))
-
-    when /\dE/ # Floating point
-      temp_number = vars[i].tr('E', '').to_f * 10**vars[i+2].to_f
-      str = str + "#{temp_number}"
-      finished = true
-    when /\d/ # Decimal number
-      str = str + parse_id(vars[i].tr('[]"', ''),quoted)
-
-    when /\w/ # Must stay low on the list to avoid matching other items
-      # Check this keyword against the list of targets
-      if(vars[i] != nil and $targetList.include?(vars[i].tr('[]"', '').upcase))
-        if quoted
-          str = str + "tlm('" + parse_tlm_item(vars[i..i+1]) + "')"
-        else
-          str = str + "tlm(\"" + parse_tlm_item(vars[i..i+1]) + "\")"
-        end
-        i += 1
-
-      # If it is not a target, then it must be a string or other identifier
-      else
-        str = str + parse_id(vars[i].tr('[]"', ''), quoted, false, false, false, false)
-      end
-
-      # Other cases not handled
-      # else
-      #   str = str + " # TODO unsupported: " + vars[i].tr('[]"', '')
-    end # case
-    last = vars[i].tr('[]"', '')
-    i += 1
-  end # while
-  str
-end
-
-def parse_id(id, quoted=false, in_eval=false, in_command=false, in_single_command = false, units = true)
-  str = ""
-  # Remove parentheses
-  if id.index("(") == 0
-    id = id[1..-1]
-  end
-  if id.index(")") == id.length - 1
-    id = id[0..-2]
-  end
-
-  if id.match(/\$\w/) # $varName
-    id[1,1] = id[1,1].downcase
-    if quoted and !in_eval
-      str = "'\#{" + id[1..-1] + "}'"
-    else
-
-      str = id[1..-1]
-    end
-
-  elsif (id.match(/^"/) != nil and
-         id.match(/"$/) != nil) # Starts and ends with a quote
-    if quoted
-      str = "'" + id.upcase[1..-2] + "'"
-    else
-      str = id.upcase
-    end
-
-  elsif id.match(/x#[A-Fa-f0-9]+DN/i) # Hex number with DN
-    str = "0x" + id[2..-3]
-
-  elsif id.match(/x#[0-9a-fA-F]+/i) # Hex number
-    str = "0x" + id[2..-1]
-
-  elsif id.match(/b#[0-1]+DN/i) # Binary number with DN
-    str = "0b" + id[2..-3]
-
-  elsif id.match(/b#[0-1]+/i) # Binary number
-    str = "0b" + id[2..-1]
-
-  elsif id.match(/\d+DN/i) or id.match(/-\d+DN/i)  # Decimal number with DN
-    str = id[0..-3]
-  elsif id.match(/\AVS\z|\Avs\z/)
-    str = str + " == "
-
-  # Verifies extensions with a decimal number followed by a unit
-  elsif units && id.match(/\dDN|\ddn|\dDEG|\ddeg|\dRAD|\drad|\dV|\dA|\dv|\da|\dc|\dC|\df|\dF|\dDPS|\dM\z|\dMPS\z|\dm\z|\dmps\z/)
-    temp = id.gsub(/DN\z|dn\z|DEG\z|deg\z|RAD\z|rad\z|V\z|A\z|v\z|a\z|c\z|C\z|f\z|F\z|DPS\z|M\z|MPS\z|m\z|mps\z/, '')
-    if in_command and temp.match(/[a-zA-Z]/)
-      str = str + "\'" + id.upcase + "\'"
-    # if filtered words still contain letter, then it is not a number
-    elsif temp.match(/[a-zA-Z]/)
-      str = str + id
-    else
-      str = str + temp
-    end
-  elsif id.match(/\dE\+\d/) # Floating point
-    id = id.gsub('+', ' + ')
-    temp_num_arr = id.split(' ')
-    temp_number = temp_num_arr[0].tr('E', '').to_f * 10**temp_num_arr[2].to_f
-    str = str + "#{temp_number}"
-  elsif id.match(/\A\d/) or id.match(/\A-\d/) # starts with Decimal number
-    str = id
-  # Verifies extensions with a decimal number followed by a unit
-  # that is by itself separated by whitespace
-  elsif units && id.match(/\ADN\z|\Adn\z|\ADEG\z|\Adeg\z|\ARAD\z|\Arad\z|\AV\z|\AA\z|\Av\z|\Aa\z|\Ac\z|\AC\z|\Af\z|\AF\z|\ADPS\z|\AM\z|\AMPS\z|\Am\z|\Amps\z/)
-    temp = id.gsub(/DN\z|dn\z|DEG\z|deg\z|RAD\z|rad\z|V\z|A\z|v\z|a\z|c\z|C\z|f\z|F\z|DPS\z|M\z|MPS\z|m\z|mps\z/, '')
-    if in_command
-      str = str + "\'" + id.upcase + "\'"
-    else
-      str = str + temp
-    end
-  elsif id.match(/\w/) # Any other word
-    # If it's quoted still need quotes for comparison
-    if in_single_command
-      str = id.upcase
-    elsif quoted
-      str = "\'" + id.upcase +  "\'"
-    else
-      str = "\"" + id.tr('\\', '').upcase + "\""
-    end
-  else
-    str = id
-  end
-end
-
-def parse_macro(words)
-  # Call the macro with the first parameter as binding
-  str = words[0] + "(binding"
-
-  # Add all arguments in a loop
-  (words.length-1).times do |i|
-    str = str + ", " + parse_id(words[i+1])
-  end
-  str = str + ")"
-end
-
-def parse_time(time)
-  # If this is a timestamp
-  if time.match(/[0-9]*:[0-9]*:[0-9]+/) # Timestamp
-    # Split on colons to separate hours/minutes/seconds
-    tok = time.split(":")
-
-    # If the first two tokens are empty, set to 0 (ex. ::10 is a valid time)
-    if tok[0] == ""
-      tok[0] = "0"
-    end
-    if tok[1] == ""
-      tok[1] = "0"
-    end
-
-    # Compute the number of seconds
-    secs = (3600*tok[0].to_i + 60*tok[1].to_i + tok[2].to_i).to_s
-
-  # Other cases not handled
-  else
-    secs = "# TODO unsupported: " + time
-  end
-end
-
-def parse_tlm_item(tlm)
-  # Remove preceeding parentheses
-  if tlm[0].index("(") == 0
-    tlm[0] = tlm[0][1..-1]
-  end
-
-  # If there are two telemetry items (target and mnemonic)
-  if tlm.length == 2
-    begin
-      str = tlm[0].tr('[]"', '').upcase + " " + Cosmos::System.telemetry.newest_packet(tlm[0].tr('[]"', '').upcase,tlm[1].tr('[]"', '').upcase).packet_name + " " + tlm[1].tr('[]"', '').upcase
-    rescue
-      str = "# TODO unknown TLM: " + tlm.to_s
-    end
-
-  # Other cases not handled
-  else
-    str = "# TODO unsupported: " + tlm.to_s
-  end
-end
-
-def parse_line(full_line, loc_out_file, wait_check_flag=false)
-  line = ""
-  comment = ""
-  str = ""
-
-  # Handle any empty lines
-  if full_line == nil || full_line.strip == ""
-    loc_out_file.puts full_line
-    return
-  end
-
-  # Detemine the location of any comments in this line
-  commentIdx = full_line.index(";")
-
-  # If we found a comment operator
-  if commentIdx != nil
-    # If there's text to pull out before the ;
-    if commentIdx != 0
-      line = full_line[0..(commentIdx-1)].rstrip
-    end
-    # If there's text to pull out after the ;
-    if commentIdx != full_line.length - 1
-      comment = "#" + full_line[(commentIdx+1)..-1]
-    end
-  else
-    # No comment operator so use the entire line
-    line = full_line.rstrip
-  end
-
-  # Determine the number of spaces to indent this line by finding the first
-  # non-whitespace character
-  numSpaces = full_line.index(/\S/)
-  numSpaces.times {str = str + " "}
-
-  # Handle lines with only comments
-  if line == nil or line == ""
-    loc_out_file.puts str + comment
-    return
-  end
-
-  # Redundant substitutions are done for comparators
-  line = line.gsub("==", " == ")
-  line = line.gsub("/=", " /= ")
-  line = line.gsub("<=", " <= ")
-  line = line.gsub(">=", " >= ")
-  line = line.gsub(/(\w)(=)(\w)/, '\1 = \3')
-  line = line.gsub(/(\w)(=)(\d)/, '\1 = \3')
-  line = line.gsub(/(\w)(=)(-)/, ' = -')
-  line = line.gsub(/(\w)(=)(\s)/, '\1 = \3')
-  line = line.gsub(/(\s)(=)(\w)/, '\1 = \3')
-
-  # Split the line into tokens by spaces, if no spaces between equals sign add them
-  words = line.split(" ")
-
-  # Check for old CSTOL labels which have a trailing colon
-  if words[0][-1] == ':'
-    loc_out_file.puts "# #{line}"
-    return
-  end
-
-  # if wait_check flag is activated ensure that the next line is a check otherwise infinite loop
-  if wait_check_flag and words[0].downcase != 'check'
-    return ""
-  end
-
-  case words[0].downcase
-  when "endproc"
-    if $inFunction
-      str += "end\n#{$inFunction}(#{$inFunctionParams.join(',')})" if $inFunction
-      $inFunction = nil
-    end
-
-  when "ask"
-    str = str + parse_id(words[1]) + " = ask(" + words[2]
-    (words.length-3).times do |i|
-      str = str + " " + words[i+3]
-    end
-    str = str + ")"
-
-  when "begin"
-    # Don't need to do anything with this keyword, so exit unless there's
-    # a comment to print
-    if comment == ""
-      return
-    end
-
-  when "check"
-
-    # If the next word starts with the raw keyword
-    if words[1].match(/\A(raw)/i)
-      # If the line contains a colon, parse out the range and use tolerance
-      if line.match(":")
-        vsIdx = line.index("VS")
-        vsIdx = line.index("vs") if vsIdx == nil
-        colIdx = line.index(":")
-        lowRange = line[(vsIdx+2)..(colIdx-1)]
-        highRange = line[(colIdx+1)..-1]
-        str = str + "check_tolerance_raw(\"" + parse_tlm_item(words[2..3]) +
-          "\", ((" + parse_expression([highRange],false) + ") + (" +
-          parse_expression([lowRange],false) +
-          ")) / 2," + " ((" + parse_expression([highRange],false) + ") - (" +
-          parse_expression([lowRange],false) + "))/2)"
-      else
-        if wait_check_flag
-          if @wait_match_string == "\"" + parse_tlm_item(words[2..3]) +
-            parse_cond_operator(words[4]) + parse_expression(words[5..-1],true) + "\""
-            @verify_wait_check = true
-            # exit function with true flag, and skips check statement next parse
-            return " "
-          end
-        end
-        str = str + "check_raw(\"" + parse_tlm_item(words[2..3]) +
-          parse_cond_operator(words[4]) + parse_expression(words[5..-1],true) +
-          "\")"
-      end
-
-    # If the next word starts with a variable indicator
-    elsif words[1].match(/\$/)
-      # If the line contains a colon, make check expression formatted to
-      # check against a defined range
-      if line.match(":")
-        vsIdx = line.index("VS")
-        vsIdx = line.index("vs") if vsIdx == nil
-        colIdx = line.index(":")
-        lowRange = line[(vsIdx+2)..(colIdx-1)]
-        highRange = line[(colIdx+1)..-1]
-        str = str + "check_expression(\"(" +
-          parse_expression([words[1]],true) + " >= (" +
-          parse_expression([lowRange],true) + ")) and (" +
-          parse_expression([words[1]],true) + " <= (" +
-          parse_expression([highRange],true) + "))\")"
-      else
-        str = str + "check_expression(\"" +
-          parse_expression(words[1..-1],true) + "\")"
-      end
-
-    # If the next word doesn't start with raw
-    elsif words[1].match(/\w/)
-      # If the line contains a colon, parse out the range and use tolerance
-      if line.match(":")
-        vsIdx = line.index("VS")
-        vsIdx = line.index("vs") if vsIdx == nil
-        colIdx = line.index(":")
-        lowRange = line[(vsIdx+2)..(colIdx-1)]
-        highRange = line[(colIdx+1)..-1]
-        str = str + "check_tolerance(\"" +
-          parse_tlm_item(words[1..2]) + "\", ((" +
-          parse_expression([highRange],false) + ") + (" +
-          parse_expression([lowRange],false) + ")) / 2, ((" +
-          parse_expression([highRange],false) + ") - (" +
-          parse_expression([lowRange],false) + "))/2)"
-      else
-        if (words[3])
-          # if single integer comparison or variable, just parse single (for negative integer cases)
-          if words.length <= 6
-            if wait_check_flag
-              if @wait_match_string == "\"" + parse_tlm_item(words[1..2]) + parse_cond_operator(words[3]) + parse_id(words[4],true) + "\""
-                @verify_wait_check = true
-                # exit function with true flag, and skips check statement next parse
-                return ""
-              end
-            else
-              str = str + "check(\"" + parse_tlm_item(words[1..2]) +
-                parse_cond_operator(words[3]) + parse_id(words[4],true) +
-                "\")"
-            end
-          else
-            str = str + "check(\"" + parse_tlm_item(words[1..2]) +
-              parse_cond_operator(words[3]) + parse_expression(words[4..-1],true) +
-              "\")"
-          end
-        else
-          str = str + "check(\"" + parse_tlm_item(words[1..2]) +
-            "\")"
-        end
-      end
-    end
-
-  when "cmd"
-    str = str + parse_cmd(words)
-
-  when "set"
-    str = str + parse_cmd(words)
-
-  when "declare"
-    # If the next word is input, ignore the line
-    if words.length >= 2 and words[1].match(/input/i)
-      if $inFunction
-        $inFunctionParams << "\"#{words[4].upcase}\""
-      else
-        str = str + "# SCL Ignored: " + line
-      end
-
-    # If it is a defined enum list, ignore definitions
-    elsif (words.length >= 6 and
-           words[4..-1].join(" ").match(/[A-Z]+\s+[A-Z]+(,\s*[A-Z]+)+/i))
-      str = str + parse_id(words[2]) + " " + words[3] + " " +
-        parse_id(words[4])
-
-    # If it is a defined range (one and only one colon), ignore range
-    elsif (words.length >= 6 and
-           words[4..-1].join(" ").count(":") == 1)
-      str = str + parse_id(words[2]) + " " + words[3] + " " +
-        parse_id(words[4])
-
-    # Parse the expression
-    elsif words.length >= 5
-      str = str + parse_id(words[2]) + " " + words[3] + " " +
-        parse_expression(words[4..-1])
-
-    else
-      str = str + "# TODO unsupported: " + line
-    end
-
-  when "else"
-    # Only an else
-    if words.length == 1
-      str = str + "else"
-
-    # 'Else if' statement
-    elsif words.length >= 2 and words[1].match(/if/i)
-      str = str + "elsif " + parse_expression(words[2..-1])
-
-    # Other cases not handled
-    else
-      str = str + "# TODO unsupported: " + line
-    end
-
-  when "end"
-    # End of an if statement
-    if words[1].match(/if/i)
-      str = str + "end"
-
-    # End of a procedure with arguments
-    elsif words[1].match(/proc/i) && $inFunction
-      str += "end\n#{$inFunction}(#{$inFunctionParams.join(',')})"
-
-    # End of a procedure without arguments
-    elsif words[1].match(/proc/i) && !$inFunction
-      str = str + "# SCL Ignored: " + line
-
-    # End of a loop
-    elsif words[1].match(/loop/i)
-      str = str + "end"
-
-    # End of a macro
-    elsif words[1].match(/macro/i)
-      str = str + "# SCL Ignored: " + line
-
-    # Other cases not handled
-    else
-      str = str + "# TODO unsupported: " + line
-    end
-
-  when "endif"
-    str = str + "end"
-
-  when "escape"
-    str = str + "break"
-
-  when "goto"
-    # Ignore typical goto for skipping the header section
-    if words.length == 2 and words[1].match(/start_here/i)
-      str = str + "# SCL Ignored: " + line
-
-    # Other cases not handled
-    else
-      str = str + "# TODO unsupported: " + line
-    end
-
-  when "if"
-    str = str + "if " + parse_expression(words[1..-1])
-
-  when "let"
-    # If we're assigning a telemetry point
-    if $targetList.include?(words[1].upcase)
-      # If there is no space between the equal sign reparse string
-      str = str + "set_tlm(\"" + parse_tlm_item(words[1..2]) +
-        parse_cond_operator(words[3], true) + parse_id(words[4],true) + "\")"
-    else
-      # there's no spaces between declaration
-      str = str + parse_id(words[1]) + " " + words[2] + " " +
-        parse_expression(words[3..-1])
-    end
-
-  when "lock"
-    # Ignore database commands
-    str = str + "# SCL Ignored: " + line
-
-  when "loop"
-    # TODO not sure if this is wise, for some files the loop is infinite and
-    # there's no exist case
-    if words[1] == nil
-      str = str + "# TODO Possible inifinite loop case check script file" +
-            "\n" + str + "while(true)"
-    else
-      str = str + words[1] + ".times do |i|"
-    end
-
-  when "macro"
-    str = str + ("# SCL Ignored: " + line)
-    $macroName = words[1].upcase
-    $macroNumArgs = 0
-    i = 2
-    while ((nextWord = words[i]) != nil)
-      case nextWord
-        when /\$/
-          $macroNumArgs = $macroNumArgs + 1
-      end
-      i = i + 1
-    end
-
-  when "new_mac"
-    # Ignore OASIS commands
-    str = str + "# SCL Ignored: " + line
-
-  when "new_proc"
-    # Ignore OASIS commands
-    str = str + "# SCL Ignored: " + line
-
-  when "proc"
-    # Process procedures without arguments as scripts
-    if words.length == 2
-      # Set a global so we know how to close this function
-      $inFunction = nil
-
-    # Process procedures with arguments as functions
-    else
-      # Split the list of arguments on commas
-      listWords = words[2..-1].join().split(",")
-
-      # Print the function name and the first argument
-      str = str + "def " + words[1].downcase + "(" + parse_id(listWords[0])
-
-      # Print the remaining arguments preceeded by a separator
-      (listWords.length-1).times do |i|
-        str = str + ", " + parse_id(listWords[i+1])
-      end
-      str = str + ")"
-
-      # Set a global so we know how to close this function
-      $inFunction = words[1].downcase
-      $inFunctionParams = []
-    end
-
-  when "record"
-    # Record messages without a label
-    if words.length == 2 and words[1].match(/messages/i)
-      str = str + "start_logging()\n"
-      numSpaces.times {str = str + " "}
-      str = str + "start_new_server_message_log()"
-
-    # Record message with a label
-    elsif words.length == 3 and words[1].match(/messages/i)
-      str = str + "set_log_label(" + words[2] + ")\n"
-      numSpaces.times {str = str + " "}
-      str = str + "start_logging()\n"
-      numSpaces.times {str = str + " "}
-      str = str + "start_new_server_message_log()"
-
-    # Other cases not handled
-    else
-      str = str + "# TODO unsupported: " + line
-    end
-
-  when "restore"
-    # Ignore database commands
-    str = str + "# SCL Ignored: " + line
-  when "run"
-    temp = words[1..-1].to_s
-    temp = temp.tr(',[]\"', '')
-    # removes the quotes symbol remnants
-    temp = temp.gsub('\\', '')
-    temp = temp.gsub(/\\\z/, '')
-    str = str + "system(\'" + temp + "\')"
-  when "start"
-    # Process procedures without arguments as scripts
-    if words.length == 2
-      str = str + "start(\"" + words[1].downcase + ".rb\")"
-
-    # Process procedures with arguments as functions
-    else
-      # Add the statement to require the function
-      str = str + "require_utility(\"" + words[1].downcase + ".rb\")\n"
-      numSpaces.times {str = str + " "}
-
-      # Split the list of arguments on commas
-      listWords = words[2..-1].join().split(",")
-      listWords.map! do |word|
-        if word.match(/[0-9]*:[0-9]*:[0-9]+/) # Timestamp
-          parse_time(word)
-        else
-          word
-        end
-      end
-
-      # Print the function name and the first argument
-      str = str + words[1].downcase + "(" + parse_id(listWords[0])
-
-      # Print the remaining arguments preceeded by a separator
-      (listWords.length-1).times do |i|
-        str = str + ", " + parse_id(listWords[i+1])
-      end
-      str = str + ")"
-    end
-
-  when "start_here:"
-    # Ignore typical starting point label
-    str = str + "# SCL Ignored: " + line
-
-  when "stop"
-    # Ignore calls to stop logging since COSMOS stops logging with each start
-    str = str + "# SCL Ignored: " + line
-
-  when "unlock"
-    # Ignore database commands
-    str = str + "# SCL Ignored: " + line
-
-  when "update"
-    # Ignore database commands
-    str = str + "# SCL Ignored: " + line
-
-  when "wait"
-    # add a space incase there's no space between or and parantheses
-    line = line.gsub(')or', ') or')
-    words = line.split(' ')
-    # Only a wait
-    if words.length == 1
-      str = str + "wait()"
-
-    # Waiting for length of time
-    elsif words[1].match(/[0-9]*:[0-9]*:[0-9]+/)
-      str = str + "wait(" + parse_time(words[1]) + ")"
-
-    # Waiting for a variable of time
-    elsif words.length == 2 and words[1].match(/\$/)
-      str = str + "wait(" + parse_id(words[1]) + ")"
-
-    # Waiting for an expression [or for a time]
-    elsif words.length > 2 and words[1].match(/\$/)
-      # Get index of 'OR FOR' if it exists by the 'FOR' keyword
-      idx = words.index("FOR")
-      if idx == nil
-        idx = words.index("for")
-      end
-
-      # If there is a timeout
-      if idx != nil
-        str = str + "wait_expression(\"" +
-          parse_expression(words[1..(idx-2)],true) + "\", " +
-          parse_expression([words[idx+1]]) + ")"
-
-      # No timeout given, so insert a default timeout
-      else
-        str = str + "wait_expression(\"" +
-          parse_expression(words[1..-1],true) + "\", " +
-          parse_time("::30") + ")"
-      end
-
-    # If the next word starts with the raw keyword
-    elsif words[1].match(/[\(]*(raw)/i)
-      # Get index of 'OR FOR' if it exists by the 'FOR' keyword
-      idx = words.index("FOR")
-      if idx == nil
-        idx = words.index("for")
-      end
-
-      # If there is a timeout
-      if idx != nil
-        # If the first part is a complex expression
-        if (words[1..(idx-2)].include?("OR") ||
-            words[1..(idx-2)].include?("or") ||
-            words[1..(idx-2)].include?("AND") ||
-            words[1..(idx-2)].include?("and"))
-          str = str + "wait_expression(\"" +
-            parse_expression(words[1..(idx-2)],true) + "\", "
-
-        # If it is a single telemetry item
-        else
-          @wait_match_string = "\"" + parse_tlm_item(words[2..3]) +
-              parse_cond_operator(words[4]) +
-              parse_expression(words[5..(idx-2)],true) + "\""
-          @verify_wait_check = false
-
-          parse_line(@data_by_lines[@universal_index+1], @out_file, true)
-
-          if @verify_wait_check == true
-            str = str + "wait_check_raw(\"" + parse_tlm_item(words[2..3]) +
-              parse_cond_operator(words[4]) +
-              parse_expression(words[5..(idx-2)],true) + "\", "
-          else
-            str = str + "wait_raw(\"" + parse_tlm_item(words[2..3]) +
-              parse_cond_operator(words[4]) +
-              parse_expression(words[5..(idx-2)],true) + "\", "
-          end
-        end
-
-        # Parse the timeout
-        str = str + parse_expression([words[idx+1]])
-
-      # If there is no timeout given
-      else
-        # If it is a complex expression
-        if (words[1..-1].include?("OR")  || words[1..-1].include?("or") ||
-            words[1..-1].include?("AND") || words[1..-1].include?("and"))
-          str = str + "wait_expression(\"" +
-            parse_expression(words[1..-1],true) + "\", "
-
-        # If it is a single telemetry item
-        else
-          @wait_match_string = "\"" + parse_tlm_item(words[2..3]) +
-            parse_cond_operator(words[4]) + parse_id(words[5],true) + "\""
-          @verify_wait_check = false
-
-          parse_line(@data_by_lines[@universal_index+1], @out_file, true)
-
-          if @verify_wait_check == true
-            str = str + "wait_check_raw(\"" + parse_tlm_item(words[2..3]) +
-            parse_cond_operator(words[4]) + parse_id(words[5],true) + "\", "
-          else
-            str = str + "wait_raw(\"" + parse_tlm_item(words[2..3]) +
-            parse_cond_operator(words[4]) + parse_id(words[5],true) + "\", "
-          end
-        end
-
-        # Insert a default timeout
-        str = str + parse_time("::30")
-      end
-      str = str + ")"
-
-    # If the next word doesn't start with raw
-    elsif words[1].match(/[\(]*\w/)
-      # Get index of 'OR FOR' if it exists by the 'FOR' keyword
-      idx = words.index("FOR")
-      if idx == nil
-        idx = words.index("for")
-      end
-
-      # If there is a timeout
-      if idx != nil
-        # If the first part is a complex expression
-        if (words[1..(idx-2)].include?("OR") ||
-            words[1..(idx-2)].include?("or") ||
-            words[1..(idx-2)].include?("AND") ||
-            words[1..(idx-2)].include?("and"))
-          str = str + "wait_expression(\"" +
-            parse_expression(words[1..(idx-2)],true) + "\", "
-
-        # If it is a single telemetry item
-        else
-          @wait_match_string = "\"" + parse_tlm_item(words[1..2]) +
-            parse_cond_operator(words[3]) +  parse_id(words[4],true) + "\""
-          @verify_wait_check = false
-
-          parse_line(@data_by_lines[@universal_index+1], @out_file, true)
-
-          if @verify_wait_check == true
-            str = str + "wait_check(\"" + parse_tlm_item(words[1..2]) +
-              parse_cond_operator(words[3]) +  parse_id(words[4],true) + "\", "
-          else
-            str = str + "wait(\"" + parse_tlm_item(words[1..2]) +
-              parse_cond_operator(words[3]) +  parse_id(words[4],true) + "\", "
-          end
-        end
-
-        # Parse the timeout
-        str = str + parse_expression([words[idx+1]])
-
-      # If there is no timeout given
-      else
-        # If it is a complex expression
-        if (words[1..-1].include?("OR")  || words[1..-1].include?("or") ||
-            words[1..-1].include?("AND") || words[1..-1].include?("and"))
-          str = str + "wait_expression(\"" +
-            parse_expression(words[1..-1],true) + "\", "
-
-        # If it is a single telemetry item
-        else
-          @wait_match_string = "\"" +  parse_tlm_item(words[1..2]) +
-            parse_cond_operator(words[3]) + parse_id(words[4],true) + "\""
-          @verify_wait_check = false
-
-          parse_line(@data_by_lines[@universal_index+1], @out_file, true)
-
-          if @verify_wait_check == true
-            str = str + "wait_check(\"" +  parse_tlm_item(words[1..2]) +
-            parse_cond_operator(words[3]) + parse_id(words[4],true) + "\", "
-          else
-            str = str + "wait(\"" +  parse_tlm_item(words[1..2]) +
-            parse_cond_operator(words[3]) + parse_id(words[4],true) + "\", "
-          end
-        end
-
-        # Insert a default timeout
-        str = str + parse_time("::30")
-      end
-      str = str + ")"
-
-    else
-      str = str + "# TODO unsupported: " + line
-    end
-
-  when "write"
-    # Write the command and first word
-    str = str + "puts(" + words[1]
-
-    # Consolidate a " , to ",
-    rem = words[2..-1].join(" ")
-    quoteSpaceIdx = rem.index("\" ,")
-    if quoteSpaceIdx != nil
-      rem = rem[0..(quoteSpaceIdx)] + rem[(quoteSpaceIdx+2)..-1]
-    end
-
-    # Find the closing quote
-    quoteIdx = rem.index("\",")
-
-    # If there was a closing quote
-    if (quoteIdx != nil and quoteIdx != rem.length - 1)
-      # Write the characters up until the quote
-      str = str + rem[0..quoteIdx-1]
-
-      # Parse the rest after the ", as a quoted expression
-      expr = rem[(quoteIdx+2)..-1]
-      if expr.class == String
-        # There might be yet another quoted section
-        quoteIdx = expr.index("\"")
-        remainder = ''
-        if quoteIdx
-          remainder = expr[quoteIdx+1..-2]
-          expr = expr[0..quoteIdx-1].strip
-          expr = expr[0..-2] if expr[-1] == ','
-        end
-        str = str + " \#{#{parse_expression([expr],true,true)}}#{remainder}\""
-      else
-        puts "****************** NOT STRING ******************"
-        str = str + " \#{" + parse_expression(expr,true,true) + "}\""
-      end
-
-    # If there was no closing quote
-    else
-      words[2..-1].each do |word|
-        str = str + " " + word.to_s
-      end
-    end
-    str = str + ")"
-
-  else
-    # If this keyword is contained in the list of macros
-    if $macroList != nil and $macroList.include?(words[0].upcase)
-      str = str + parse_macro(words)
-
-    # Other keywords not handled
-    else
-      str = str + "# TODO unsupported: "  + line
-    end
-  end
-  # Implicit end of case statement
-
-  # Write the code and comment to the output file
-  if comment == ""
-    loc_out_file.puts str
-  else
-    loc_out_file.puts str + " " + comment
-  end
-end
-
-################################################################################
-#####                            BEGIN SCRIPT                             ######
-################################################################################
-
-require 'ostruct'
-require 'optparse'
-
-options = OpenStruct.new
-options.file = nil
-
-opts = OptionParser.new do |opts|
-  opts.banner = "Usage: cstol_converter [optional filenames]"
-  opts.separator ""
-  opts.separator "By default it will parse all macros (*.mac) and CSTOLS (*.prc)"
-  opts.separator "recursively starting in the current working directory"
-  opts.separator ""
-  # Create the help and version options
-  opts.on("-h", "--help", "Show this message") do
-    puts opts
-    exit
-  end
-end
-
-begin
-  opts.parse!(ARGV)
-rescue => err
-  puts err
-  puts opts
-  exit
-end
-
-mac_files = []
-prc_files = []
-if ARGV[0]
-  ARGV.each do |filename|
-    prc_files << filename
-  end
-else
-  # Find all macros
-  mac_files = Dir["**/*.mac"]
-  # Find all procedures
-  prc_files = Dir["**/*.prc"]
-end
-
-# List of targets found in the CSTOL files
-$targetList = Cosmos::System.targets.keys
-
-# Process all macros first
-unless mac_files.empty?
-  puts "*****************************************************"
-  macros_file = File.open("macrosAutoGen.rb","w")
-  mac_files.each do |file|
-    puts "  Parsing MAC file: " + file
-
-    # Parse each line in the macro file
-    File.open(file,"r") do |infile|
-      out_file = File.open(File.join(Dir.pwd, file[0..-5] + "_macro.rb"), "w")
-      infile.each do |line|
-        parse_line(line,@out_file)
-      end
-      @out_file.close
-    end
-
-    # Create a Ruby macro file that evaluates the macro in the callers context
-    macros_file.print "#{$macroName}_SRC =
-      open(\"#{file[0..-5]}_macro.rb\"){ |f|\n  f.sysread(f.stat().size())\n}\n\n"
-    macros_file.print "def #{$macroName}(locBinding"
-    $macroNumArgs.times { |num|
-      macros_file.print ",macVar#{num+1}"
-    }
-    macros_file.print ")\n"
-    $macroNumArgs.times { |num|
-      macros_file.print "  eval(\"inVar#{num+1} = \#{macVar#{num+1}}\",locBinding)\n"
-    }
-    macros_file.print "  eval(#{$macroName}_SRC,locBinding)\n"
-    macros_file.print "end\n\n"
-
-    # Append this macro to the master list of macros
-    if $macroList == nil
-      $macroList = [$macroName]
-    else
-      $macroList = $macroList.concat([$macroName])
-    end
-  end
-  macros_file.close
-end
-
-if prc_files.empty?
-  puts "No *.prc files found"
-else
-  puts "*****************************************************"
-
-  # Process all procedures next
-  prc_files.each do |file|
-    puts "  Parsing PRC file: " + file
-
-    # Open each procedure
-    File.open(file,"r") do |infile|
-      # Open its equivalent Ruby output file
-      @out_file = File.open(File.join(Dir.pwd, File.basename(file)[0..-5] + ".rb"), "w")
-
-      # Read the entire file in first in order to compress line continuations
-      @data = ""
-      matched_quotes = true
-      infile.each do |line|
-        # Check for matching quotes on this line
-        num_quotes = line.scan(/("|[^\\]")/).size
-        if num_quotes % 2 == 1
-          matched_quotes = !matched_quotes
-        end
-
-        # If the last non-whitespace character is the line continuation char
-        if line.match(/&\s*$/)
-          # Remove the continuation char and returns to join with next line
-          idx = line.rindex("&")
-          @data = @data + line[0..(idx-1)]
-        elsif matched_quotes == false
-          # If the unmatched string uses the non-standard underscore char
-          if line.match(/_\s*$/)
-            # Remove the trailing underscore
-            idx = line.rindex("_")
-            line = line[0..(idx-1)]
-          end
-          # Remove the returns from this line to join with next line
-          @data = @data + line.rstrip
-        else
-          # Leave it alone
-          @data = @data + line
-        end
-      end
-
-      @universal_index = 0
-      @data_by_lines = @data.lines.to_a
-      # Parse each line in the file
-      @data_by_lines.each do |line|
-        if @verify_wait_check == true
-          # Skip line
-          @verify_wait_check = false
-        else
-          parse_line(@data_by_lines[@universal_index], @out_file)
-        end
-        @universal_index += 1
-      end
-
-      # Close the file
-      @out_file.close
-    end
-  end
-end
-
+#!/usr/bin/env ruby
+# 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
+
+# This file converts OASIS CSTOL files to COSMOS scripts
+
+require 'cosmos'
+require 'cosmos/script'
+require 'cosmos/system'
+
+# TODO: capitalized string from ask statement may not match expression (gmi.rb:70)
+# TODO: handle V, C other units specifications...
+# TODO: handle unary operators (-1, not - 1) => although Ruby handles this fine
+
+def parse_cmd(words)
+  # Convert the part that's common to all commands
+  str = "cmd(\"" + words[1].upcase + " " + words[2].upcase
+
+  # If it has parameters
+  if words.length == 5
+    str = str + " " + parse_id(words[4], true, false, true, true)
+
+  elsif words.length > 5
+    str = str + " with"
+
+    # Join the rest of the list and remove the commas
+    args = words[4..-1].join(" ").split(",")
+    args.length.times do |i|
+      # Only prepend comma if it is not the first argument pair
+      if i != 0
+        str = str + ","
+      end
+      params = args[i].split(" ")
+
+      str = str + " " + params[0].upcase + " " + parse_id(params[1],true, false, true)
+    end
+  end
+  str = str + "\")"
+end
+
+def parse_cond_operator(op, is_set_tlm = false)
+  str = ""
+  # Convert CSTOL operators into Ruby operators
+  if op.match("/=")
+    str = " != "
+  elsif op.match(">=")
+    str = " >= "
+  elsif op.match("<=")
+    str = " <= "
+  elsif op.match(">")
+    str = " > "
+  elsif op.match("<")
+    str = " < "
+  elsif op.match("=")
+    str = " == "
+    if is_set_tlm
+      str = " = "
+    end
+  elsif op.match(/VS/i)
+    str = " == "
+  end
+  str
+end
+
+def parse_expression(vars, quoted=false, in_eval=false)
+  i=0
+  str = ""
+  finished = false
+  # Make sure there are spaces around the operators
+  if vars.length > 1
+    vars = vars.join(" ")
+  else
+    vars = vars.to_s
+  end
+  vars = vars.gsub("(", " ( ")
+  vars = vars.gsub(")", " ) ")
+  vars = vars.gsub("+", " + ")
+  vars = vars.gsub("-", " - ")
+  vars = vars.gsub("*", " * ")
+  vars = vars.gsub("==", " == ")
+  vars = vars.gsub("/=", " /= ")
+  vars = vars.gsub("<=", " <= ")
+  vars = vars.gsub(">=", " >= ")
+  vars = vars.gsub(";", " ; ")
+  # Add spaces around single character operators (/ < >)
+  offset = 0
+  while((idx = vars.index(/[\/<>][^=]/,offset)) != nil)
+    # Add space before and after operator and increment offset
+    vars = vars.insert(idx," ")
+    vars = vars.insert(idx+2," ")
+    offset = idx + 2
+  end
+  # Add spaces around single = operator (not /=, ==, <=, or >=)
+  offset = 0
+  while((idx = vars.index(/[^\/=<>]=[^=]/,offset)) != nil)
+    # Add space before and after operator and increment offset
+    vars = vars.insert(idx+1," ")
+    vars = vars.insert(idx+3," ")
+    offset = idx + 3
+  end
+
+  # Split the expression on spaces
+  vars = vars.split(" ")
+
+  last = nil
+  while (vars[i] != nil and finished != true)
+    case vars[i].tr('[]"', '')
+    when "("
+      if quoted == false
+        str = str + "("
+      end
+
+    when ")"
+      if quoted == false
+        str = str + ")"
+      end
+
+    when /\bOR\b/i
+      str = str + " || "
+
+    when /\bAND\b/i
+      str = str + " && "
+
+    when /\b\$[0-9]\b/ # $0, $1, etc are function inputs
+      str = str + "inVar" + vars[0][1..-1]
+
+    when /\$/ # $varName
+      str = str + parse_id(vars[i].tr('[]"', ''),quoted,in_eval)
+
+    when /RAW/i
+      if quoted
+        str = str + "tlm_raw('" + parse_tlm_item(vars[i+1..i+2]) + "')"
+      else
+        str = str + "tlm_raw(\"" + parse_tlm_item(vars[i+1..i+2]) + "\")"
+      end
+      i = i + 2
+    when /x#[0-9a-fA-F]+/i # Hex number
+      str = str + parse_id(vars[i].tr('[]"', ''),quoted)
+    when /b#[0-1]+/i # Binary number
+      str = str + parse_id(vars[i].tr('[]"', ''),quoted)
+
+    when /(\AVS\z|=|\/=|>|>=|<|<=)/ # Conditional operator
+      str = str + parse_cond_operator(vars[i])
+    when /(\+|-|\*|\/)/ # Arithmetic operator
+      str = str + " " + vars[i].tr('[]"', '') + " "
+
+    # Verfies Number followed immediately by units
+    when /\dDN\z|\ddn\z|\dDEG\z|\ddeg\z|\dRAD\z|\drad\z|\dV\z|\dA\z|\dv\z|\da\z|\dc\z|\dC\z|\df\z|\dF\z|\dDPS\z|\dM\z|\dMPS\z|\dm\z|\dmps\z/ # Checks for decimal/degrees/volts and amps
+      temp = vars[i].tr('[]"', '')
+      temp = temp.gsub(/DN\z|dn\z|DEG\z|deg\z|RAD\z|rad\z|V\z|A\z|v\z|a\z|c\z|C\z|f\z|F\z|DPS\z|M\z|MPS\z|m\z|mps\z/, '')
+      if temp.match(/[a-zA-Z]/)
+        str = str + parse_id(vars[i].tr('[]"', ''),quoted)
+      else
+        str = str + temp
+      end
+
+    # Verifies units are standalone
+    when last != '=' && /DN\z|dn\z|DEG\z|deg\z|RAD\z|rad\z|V\z|A\z|v\z|a\z|c\z|C\z|f\z|F\z|DPS\z|M\z|MPS\z|m\z|mps\z/ # Checks for decimal/degrees/volts and amps
+      # Verify it is not a target
+      if(vars[i] != nil and $targetList.include?(vars[i].tr('[]"', '').upcase))
+        if quoted
+          str = str + "tlm('" + parse_tlm_item(vars[i..i+1]) + "')"
+        else
+          str = str + "tlm(\"" + parse_tlm_item(vars[i..i+1]) + "\")"
+        end
+        i = i + 1
+      else
+        str = str + parse_id(vars[i].tr('[]"', ''),quoted)
+      end
+    when /[0-9]*:[0-9]*:[0-9]+/ # Timestamp
+      str = str + parse_time(vars[i].tr('[]"', ''))
+
+    when /\dE/ # Floating point
+      temp_number = vars[i].tr('E', '').to_f * 10**vars[i+2].to_f
+      str = str + "#{temp_number}"
+      finished = true
+    when /\d/ # Decimal number
+      str = str + parse_id(vars[i].tr('[]"', ''),quoted)
+
+    when /\w/ # Must stay low on the list to avoid matching other items
+      # Check this keyword against the list of targets
+      if(vars[i] != nil and $targetList.include?(vars[i].tr('[]"', '').upcase))
+        if quoted
+          str = str + "tlm('" + parse_tlm_item(vars[i..i+1]) + "')"
+        else
+          str = str + "tlm(\"" + parse_tlm_item(vars[i..i+1]) + "\")"
+        end
+        i += 1
+
+      # If it is not a target, then it must be a string or other identifier
+      else
+        str = str + parse_id(vars[i].tr('[]"', ''), quoted, false, false, false, false)
+      end
+
+      # Other cases not handled
+      # else
+      #   str = str + " # TODO unsupported: " + vars[i].tr('[]"', '')
+    end # case
+    last = vars[i].tr('[]"', '')
+    i += 1
+  end # while
+  str
+end
+
+def parse_id(id, quoted=false, in_eval=false, in_command=false, in_single_command = false, units = true)
+  str = ""
+  # Remove parentheses
+  if id.index("(") == 0
+    id = id[1..-1]
+  end
+  if id.index(")") == id.length - 1
+    id = id[0..-2]
+  end
+
+  if id.match(/\$\w/) # $varName
+    id[1,1] = id[1,1].downcase
+    if quoted and !in_eval
+      str = "'\#{" + id[1..-1] + "}'"
+    else
+
+      str = id[1..-1]
+    end
+
+  elsif (id.match(/^"/) != nil and
+         id.match(/"$/) != nil) # Starts and ends with a quote
+    if quoted
+      str = "'" + id.upcase[1..-2] + "'"
+    else
+      str = id.upcase
+    end
+
+  elsif id.match(/x#[A-Fa-f0-9]+DN/i) # Hex number with DN
+    str = "0x" + id[2..-3]
+
+  elsif id.match(/x#[0-9a-fA-F]+/i) # Hex number
+    str = "0x" + id[2..-1]
+
+  elsif id.match(/b#[0-1]+DN/i) # Binary number with DN
+    str = "0b" + id[2..-3]
+
+  elsif id.match(/b#[0-1]+/i) # Binary number
+    str = "0b" + id[2..-1]
+
+  elsif id.match(/\d+DN/i) or id.match(/-\d+DN/i)  # Decimal number with DN
+    str = id[0..-3]
+  elsif id.match(/\AVS\z|\Avs\z/)
+    str = str + " == "
+
+  # Verifies extensions with a decimal number followed by a unit
+  elsif units && id.match(/\dDN|\ddn|\dDEG|\ddeg|\dRAD|\drad|\dV|\dA|\dv|\da|\dc|\dC|\df|\dF|\dDPS|\dM\z|\dMPS\z|\dm\z|\dmps\z/)
+    temp = id.gsub(/DN\z|dn\z|DEG\z|deg\z|RAD\z|rad\z|V\z|A\z|v\z|a\z|c\z|C\z|f\z|F\z|DPS\z|M\z|MPS\z|m\z|mps\z/, '')
+    if in_command and temp.match(/[a-zA-Z]/)
+      str = str + "\'" + id.upcase + "\'"
+    # if filtered words still contain letter, then it is not a number
+    elsif temp.match(/[a-zA-Z]/)
+      str = str + id
+    else
+      str = str + temp
+    end
+  elsif id.match(/\dE\+\d/) # Floating point
+    id = id.gsub('+', ' + ')
+    temp_num_arr = id.split(' ')
+    temp_number = temp_num_arr[0].tr('E', '').to_f * 10**temp_num_arr[2].to_f
+    str = str + "#{temp_number}"
+  elsif id.match(/\A\d/) or id.match(/\A-\d/) # starts with Decimal number
+    str = id
+  # Verifies extensions with a decimal number followed by a unit
+  # that is by itself separated by whitespace
+  elsif units && id.match(/\ADN\z|\Adn\z|\ADEG\z|\Adeg\z|\ARAD\z|\Arad\z|\AV\z|\AA\z|\Av\z|\Aa\z|\Ac\z|\AC\z|\Af\z|\AF\z|\ADPS\z|\AM\z|\AMPS\z|\Am\z|\Amps\z/)
+    temp = id.gsub(/DN\z|dn\z|DEG\z|deg\z|RAD\z|rad\z|V\z|A\z|v\z|a\z|c\z|C\z|f\z|F\z|DPS\z|M\z|MPS\z|m\z|mps\z/, '')
+    if in_command
+      str = str + "\'" + id.upcase + "\'"
+    else
+      str = str + temp
+    end
+  elsif id.match(/\w/) # Any other word
+    # If it's quoted still need quotes for comparison
+    if in_single_command
+      str = id.upcase
+    elsif quoted
+      str = "\'" + id.upcase +  "\'"
+    else
+      str = "\"" + id.tr('\\', '').upcase + "\""
+    end
+  else
+    str = id
+  end
+end
+
+def parse_macro(words)
+  # Call the macro with the first parameter as binding
+  str = words[0] + "(binding"
+
+  # Add all arguments in a loop
+  (words.length-1).times do |i|
+    str = str + ", " + parse_id(words[i+1])
+  end
+  str = str + ")"
+end
+
+def parse_time(time)
+  # If this is a timestamp
+  if time.match(/[0-9]*:[0-9]*:[0-9]+/) # Timestamp
+    # Split on colons to separate hours/minutes/seconds
+    tok = time.split(":")
+
+    # If the first two tokens are empty, set to 0 (ex. ::10 is a valid time)
+    if tok[0] == ""
+      tok[0] = "0"
+    end
+    if tok[1] == ""
+      tok[1] = "0"
+    end
+
+    # Compute the number of seconds
+    secs = (3600*tok[0].to_i + 60*tok[1].to_i + tok[2].to_i).to_s
+
+  # Other cases not handled
+  else
+    secs = "# TODO unsupported: " + time
+  end
+end
+
+def parse_tlm_item(tlm)
+  # Remove preceeding parentheses
+  if tlm[0].index("(") == 0
+    tlm[0] = tlm[0][1..-1]
+  end
+
+  # If there are two telemetry items (target and mnemonic)
+  if tlm.length == 2
+    begin
+      str = tlm[0].tr('[]"', '').upcase + " " + Cosmos::System.telemetry.newest_packet(tlm[0].tr('[]"', '').upcase,tlm[1].tr('[]"', '').upcase).packet_name + " " + tlm[1].tr('[]"', '').upcase
+    rescue
+      str = "# TODO unknown TLM: " + tlm.to_s
+    end
+
+  # Other cases not handled
+  else
+    str = "# TODO unsupported: " + tlm.to_s
+  end
+end
+
+def parse_line(full_line, loc_out_file, wait_check_flag=false)
+  line = ""
+  comment = ""
+  str = ""
+
+  # Handle any empty lines
+  if full_line == nil || full_line.strip == ""
+    loc_out_file.puts full_line
+    return
+  end
+
+  # Detemine the location of any comments in this line
+  commentIdx = full_line.index(";")
+
+  # If we found a comment operator
+  if commentIdx != nil
+    # If there's text to pull out before the ;
+    if commentIdx != 0
+      line = full_line[0..(commentIdx-1)].rstrip
+    end
+    # If there's text to pull out after the ;
+    if commentIdx != full_line.length - 1
+      comment = "#" + full_line[(commentIdx+1)..-1]
+    end
+  else
+    # No comment operator so use the entire line
+    line = full_line.rstrip
+  end
+
+  # Determine the number of spaces to indent this line by finding the first
+  # non-whitespace character
+  numSpaces = full_line.index(/\S/)
+  numSpaces.times {str = str + " "}
+
+  # Handle lines with only comments
+  if line == nil or line == ""
+    loc_out_file.puts str + comment
+    return
+  end
+
+  # Redundant substitutions are done for comparators
+  line = line.gsub("==", " == ")
+  line = line.gsub("/=", " /= ")
+  line = line.gsub("<=", " <= ")
+  line = line.gsub(">=", " >= ")
+  line = line.gsub(/(\w)(=)(\w)/, '\1 = \3')
+  line = line.gsub(/(\w)(=)(\d)/, '\1 = \3')
+  line = line.gsub(/(\w)(=)(-)/, ' = -')
+  line = line.gsub(/(\w)(=)(\s)/, '\1 = \3')
+  line = line.gsub(/(\s)(=)(\w)/, '\1 = \3')
+
+  # Split the line into tokens by spaces, if no spaces between equals sign add them
+  words = line.split(" ")
+
+  # Check for old CSTOL labels which have a trailing colon
+  if words[0][-1] == ':'
+    loc_out_file.puts "# #{line}"
+    return
+  end
+
+  # if wait_check flag is activated ensure that the next line is a check otherwise infinite loop
+  if wait_check_flag and words[0].downcase != 'check'
+    return ""
+  end
+
+  case words[0].downcase
+  when "endproc"
+    if $inFunction
+      str += "end\n#{$inFunction}(#{$inFunctionParams.join(',')})" if $inFunction
+      $inFunction = nil
+    end
+
+  when "ask"
+    str = str + parse_id(words[1]) + " = ask(" + words[2]
+    (words.length-3).times do |i|
+      str = str + " " + words[i+3]
+    end
+    str = str + ")"
+
+  when "begin"
+    # Don't need to do anything with this keyword, so exit unless there's
+    # a comment to print
+    if comment == ""
+      return
+    end
+
+  when "check"
+
+    # If the next word starts with the raw keyword
+    if words[1].match(/\A(raw)/i)
+      # If the line contains a colon, parse out the range and use tolerance
+      if line.match(":")
+        vsIdx = line.index("VS")
+        vsIdx = line.index("vs") if vsIdx == nil
+        colIdx = line.index(":")
+        lowRange = line[(vsIdx+2)..(colIdx-1)]
+        highRange = line[(colIdx+1)..-1]
+        str = str + "check_tolerance_raw(\"" + parse_tlm_item(words[2..3]) +
+          "\", ((" + parse_expression([highRange],false) + ") + (" +
+          parse_expression([lowRange],false) +
+          ")) / 2," + " ((" + parse_expression([highRange],false) + ") - (" +
+          parse_expression([lowRange],false) + "))/2)"
+      else
+        if wait_check_flag
+          if @wait_match_string == "\"" + parse_tlm_item(words[2..3]) +
+            parse_cond_operator(words[4]) + parse_expression(words[5..-1],true) + "\""
+            @verify_wait_check = true
+            # exit function with true flag, and skips check statement next parse
+            return " "
+          end
+        end
+        str = str + "check_raw(\"" + parse_tlm_item(words[2..3]) +
+          parse_cond_operator(words[4]) + parse_expression(words[5..-1],true) +
+          "\")"
+      end
+
+    # If the next word starts with a variable indicator
+    elsif words[1].match(/\$/)
+      # If the line contains a colon, make check expression formatted to
+      # check against a defined range
+      if line.match(":")
+        vsIdx = line.index("VS")
+        vsIdx = line.index("vs") if vsIdx == nil
+        colIdx = line.index(":")
+        lowRange = line[(vsIdx+2)..(colIdx-1)]
+        highRange = line[(colIdx+1)..-1]
+        str = str + "check_expression(\"(" +
+          parse_expression([words[1]],true) + " >= (" +
+          parse_expression([lowRange],true) + ")) and (" +
+          parse_expression([words[1]],true) + " <= (" +
+          parse_expression([highRange],true) + "))\")"
+      else
+        str = str + "check_expression(\"" +
+          parse_expression(words[1..-1],true) + "\")"
+      end
+
+    # If the next word doesn't start with raw
+    elsif words[1].match(/\w/)
+      # If the line contains a colon, parse out the range and use tolerance
+      if line.match(":")
+        vsIdx = line.index("VS")
+        vsIdx = line.index("vs") if vsIdx == nil
+        colIdx = line.index(":")
+        lowRange = line[(vsIdx+2)..(colIdx-1)]
+        highRange = line[(colIdx+1)..-1]
+        str = str + "check_tolerance(\"" +
+          parse_tlm_item(words[1..2]) + "\", ((" +
+          parse_expression([highRange],false) + ") + (" +
+          parse_expression([lowRange],false) + ")) / 2, ((" +
+          parse_expression([highRange],false) + ") - (" +
+          parse_expression([lowRange],false) + "))/2)"
+      else
+        if (words[3])
+          # if single integer comparison or variable, just parse single (for negative integer cases)
+          if words.length <= 6
+            if wait_check_flag
+              if @wait_match_string == "\"" + parse_tlm_item(words[1..2]) + parse_cond_operator(words[3]) + parse_id(words[4],true) + "\""
+                @verify_wait_check = true
+                # exit function with true flag, and skips check statement next parse
+                return ""
+              end
+            else
+              str = str + "check(\"" + parse_tlm_item(words[1..2]) +
+                parse_cond_operator(words[3]) + parse_id(words[4],true) +
+                "\")"
+            end
+          else
+            str = str + "check(\"" + parse_tlm_item(words[1..2]) +
+              parse_cond_operator(words[3]) + parse_expression(words[4..-1],true) +
+              "\")"
+          end
+        else
+          str = str + "check(\"" + parse_tlm_item(words[1..2]) +
+            "\")"
+        end
+      end
+    end
+
+  when "cmd"
+    str = str + parse_cmd(words)
+
+  when "set"
+    str = str + parse_cmd(words)
+
+  when "declare"
+    # If the next word is input, ignore the line
+    if words.length >= 2 and words[1].match(/input/i)
+      if $inFunction
+        $inFunctionParams << "\"#{words[4].upcase}\""
+      else
+        str = str + "# SCL Ignored: " + line
+      end
+
+    # If it is a defined enum list, ignore definitions
+    elsif (words.length >= 6 and
+           words[4..-1].join(" ").match(/[A-Z]+\s+[A-Z]+(,\s*[A-Z]+)+/i))
+      str = str + parse_id(words[2]) + " " + words[3] + " " +
+        parse_id(words[4])
+
+    # If it is a defined range (one and only one colon), ignore range
+    elsif (words.length >= 6 and
+           words[4..-1].join(" ").count(":") == 1)
+      str = str + parse_id(words[2]) + " " + words[3] + " " +
+        parse_id(words[4])
+
+    # Parse the expression
+    elsif words.length >= 5
+      str = str + parse_id(words[2]) + " " + words[3] + " " +
+        parse_expression(words[4..-1])
+
+    else
+      str = str + "# TODO unsupported: " + line
+    end
+
+  when "else"
+    # Only an else
+    if words.length == 1
+      str = str + "else"
+
+    # 'Else if' statement
+    elsif words.length >= 2 and words[1].match(/if/i)
+      str = str + "elsif " + parse_expression(words[2..-1])
+
+    # Other cases not handled
+    else
+      str = str + "# TODO unsupported: " + line
+    end
+
+  when "end"
+    # End of an if statement
+    if words[1].match(/if/i)
+      str = str + "end"
+
+    # End of a procedure with arguments
+    elsif words[1].match(/proc/i) && $inFunction
+      str += "end\n#{$inFunction}(#{$inFunctionParams.join(',')})"
+
+    # End of a procedure without arguments
+    elsif words[1].match(/proc/i) && !$inFunction
+      str = str + "# SCL Ignored: " + line
+
+    # End of a loop
+    elsif words[1].match(/loop/i)
+      str = str + "end"
+
+    # End of a macro
+    elsif words[1].match(/macro/i)
+      str = str + "# SCL Ignored: " + line
+
+    # Other cases not handled
+    else
+      str = str + "# TODO unsupported: " + line
+    end
+
+  when "endif"
+    str = str + "end"
+
+  when "escape"
+    str = str + "break"
+
+  when "goto"
+    # Ignore typical goto for skipping the header section
+    if words.length == 2 and words[1].match(/start_here/i)
+      str = str + "# SCL Ignored: " + line
+
+    # Other cases not handled
+    else
+      str = str + "# TODO unsupported: " + line
+    end
+
+  when "if"
+    str = str + "if " + parse_expression(words[1..-1])
+
+  when "let"
+    # If we're assigning a telemetry point
+    if $targetList.include?(words[1].upcase)
+      # If there is no space between the equal sign reparse string
+      str = str + "set_tlm(\"" + parse_tlm_item(words[1..2]) +
+        parse_cond_operator(words[3], true) + parse_id(words[4],true) + "\")"
+    else
+      # there's no spaces between declaration
+      str = str + parse_id(words[1]) + " " + words[2] + " " +
+        parse_expression(words[3..-1])
+    end
+
+  when "lock"
+    # Ignore database commands
+    str = str + "# SCL Ignored: " + line
+
+  when "loop"
+    # TODO not sure if this is wise, for some files the loop is infinite and
+    # there's no exist case
+    if words[1] == nil
+      str = str + "# TODO Possible inifinite loop case check script file" +
+            "\n" + str + "while(true)"
+    else
+      str = str + words[1] + ".times do |i|"
+    end
+
+  when "macro"
+    str = str + ("# SCL Ignored: " + line)
+    $macroName = words[1].upcase
+    $macroNumArgs = 0
+    i = 2
+    while ((nextWord = words[i]) != nil)
+      case nextWord
+        when /\$/
+          $macroNumArgs = $macroNumArgs + 1
+      end
+      i = i + 1
+    end
+
+  when "new_mac"
+    # Ignore OASIS commands
+    str = str + "# SCL Ignored: " + line
+
+  when "new_proc"
+    # Ignore OASIS commands
+    str = str + "# SCL Ignored: " + line
+
+  when "proc"
+    # Process procedures without arguments as scripts
+    if words.length == 2
+      # Set a global so we know how to close this function
+      $inFunction = nil
+
+    # Process procedures with arguments as functions
+    else
+      # Split the list of arguments on commas
+      listWords = words[2..-1].join().split(",")
+
+      # Print the function name and the first argument
+      str = str + "def " + words[1].downcase + "(" + parse_id(listWords[0])
+
+      # Print the remaining arguments preceeded by a separator
+      (listWords.length-1).times do |i|
+        str = str + ", " + parse_id(listWords[i+1])
+      end
+      str = str + ")"
+
+      # Set a global so we know how to close this function
+      $inFunction = words[1].downcase
+      $inFunctionParams = []
+    end
+
+  when "record"
+    # Record messages without a label
+    if words.length == 2 and words[1].match(/messages/i)
+      str = str + "start_logging()\n"
+      numSpaces.times {str = str + " "}
+      str = str + "start_new_server_message_log()"
+
+    # Record message with a label
+    elsif words.length == 3 and words[1].match(/messages/i)
+      str = str + "set_log_label(" + words[2] + ")\n"
+      numSpaces.times {str = str + " "}
+      str = str + "start_logging()\n"
+      numSpaces.times {str = str + " "}
+      str = str + "start_new_server_message_log()"
+
+    # Other cases not handled
+    else
+      str = str + "# TODO unsupported: " + line
+    end
+
+  when "restore"
+    # Ignore database commands
+    str = str + "# SCL Ignored: " + line
+  when "run"
+    temp = words[1..-1].to_s
+    temp = temp.tr(',[]\"', '')
+    # removes the quotes symbol remnants
+    temp = temp.gsub('\\', '')
+    temp = temp.gsub(/\\\z/, '')
+    str = str + "system(\'" + temp + "\')"
+  when "start"
+    # Process procedures without arguments as scripts
+    if words.length == 2
+      str = str + "start(\"" + words[1].downcase + ".rb\")"
+
+    # Process procedures with arguments as functions
+    else
+      # Add the statement to require the function
+      str = str + "require_utility(\"" + words[1].downcase + ".rb\")\n"
+      numSpaces.times {str = str + " "}
+
+      # Split the list of arguments on commas
+      listWords = words[2..-1].join().split(",")
+      listWords.map! do |word|
+        if word.match(/[0-9]*:[0-9]*:[0-9]+/) # Timestamp
+          parse_time(word)
+        else
+          word
+        end
+      end
+
+      # Print the function name and the first argument
+      str = str + words[1].downcase + "(" + parse_id(listWords[0])
+
+      # Print the remaining arguments preceeded by a separator
+      (listWords.length-1).times do |i|
+        str = str + ", " + parse_id(listWords[i+1])
+      end
+      str = str + ")"
+    end
+
+  when "start_here:"
+    # Ignore typical starting point label
+    str = str + "# SCL Ignored: " + line
+
+  when "stop"
+    # Ignore calls to stop logging since COSMOS stops logging with each start
+    str = str + "# SCL Ignored: " + line
+
+  when "unlock"
+    # Ignore database commands
+    str = str + "# SCL Ignored: " + line
+
+  when "update"
+    # Ignore database commands
+    str = str + "# SCL Ignored: " + line
+
+  when "wait"
+    # add a space incase there's no space between or and parantheses
+    line = line.gsub(')or', ') or')
+    words = line.split(' ')
+    # Only a wait
+    if words.length == 1
+      str = str + "wait()"
+
+    # Waiting for length of time
+    elsif words[1].match(/[0-9]*:[0-9]*:[0-9]+/)
+      str = str + "wait(" + parse_time(words[1]) + ")"
+
+    # Waiting for a variable of time
+    elsif words.length == 2 and words[1].match(/\$/)
+      str = str + "wait(" + parse_id(words[1]) + ")"
+
+    # Waiting for an expression [or for a time]
+    elsif words.length > 2 and words[1].match(/\$/)
+      # Get index of 'OR FOR' if it exists by the 'FOR' keyword
+      idx = words.index("FOR")
+      if idx == nil
+        idx = words.index("for")
+      end
+
+      # If there is a timeout
+      if idx != nil
+        str = str + "wait_expression(\"" +
+          parse_expression(words[1..(idx-2)],true) + "\", " +
+          parse_expression([words[idx+1]]) + ")"
+
+      # No timeout given, so insert a default timeout
+      else
+        str = str + "wait_expression(\"" +
+          parse_expression(words[1..-1],true) + "\", " +
+          parse_time("::30") + ")"
+      end
+
+    # If the next word starts with the raw keyword
+    elsif words[1].match(/[\(]*(raw)/i)
+      # Get index of 'OR FOR' if it exists by the 'FOR' keyword
+      idx = words.index("FOR")
+      if idx == nil
+        idx = words.index("for")
+      end
+
+      # If there is a timeout
+      if idx != nil
+        # If the first part is a complex expression
+        if (words[1..(idx-2)].include?("OR") ||
+            words[1..(idx-2)].include?("or") ||
+            words[1..(idx-2)].include?("AND") ||
+            words[1..(idx-2)].include?("and"))
+          str = str + "wait_expression(\"" +
+            parse_expression(words[1..(idx-2)],true) + "\", "
+
+        # If it is a single telemetry item
+        else
+          @wait_match_string = "\"" + parse_tlm_item(words[2..3]) +
+              parse_cond_operator(words[4]) +
+              parse_expression(words[5..(idx-2)],true) + "\""
+          @verify_wait_check = false
+
+          parse_line(@data_by_lines[@universal_index+1], @out_file, true)
+
+          if @verify_wait_check == true
+            str = str + "wait_check_raw(\"" + parse_tlm_item(words[2..3]) +
+              parse_cond_operator(words[4]) +
+              parse_expression(words[5..(idx-2)],true) + "\", "
+          else
+            str = str + "wait_raw(\"" + parse_tlm_item(words[2..3]) +
+              parse_cond_operator(words[4]) +
+              parse_expression(words[5..(idx-2)],true) + "\", "
+          end
+        end
+
+        # Parse the timeout
+        str = str + parse_expression([words[idx+1]])
+
+      # If there is no timeout given
+      else
+        # If it is a complex expression
+        if (words[1..-1].include?("OR")  || words[1..-1].include?("or") ||
+            words[1..-1].include?("AND") || words[1..-1].include?("and"))
+          str = str + "wait_expression(\"" +
+            parse_expression(words[1..-1],true) + "\", "
+
+        # If it is a single telemetry item
+        else
+          @wait_match_string = "\"" + parse_tlm_item(words[2..3]) +
+            parse_cond_operator(words[4]) + parse_id(words[5],true) + "\""
+          @verify_wait_check = false
+
+          parse_line(@data_by_lines[@universal_index+1], @out_file, true)
+
+          if @verify_wait_check == true
+            str = str + "wait_check_raw(\"" + parse_tlm_item(words[2..3]) +
+            parse_cond_operator(words[4]) + parse_id(words[5],true) + "\", "
+          else
+            str = str + "wait_raw(\"" + parse_tlm_item(words[2..3]) +
+            parse_cond_operator(words[4]) + parse_id(words[5],true) + "\", "
+          end
+        end
+
+        # Insert a default timeout
+        str = str + parse_time("::30")
+      end
+      str = str + ")"
+
+    # If the next word doesn't start with raw
+    elsif words[1].match(/[\(]*\w/)
+      # Get index of 'OR FOR' if it exists by the 'FOR' keyword
+      idx = words.index("FOR")
+      if idx == nil
+        idx = words.index("for")
+      end
+
+      # If there is a timeout
+      if idx != nil
+        # If the first part is a complex expression
+        if (words[1..(idx-2)].include?("OR") ||
+            words[1..(idx-2)].include?("or") ||
+            words[1..(idx-2)].include?("AND") ||
+            words[1..(idx-2)].include?("and"))
+          str = str + "wait_expression(\"" +
+            parse_expression(words[1..(idx-2)],true) + "\", "
+
+        # If it is a single telemetry item
+        else
+          @wait_match_string = "\"" + parse_tlm_item(words[1..2]) +
+            parse_cond_operator(words[3]) +  parse_id(words[4],true) + "\""
+          @verify_wait_check = false
+
+          parse_line(@data_by_lines[@universal_index+1], @out_file, true)
+
+          if @verify_wait_check == true
+            str = str + "wait_check(\"" + parse_tlm_item(words[1..2]) +
+              parse_cond_operator(words[3]) +  parse_id(words[4],true) + "\", "
+          else
+            str = str + "wait(\"" + parse_tlm_item(words[1..2]) +
+              parse_cond_operator(words[3]) +  parse_id(words[4],true) + "\", "
+          end
+        end
+
+        # Parse the timeout
+        str = str + parse_expression([words[idx+1]])
+
+      # If there is no timeout given
+      else
+        # If it is a complex expression
+        if (words[1..-1].include?("OR")  || words[1..-1].include?("or") ||
+            words[1..-1].include?("AND") || words[1..-1].include?("and"))
+          str = str + "wait_expression(\"" +
+            parse_expression(words[1..-1],true) + "\", "
+
+        # If it is a single telemetry item
+        else
+          @wait_match_string = "\"" +  parse_tlm_item(words[1..2]) +
+            parse_cond_operator(words[3]) + parse_id(words[4],true) + "\""
+          @verify_wait_check = false
+
+          parse_line(@data_by_lines[@universal_index+1], @out_file, true)
+
+          if @verify_wait_check == true
+            str = str + "wait_check(\"" +  parse_tlm_item(words[1..2]) +
+            parse_cond_operator(words[3]) + parse_id(words[4],true) + "\", "
+          else
+            str = str + "wait(\"" +  parse_tlm_item(words[1..2]) +
+            parse_cond_operator(words[3]) + parse_id(words[4],true) + "\", "
+          end
+        end
+
+        # Insert a default timeout
+        str = str + parse_time("::30")
+      end
+      str = str + ")"
+
+    else
+      str = str + "# TODO unsupported: " + line
+    end
+
+  when "write"
+    # Write the command and first word
+    str = str + "puts(" + words[1]
+
+    # Consolidate a " , to ",
+    rem = words[2..-1].join(" ")
+    quoteSpaceIdx = rem.index("\" ,")
+    if quoteSpaceIdx != nil
+      rem = rem[0..(quoteSpaceIdx)] + rem[(quoteSpaceIdx+2)..-1]
+    end
+
+    # Find the closing quote
+    quoteIdx = rem.index("\",")
+
+    # If there was a closing quote
+    if (quoteIdx != nil and quoteIdx != rem.length - 1)
+      # Write the characters up until the quote
+      str = str + rem[0..quoteIdx-1]
+
+      # Parse the rest after the ", as a quoted expression
+      expr = rem[(quoteIdx+2)..-1]
+      if expr.class == String
+        # There might be yet another quoted section
+        quoteIdx = expr.index("\"")
+        remainder = ''
+        if quoteIdx
+          remainder = expr[quoteIdx+1..-2]
+          expr = expr[0..quoteIdx-1].strip
+          expr = expr[0..-2] if expr[-1] == ','
+        end
+        str = str + " \#{#{parse_expression([expr],true,true)}}#{remainder}\""
+      else
+        puts "****************** NOT STRING ******************"
+        str = str + " \#{" + parse_expression(expr,true,true) + "}\""
+      end
+
+    # If there was no closing quote
+    else
+      words[2..-1].each do |word|
+        str = str + " " + word.to_s
+      end
+    end
+    str = str + ")"
+
+  else
+    # If this keyword is contained in the list of macros
+    if $macroList != nil and $macroList.include?(words[0].upcase)
+      str = str + parse_macro(words)
+
+    # Other keywords not handled
+    else
+      str = str + "# TODO unsupported: "  + line
+    end
+  end
+  # Implicit end of case statement
+
+  # Write the code and comment to the output file
+  if comment == ""
+    loc_out_file.puts str
+  else
+    loc_out_file.puts str + " " + comment
+  end
+end
+
+################################################################################
+#####                            BEGIN SCRIPT                             ######
+################################################################################
+
+require 'ostruct'
+require 'optparse'
+
+options = OpenStruct.new
+options.file = nil
+
+opts = OptionParser.new do |opts|
+  opts.banner = "Usage: cstol_converter [optional filenames]"
+  opts.separator ""
+  opts.separator "By default it will parse all macros (*.mac) and CSTOLS (*.prc)"
+  opts.separator "recursively starting in the current working directory"
+  opts.separator ""
+  # Create the help and version options
+  opts.on("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+end
+
+begin
+  opts.parse!(ARGV)
+rescue => err
+  puts err
+  puts opts
+  exit
+end
+
+mac_files = []
+prc_files = []
+if ARGV[0]
+  ARGV.each do |filename|
+    prc_files << filename
+  end
+else
+  # Find all macros
+  mac_files = Dir["**/*.mac"]
+  # Find all procedures
+  prc_files = Dir["**/*.prc"]
+end
+
+# List of targets found in the CSTOL files
+$targetList = Cosmos::System.targets.keys
+
+# Process all macros first
+unless mac_files.empty?
+  puts "*****************************************************"
+  macros_file = File.open("macrosAutoGen.rb","w")
+  mac_files.each do |file|
+    puts "  Parsing MAC file: " + file
+
+    # Parse each line in the macro file
+    File.open(file,"r") do |infile|
+      out_file = File.open(File.join(Dir.pwd, file[0..-5] + "_macro.rb"), "w")
+      infile.each do |line|
+        parse_line(line,@out_file)
+      end
+      @out_file.close
+    end
+
+    # Create a Ruby macro file that evaluates the macro in the callers context
+    macros_file.print "#{$macroName}_SRC =
+      open(\"#{file[0..-5]}_macro.rb\"){ |f|\n  f.sysread(f.stat().size())\n}\n\n"
+    macros_file.print "def #{$macroName}(locBinding"
+    $macroNumArgs.times { |num|
+      macros_file.print ",macVar#{num+1}"
+    }
+    macros_file.print ")\n"
+    $macroNumArgs.times { |num|
+      macros_file.print "  eval(\"inVar#{num+1} = \#{macVar#{num+1}}\",locBinding)\n"
+    }
+    macros_file.print "  eval(#{$macroName}_SRC,locBinding)\n"
+    macros_file.print "end\n\n"
+
+    # Append this macro to the master list of macros
+    if $macroList == nil
+      $macroList = [$macroName]
+    else
+      $macroList = $macroList.concat([$macroName])
+    end
+  end
+  macros_file.close
+end
+
+if prc_files.empty?
+  puts "No *.prc files found"
+else
+  puts "*****************************************************"
+
+  # Process all procedures next
+  prc_files.each do |file|
+    puts "  Parsing PRC file: " + file
+
+    # Open each procedure
+    File.open(file,"r") do |infile|
+      # Open its equivalent Ruby output file
+      @out_file = File.open(File.join(Dir.pwd, File.basename(file)[0..-5] + ".rb"), "w")
+
+      # Read the entire file in first in order to compress line continuations
+      @data = ""
+      matched_quotes = true
+      infile.each do |line|
+        # Check for matching quotes on this line
+        num_quotes = line.scan(/("|[^\\]")/).size
+        if num_quotes % 2 == 1
+          matched_quotes = !matched_quotes
+        end
+
+        # If the last non-whitespace character is the line continuation char
+        if line.match(/&\s*$/)
+          # Remove the continuation char and returns to join with next line
+          idx = line.rindex("&")
+          @data = @data + line[0..(idx-1)]
+        elsif matched_quotes == false
+          # If the unmatched string uses the non-standard underscore char
+          if line.match(/_\s*$/)
+            # Remove the trailing underscore
+            idx = line.rindex("_")
+            line = line[0..(idx-1)]
+          end
+          # Remove the returns from this line to join with next line
+          @data = @data + line.rstrip
+        else
+          # Leave it alone
+          @data = @data + line
+        end
+      end
+
+      @universal_index = 0
+      @data_by_lines = @data.lines.to_a
+      # Parse each line in the file
+      @data_by_lines.each do |line|
+        if @verify_wait_check == true
+          # Skip line
+          @verify_wait_check = false
+        else
+          parse_line(@data_by_lines[@universal_index], @out_file)
+        end
+        @universal_index += 1
+      end
+
+      # Close the file
+      @out_file.close
+    end
+  end
+end
+