openc3-cosmos-script-engine-cstol 1.0.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f1bc3e1c0f55e2a66fc5df1c1b156ef06f29a2b98132f1a9ca89d26562ba1fb
-  data.tar.gz: da77cd0df1e9908ca50654fb5b9a9cbad3b0359353e9009daab56504bab811d1
+  metadata.gz: 6ef43bd11a38493eccfc313dccee63034ead05937930eaed62e5c164bd4b68a4
+  data.tar.gz: e63152c3a168bf6da0b6d70b3e3aa9f05cb2c974c631cbd4e1ac5f36908618a6
 SHA512:
-  metadata.gz: b70bb6b13b4fac767e2bfb3407318c350029c94ba2535f7c4a33a615c2b4deb5491ebcf6f6fd2502f33a8be75d6bbf41a6a495602eb19e9f0d082e6261f48791
-  data.tar.gz: 2d5ba36b266566e4eda8e6cabe4ed67589411335d3b6c3d2545ab4fb28162ec0b64c7d544ec4b1a8fb2910ae36aa4dd5b80fd0e09263c12808b346dce4d0c9ed
+  metadata.gz: eab9091c50b1867c2d4ac4b2794f72abb67bd48352ccbd01cfa14fb442be43314c1766e73ba418cef8445d6f596d7855b54306c6b5a58cddfcca900698450107
+  data.tar.gz: d23e20164925cafe6a9efee37d6348b2277a1996a53fe8d05f0b31dd6fa4612635a0e34c1ffdcf893af8a5c297b175ece81a747250459ce747a97e298a3e6ece

data/lib/cstol_script_engine.py

@@ -25,12 +25,18 @@ import shlex
 import datetime
 import math
 import os
-from openc3.script.exceptions import CheckError, StopScript
+from openc3.script.exceptions import CheckError, StopScriptError
 from openc3.script_engines.script_engine import ScriptEngine
 from openc3.script import wait, wait_expression, ask_string, clear_screen, clear_all_screens, set_tlm, display_screen, \
     connect_interface, disconnect_interface, send_raw, start, cmd, get_target_file, tlm, ask_string, set_line_delay, step_mode, run_mode
 
 class CstolVariables:
