Add CONTINUE control flow statement, use curly brackets instead of square brackets in the standard library

Author: python-processing-unit

__pycache__/interpreter.cpython-314.pyc

@@ -28,6 +28,7 @@
     SourceLocation,
     Statement,
     WhileStatement,
+    ContinueStatement,
 )
 
 
@@ -66,6 +67,11 @@ def __init__(self, count: int) -> None:
         self.count = count
 
 
+class ContinueSignal(Exception):
+    def __init__(self) -> None:
+        super().__init__()
+
+
 class JumpSignal(Exception):
     def __init__(self, target: int) -> None:
         super().__init__(target)
@@ -574,6 +580,8 @@ def run(self) -> None:
             self._execute_block(program.statements, global_env)
         except BreakSignal as bs:
             raise ASMRuntimeError(f"BREAK({bs.count}) escaped enclosing loops", rewrite_rule="BREAK")
+        except ContinueSignal:
+            raise ASMRuntimeError("CONTINUE used outside loop", rewrite_rule="CONTINUE")
         except ASMRuntimeError as error:
             if self.logger.entries:
                 error.step_index = self.logger.entries[-1].step_index
@@ -647,6 +655,9 @@ def _execute_statement(self, statement: Statement, env: Environment) -> None:
             if count <= 0:
                 raise ASMRuntimeError("BREAK count must be > 0", location=statement.location, rewrite_rule="BREAK")
             raise BreakSignal(count)
+        if isinstance(statement, ContinueStatement):
+            # Signal to the innermost loop to skip to next iteration.
+            raise ContinueSignal()
         if isinstance(statement, GotoStatement):
             target = self._evaluate_expression(statement.expression, env)
             raise JumpSignal(target)
@@ -672,6 +683,18 @@ def _execute_while(self, statement: WhileStatement, env: Environment) -> None:
                     bs.count -= 1
                     raise
                 return
+            except ContinueSignal:
+                # Evaluate condition now to determine if there will be another iteration.
+                try:
+                    next_cond = self._evaluate_expression(statement.condition, env)
+                except ASMRuntimeError:
+                    # Propagate evaluation errors
+                    raise
+                if next_cond != 0:
+                    # proceed to next iteration
+                    continue
+                # no next iteration -> behave like BREAK(1)
+                return
 
     def _execute_for(self, statement: ForStatement, env: Environment) -> None:
         target: int = self._evaluate_expression(statement.target_expr, env)
@@ -684,6 +707,14 @@ def _execute_for(self, statement: ForStatement, env: Environment) -> None:
                     bs.count -= 1
                     raise
                 return
+            except ContinueSignal:
+                # For FOR loops, increment the counter and decide whether to continue
+                current = env.get(statement.counter)
+                if current + 1 < target:
+                    env.set(statement.counter, current + 1)
+                    continue
+                # no further iterations -> behave like BREAK(1)
+                return
             env.set(statement.counter, env.get(statement.counter) + 1)
 
     def _evaluate_expression(self, expression: Expression, env: Environment) -> int:

__pycache__/lexer.cpython-314.pyc

@@ -19,7 +19,7 @@ class Token:
     column: int
 
 
-KEYWORDS = {"IF", "ELSIF", "ELSE", "WHILE", "FOR", "FUNC", "RETURN", "BREAK", "GOTO", "GOTOPOINT"}
+KEYWORDS = {"IF", "ELSIF", "ELSE", "WHILE", "FOR", "FUNC", "RETURN", "BREAK", "GOTO", "GOTOPOINT", "CONTINUE"}
 SYMBOLS = {
     "(": "LPAREN",
     ")": "RPAREN",
@@ -55,23 +55,8 @@ def tokenize(self) -> List[Token]:
                 _advance()
                 continue
             if ch == "^":
-                if self.index + 1 >= len(self.text):
-                    raise ASMParseError(
-                        f"Invalid line continuation '^' at {self.filename}:{self.line}:{self.column}"
-                    )
-                next_ch = self.text[self.index + 1]
-                if next_ch == "\n":
-                    _advance()
-                    _advance()
-                    continue
-                if next_ch == "\r":
-                    _advance()
-                    if not self._eof and self._peek() == "\n":
-                        _advance()
-                    continue
-                raise ASMParseError(
-                    f"Invalid line continuation '^' not followed by newline at {self.filename}:{self.line}:{self.column}"
-                )
+                self._consume_line_continuation()
+                continue
             if ch == "\n":
                 tokens.append(Token("NEWLINE", "\n", self.line, self.column))
                 _advance()
@@ -119,9 +104,16 @@ def _consume_signed_number(self) -> Token:
 
     def _consume_binary_digits(self) -> str:
         digits: List[str] = []
-        while not self._eof and self._peek() in "01":
-            digits.append(self._peek())
-            self._advance()
+        while not self._eof:
+            ch = self._peek()
+            if ch in "01":
+                digits.append(ch)
+                self._advance()
+                continue
+            if ch == "^":
+                self._consume_line_continuation()
+                continue
+            break
         return "".join(digits)
 
     def _consume_identifier(self) -> Token:
@@ -131,9 +123,16 @@ def _consume_identifier(self) -> Token:
                 f"Identifiers must not start with '0' or '1' at {self.filename}:{line}:{col}"
             )
         chars: List[str] = []
-        while not self._eof and self._is_identifier_part(self._peek()):
-            chars.append(self._peek())
-            self._advance()
+        while not self._eof:
+            ch = self._peek()
+            if self._is_identifier_part(ch):
+                chars.append(ch)
+                self._advance()
+                continue
+            if ch == "^":
+                self._consume_line_continuation()
+                continue
+            break
         value = "".join(chars)
         token_type: str = value if value in KEYWORDS else "IDENT"
         return Token(token_type, value, line, col)
@@ -142,7 +141,27 @@ def _is_identifier_start(self, ch: str) -> bool:
         return (ch == "_") or ("A" <= ch <= "Z") or ("a" <= ch <= "z")
 
     def _is_identifier_part(self, ch: str) -> bool:
-        return (ch == "_") or ("A" <= ch <= "Z") or ("a" <= ch <= "z") or ("0" <= ch <= "9") or (ch == ".")
+        return (ch == "_") or ("A" <= ch <= "Z") or ("a" <= ch <= "z") or (ch in "01")
+
+    def _consume_line_continuation(self) -> None:
+        if self.index + 1 >= len(self.text):
+            raise ASMParseError(
+                f"Invalid line continuation '^' at {self.filename}:{self.line}:{self.column}"
+            )
+        ch1 = self.text[self.index + 1]
+        if ch1 == "\n":
+            self._advance()
+            self._advance()
+            return
+        if ch1 == "\r":
+            self._advance()
+            self._advance()
+            if self.index < len(self.text) and self.text[self.index] == "\n":
+                self._advance()
+            return
+        raise ASMParseError(
+            f"Invalid line continuation '^' not followed by newline at {self.filename}:{self.line}:{self.column}"
+        )
 
     @property
     def _eof(self) -> bool: