openc3 5.0.6

data/bin/cstol_converter

@@ -0,0 +1,1178 @@
+#!/usr/bin/env ruby
+# encoding: ascii-8bit
+
+# Copyright 2022 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 Affero General Public License
+# as published by the Free Software Foundation; version 3 with
+# attribution addendums as found in the LICENSE.txt
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2022, OpenC3, Inc.
+# All Rights Reserved
+
+# This file converts OASIS CSTOL files to OpenC3 scripts
+
+require 'openc3'
+require 'openc3/script'
+require 'openc3/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 + " LATEST " + 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.delete_suffix('\\')
+    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 + "load_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 OpenC3 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
+options.scope = 'DEFAULT'
+
+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
+  opts.on("-s SCOPE", "--scope SCOPE", "Use the specified scope instead of DEFAULT") do |arg|
+    options.scope = arg
+  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 = OpenC3::TargetModel.names(scope: options.scope)
+
+# 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