+    # NOTE: special_variables is INTENTIONALLY a class-level (shared) dictionary.
+    # Special variables ($$ variables) are global to the engine and must persist
+    # across every script run and every CstolVariables instance. Unlike
+    # local_variables (which __init__ resets per instance), this state is meant to
+    # be shared by all instances. Do NOT move this into __init__ or copy it per
+    # instance - that would break the intended global behavior.
     special_variables = {
         "$$OWLT": 0.0,
         "$$ERROR": "NO_ERROR",
@@ -43,8 +49,23 @@ class CstolVariables:
 
     def __init__(self):
         self.local_variables = {}
+        self.if_stack = []
         self.loop_stack = []
 
+    def set_local_variable(self, name, value):
+        """
+        Sets a local variable. Variable names are case insensitive, so they are
+        normalized to upper case before being stored.
+        """
+        self.local_variables[name.upper()] = value
+
+    def get_local_variable(self, name):
+        """
+        Gets a local variable by name (case insensitive).
+        Returns None if the variable does not exist.
+        """
+        return self.local_variables.get(name.upper(), None)
+
     def set_special_variable(self, name, value):
         """
         Sets a special variable, which is a variable that starts with '$$'.
@@ -52,8 +73,9 @@ class CstolVariables:
         """
         if not name.startswith('$$'):
             raise ValueError(f"Special variable names must start with '$$': {name}")
+        name = name.upper()
         self.special_variables[name] = value
-        match name.upper():
+        match name:
             case "$$CLP_STP_INTERVAL":
                 set_line_delay(value)
                 self.special_variables["$$STEP_INTERVAL"] = value
@@ -82,7 +104,8 @@ class CstolVariables:
         """
         if not name.startswith('$$'):
             raise ValueError(f"Special variable names must start with '$$': {name}")
-        match name.upper():
+        name = name.upper()
+        match name:
             case "$$CURRENT_TIME":
                 return datetime.datetime.now(datetime.timezone.utc).timestamp()
             case "$$SC_TIME":
@@ -240,7 +263,19 @@ class CstolScriptEngine(ScriptEngine):
                 i += 3  # Skip the next 2 tokens since we combined them
 
             else:
-                reconstructed_tokens.append(tokens[i])
+                # Recombine multi-part operator tokens
+                token = tokens[i]
+                if token in self.KNOWN_TOKENS and i + 1 < len(tokens):
+                    next_token = tokens[i + 1]
+                    if ((token == '*' and next_token == '*') or
+                        (token == '<' and next_token == '=') or
+                        (token == '>' and next_token == '=') or
+                        (token == '/' and next_token == '=')):
+                        reconstructed_tokens.append(token + next_token)
+                        i += 2 # Skip the next token
+                        continue
+
+                reconstructed_tokens.append(token)
                 i += 1
 
         return reconstructed_tokens
@@ -280,7 +315,7 @@ class CstolScriptEngine(ScriptEngine):
             # Handle local variables
             if token.startswith('$'):
                 # Get the actual value of local variable
-                value = self.variables.local_variables.get(token, None)
+                value = self.variables.get_local_variable(token)
                 if value is None:
                     raise ValueError(f"Unknown variable: {token}")
                 if isinstance(value, str):
@@ -312,19 +347,19 @@ class CstolScriptEngine(ScriptEngine):
                 continue
 
             # Handle radix notation integers
-            matches = re.match(r'^[BODXHbodxh]#\d+$', token)
+            # Allow hex digits (A-F) for all bases so X#FF and H#DEADBEEF parse;
+            # int() with the proper base validates the digits for each radix.
+            matches = re.match(r'^([BODXHbodxh])#([0-9A-Fa-f]+)$', token)
             if matches is not None:
-                match (token[0].upper()):
-                    case 'B':
-                        final_tokens.append(f'0b{token[2:]}')
-                    case 'O':
-                        final_tokens.append(f'0o{token[2:]}')
-                    case 'D':
-                        final_tokens.append(f'{token[2:]}')
+                radix_char = matches.group(1).upper()
+                digits = matches.group(2)
+                match radix_char:
                     case 'H':
-                        final_tokens.append(str(int(token[2:], 16).to_bytes((len(token[2:]) + 1) // 2, 'big')))
-                    case 'X':
-                        final_tokens.append(f'0x{token[2:]}')
+                        # Hex byte buffer (raw bytes rather than an integer)
+                        final_tokens.append(str(int(digits, 16).to_bytes((len(digits) + 1) // 2, 'big')))
+                    case _:
+                        base = {'B': 2, 'O': 8, 'D': 10, 'X': 16}[radix_char]
+                        final_tokens.append(str(int(digits, base)))
                 previous_number = True
                 continue
 
@@ -359,7 +394,7 @@ class CstolScriptEngine(ScriptEngine):
             token = final_tokens[i]
 
             # Check for "RAW" pattern first: "RAW", "TARGET_NAME", "ITEM_NAME"
-            if (token == '"RAW"' and i + 2 < len(final_tokens) and
+            if (token.upper() == '"RAW"' and i + 2 < len(final_tokens) and
                 final_tokens[i + 1].startswith('"') and final_tokens[i + 1].endswith('"') and
                 final_tokens[i + 2].startswith('"') and final_tokens[i + 2].endswith('"')):
 
@@ -388,7 +423,7 @@ class CstolScriptEngine(ScriptEngine):
         return ' '.join(processed_tokens)
 
     # Combined regex pattern to match both formats
-    TIMESTAMP_PATTERN = r'(?:(\d{4})?/(\d{1,3})?-)?(\d{1,2}):(\d{1,2}):(\d{1,2}\.?\d*)'
+    TIMESTAMP_PATTERN = r'(?:(\d{4})?/(\d{1,3})?-)?(\d{0,2}):(\d{0,2}):(\d{1,2}\.?\d*)'
 
     # Will convert a CSTOL Clock Time or Delta Time into floating point seconds
     def parse_timestamp(self, timestamp, now = None):
@@ -398,6 +433,10 @@ class CstolScriptEngine(ScriptEngine):
         matches = re.match(self.TIMESTAMP_PATTERN, timestamp)
         if matches:
             year, day_of_year, hour, minute, second = matches.groups()
+            if len(hour) == 0:
+                hour = 0
+            if len(minute) == 0:
+                minute = 0
             result = {
                 'hour': int(hour),
                 'minute': int(minute),
@@ -475,6 +514,29 @@ class CstolScriptEngine(ScriptEngine):
             expressions.append(expression)
         return expressions
 
+    def _split_wait_timeout(self, tokens):
+        """Split WAIT body tokens into (condition_tokens, timeout_tokens | None).
+
+        Scans from the end of the token list looking for the last ``OR``
+        that is immediately followed by ``FOR`` or ``UNTIL``. That ``OR``
+        marks the boundary between the boolean condition and the timeout
+        clause.
+
+        Returns
+        -------
+        (condition_tokens, timeout_tokens)
+            *timeout_tokens* includes the ``FOR``/``UNTIL`` keyword and the
+            value that follows.  If no ``OR FOR`` / ``OR UNTIL`` sequence is
+            found the full token list is returned as the condition and
+            *timeout_tokens* is ``None``.
+        """
+        # Walk backwards so we find the last OR FOR / OR UNTIL (before the timeout).
+        # Earlier OR tokens are boolean operators inside the condition.
+        for i in range(len(tokens) - 1, 0, -1):
+            if tokens[i - 1].upper() == "OR" and tokens[i].upper() in ("FOR", "UNTIL"):
+                return tokens[:i - 1], tokens[i:]
+        return tokens, None
+
     def split_vs_tokens_on_colon(self, tokens):
         """
         Split tokens on colons for VS clause processing, but preserve timestamps.
@@ -537,9 +599,12 @@ class CstolScriptEngine(ScriptEngine):
             question = question[1:-1]
         answer = ask_string(question)
         if answer is not None:
-            if answer[0] == '"' and answer[-1] == '"':
+            if len(answer) >= 2 and answer[0] == '"' and answer[-1] == '"':
                 # Remove quotes and don't uppercase and don't eval
                 answer = answer[1:-1]
+            elif answer.strip() == '':
+                # Empty answer - store as-is without tokenizing/evaluating
+                pass
             else:
                 # Tokenize answer
                 answer_tokens = self.cstol_tokenizer(answer)
@@ -550,11 +615,13 @@ class CstolScriptEngine(ScriptEngine):
                 # Uppercase
                 if isinstance(answer, str):
                     answer = answer.upper()
-            self.variables.local_variables[variable] = answer
+            self.variables.set_local_variable(variable, answer)
 
     def handle_check(self, tokens, line_no):
         expressions = self.extract_expressions(tokens[1:], ",")
         for expr in expressions:
+            if len(expr) == 0:
+                raise ValueError(f"Empty expression in CHECK command at line {line_no}")
             format = None
             if expr[0][0] == '%':
                 # Format string
@@ -742,7 +809,7 @@ class CstolScriptEngine(ScriptEngine):
             raise ValueError(f"Expected '=' after variable name in DECLARE command at line {line_no}")
         #default_value = self.token_to_value(tokens[4])
         default_value = self.evaluate_tokens([tokens[4]])[0]
-        self.variables.local_variables[variable_name] = default_value
+        self.variables.set_local_variable(variable_name, default_value)
 
     def handle_display(self, tokens, line_no):
         screen_name = tokens[1]
@@ -752,9 +819,29 @@ class CstolScriptEngine(ScriptEngine):
         display_screen(*screen_name.split())
 
     def handle_else(self, tokens, lines, line_no):
-        if len(tokens) == 1 and tokens[0] == 'ELSE':
+        goto_endif = False
+        if len(tokens) > 1:
+            # ELSE IF is tricky - We can hit these after a successful IF, or an unsuccessful IF
+            # The if_stack keeps track if an earlier if was successful and its value will determine if we
+            # execute the ELSEIF or just goto the next ENDIF
+            current_if = False
+            if len(self.variables.if_stack) > 0:
+                current_if = self.variables.if_stack[-1]
+            if tokens[0].upper() == 'ELSEIF':
+                if current_if:
+                    goto_endif = True
+                else:
+                    return self.handle_if(tokens, lines, line_no)
+            elif (tokens[0].upper() == 'ELSE' and tokens[1].upper() == 'IF'):
+                if current_if:
+                    goto_endif = True
+                else:
+                    return self.handle_if(tokens[1:], lines, line_no)
+
+        if goto_endif or (len(tokens) == 1 and tokens[0].upper() == 'ELSE'):
             # The only way we ever hit an ELSE is if we were in a successful block beforehand
             # Therefore goto the ENDIF
+            self.variables.if_stack[-1] = True
             depth = 1
             for i in range(line_no, len(lines)):
                 next_line = lines[i].strip().upper()
@@ -766,18 +853,16 @@ class CstolScriptEngine(ScriptEngine):
                         return i + 1
             raise ValueError(f"No matching ENDIF for ELSE command at line {line_no}")
 
-        elif len(tokens) > 1:
-            if tokens[0] == 'ELSEIF':
-                return self.handle_if(tokens, lines, line_no)
-            elif (tokens[0] == 'ELSE' and tokens[1] == 'IF'):
-                return self.handle_if(tokens[1:], lines, line_no)
+        raise ValueError(f"handle_else called with unexpected tokens at line {line_no}")
 
     def handle_end(self, tokens, line_no):
-        if len(tokens) == 1 and tokens[0] == 'END':
+        if len(tokens) == 1 and tokens[0].upper() == 'END':
             raise ValueError(f"Unexpected END command at line {line_no}, expected ENDIF, ENDLOOP, ENDMACRO, or ENDPROC")
-        elif (len(tokens) == 1 and tokens[0] == 'ENDIF') or (tokens[0] == 'END' and tokens[1] == 'IF'):
+        elif (len(tokens) == 1 and tokens[0].upper() == 'ENDIF') or (tokens[0].upper() == 'END' and tokens[1].upper() == 'IF'):
+            # END IF pops the IF stack
+            self.variables.if_stack.pop()
             pass
-        elif (len(tokens) == 1 and tokens[0] == 'ENDLOOP') or (tokens[0] == 'END' and tokens[1] == 'LOOP'):
+        elif (len(tokens) == 1 and tokens[0].upper() == 'ENDLOOP') or (tokens[0].upper() == 'END' and tokens[1].upper() == 'LOOP'):
             if len(self.variables.loop_stack) > 0:
                 loop_info = self.variables.loop_stack[-1]
                 loop_info[2] += 1
@@ -798,10 +883,14 @@ class CstolScriptEngine(ScriptEngine):
         # Find the matching ENDLOOP
         depth = 1
         for i in range(line_no, len(lines)):
-            next_line = lines[i].strip()
-            if next_line.startswith('LOOP'):
+            # Match on whole words so labels like "LOOPBACK:" are not mistaken
+            # for a nested LOOP keyword
+            words = lines[i].strip().upper().split()
+            if not words:
+                continue
+            if words[0] == 'LOOP':
                 depth += 1
-            elif next_line.startswith('END LOOP') or next_line.startswith('ENDLOOP'):
+            elif words[0] == 'ENDLOOP' or (words[0] == 'END' and len(words) > 1 and words[1] == 'LOOP'):
                 depth -= 1
                 if depth == 0:
                     if len(self.variables.loop_stack) > 0:
@@ -810,17 +899,17 @@ class CstolScriptEngine(ScriptEngine):
         raise ValueError(f"No matching ENDLOOP found for ESCAPE command at line {line_no}")
 
     def handle_go(self, tokens, lines, line_no):
-        if tokens[0] == 'GOTO' or (len(tokens) > 1 and tokens[0] == 'GO' and tokens[1] == 'TO'):
-            if (tokens[0] == 'GOTO' and len(tokens) < 2) or (tokens[0] == 'GO' and tokens[1] != 'TO' and len(tokens) < 3):
+        if tokens[0].upper() == 'GOTO' or (len(tokens) > 1 and tokens[0].upper() == 'GO' and tokens[1].upper() == 'TO'):
+            if (tokens[0].upper() == 'GOTO' and len(tokens) < 2) or (tokens[0].upper() == 'GO' and len(tokens) < 3):
                 raise ValueError(f"Invalid GOTO command format at line {line_no}")
             label = None
-            if tokens[0] == 'GOTO':
-                label = tokens[1] + ':'
+            if tokens[0].upper() == 'GOTO':
+                label = (tokens[1] + ':').upper()
             else:
-                label = tokens[2] + ':'
+                label = (tokens[2] + ':').upper()
             # Find the label in the lines
             for i in range(1, len(lines)):
-                next_line = lines[i - 1].strip()
+                next_line = lines[i - 1].strip().upper()
                 if next_line.startswith(label):
                     return i
             raise ValueError(f"Label '{label}' not found in GOTO command at line {line_no}")
@@ -835,6 +924,8 @@ class CstolScriptEngine(ScriptEngine):
             raise ValueError(f"Error evaluating expression '{expression_tokens}' in IF command at line {line_no}: {e}")
 
         if result:
+            # Mark if as handled
+            self.variables.if_stack[-1] = True
             return line_no + 1  # Continue to the next line if the condition is true
         # If the condition is false, skip to the next ENDIF or ELSE
         else:
@@ -897,7 +988,7 @@ class CstolScriptEngine(ScriptEngine):
             self.variables.set_special_variable(variable_name, result)
         else:
             # Local variable
-            self.variables.local_variables[variable_name] = result
+            self.variables.set_local_variable(variable_name, result)
 
     def handle_load(self, tokens, line_no):
         # LOAD external-element-name AT location FROM file-name
@@ -923,14 +1014,11 @@ class CstolScriptEngine(ScriptEngine):
         if len(tokens) == 1:
             # Infinite loop
             self.variables.loop_stack.append([line_no + 1, None, 1])
-            return line_no + 1  # Continue to the next line
-        elif len(tokens) == 2:
-            # Counted loop
-            count = int(tokens[1])
-            self.variables.loop_stack.append([line_no + 1, count, 1])
-            return line_no + 1  # Continue to the next line
         else:
-            raise ValueError(f"Invalid LOOP command format at line {line_no}")
+            # Counted loop - the count may be a literal, variable, or expression
+            count = int(self.evaluate_expression(tokens[1:]))
+            self.variables.loop_stack.append([line_no + 1, count, 1])
+        return line_no + 1  # Continue to the next line
 
     def handle_proc(self, tokens, line_no):
         # tokens[1] is proc name
@@ -941,7 +1029,7 @@ class CstolScriptEngine(ScriptEngine):
                 if token == ',':
                     continue
                 elif token.startswith('$'):
-                    self.variables.local_variables[token] = os.getenv(f"CSTOL_ARG_{index}")
+                    self.variables.set_local_variable(token, os.getenv(f"CSTOL_ARG_{index}"))
                     index += 1
                 else:
                     raise ValueError(f"Invalid variable '{token}' in PROC command at line {line_no}")
@@ -949,7 +1037,7 @@ class CstolScriptEngine(ScriptEngine):
     def handle_return(self, tokens, lines, line_no):
         if len(tokens) > 1:
             if tokens[1].upper() == 'ALL':
-                raise StopScript
+                raise StopScriptError
         return (len(lines) + 1)
 
     def handle_run(self, tokens, line_no):
@@ -1023,11 +1111,11 @@ class CstolScriptEngine(ScriptEngine):
                 raise ValueError(f"Invalid timestamp format at line {line_no}")
         else:
             # Conditional expression wait
-            expressions = self.extract_expressions(tokens[1:], seperator="OR")
-            python_expression = self.build_python_expression(expressions[0])
-            if len(expressions) > 1:
+            condition_tokens, timeout_tokens = self._split_wait_timeout(tokens[1:])
+            python_expression = self.build_python_expression(condition_tokens)
+            if timeout_tokens is not None:
                 # Timeout given with "OR FOR" or "OR UNTIL"
-                seconds = self.evaluate_expression(expressions[1][1:]) # Drop assumed FOR or UNTIL token
+                seconds = self.evaluate_expression(timeout_tokens[1:]) # Drop FOR or UNTIL token
                 if isinstance(seconds, (int, float, complex)) and not isinstance(seconds, bool):
                     if seconds > self.ONE_YEAR_SECONDS:
                         now = datetime.datetime.now().timestamp()
@@ -1052,6 +1140,8 @@ class CstolScriptEngine(ScriptEngine):
         expressions = self.extract_expressions(tokens[1:], ",")
         results = []
         for expr in expressions:
+            if len(expr) == 0:
+                raise ValueError(f"Empty expression in WRITE command at line {line_no}")
             result = ''
             if expr[0][0] == '%':
                 # Format string
@@ -1166,6 +1256,8 @@ class CstolScriptEngine(ScriptEngine):
                 case "GO" | "GOTO":
                     return self.handle_go(tokens, lines, line_no)
                 case "IF":
+                    # Regular IF starts an if stack
+                    self.variables.if_stack.append(False)
                     return self.handle_if(tokens, lines, line_no)
                 case "LET":
                     self.handle_let(tokens, line_no)
@@ -1192,4 +1284,4 @@ class CstolScriptEngine(ScriptEngine):
                 case _:
                     raise ValueError(f"Unknown keyword '{keyword}' at line {line_no}")
 
-        return line_no + 1
+        return line_no + 1

metadata

@@ -1,18 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: openc3-cosmos-script-engine-cstol
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.1
 platform: ruby
 authors:
-- Ryan Melton
+- OpenC3, Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-10-17 00:00:00.000000000 Z
+date: 2026-08-12 00:00:00.000000000 Z
 dependencies: []
 description: "  This plugin provides a script engine to support CSTOL in Script Runner\n"
 email:
-- ryan@openc3.com
+- plugins@openc3.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -22,12 +22,19 @@ files:
 - Rakefile
 - lib/cstol_script_engine.py
 - plugin.txt
+- public/store_img.png
 - targets/CSTOL_TEST/procedures/collect.prc
 - targets/CSTOL_TEST/procedures/test.prc
 homepage: https://github.com/OpenC3/openc3-cosmos-script-engine-cstol
 licenses:
 - Nonstandard
-metadata: {}
+metadata:
+  source_code_uri: https://github.com/OpenC3/openc3-cosmos-script-engine-cstol
+  openc3_store_title: CSTOL Script Engine
+  openc3_store_keywords: script, cstol
+  openc3_store_image: public/store_img.png
+  openc3_store_access_type: public
+  openc3_cosmos_minimum_version: 7.0.0
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -46,5 +53,5 @@ requirements: []
 rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
-summary: OpenC3 Script Engine CSTOL
+summary: OpenC3 CSTOL Script Engine
 test_files: []