Add THROW, fix tracebacks

Author: python-processing-unit

SPECIFICATION.html

@@ -344,6 +344,7 @@
 - `STRIP(STR: string, STR: remove):STR` — Returns a `STR` formed by removing every occurrence of the substring `remove` from `string`. The `remove` argument must be a non-empty string; supplying an empty `remove` raises a runtime error.
 - `REPLACE(STR: string, STR: a, STR: b):STR` — Returns a `STR` formed by replacing every occurrence of the substring `a` in `string` with `b`. The `a` argument must be a non-empty string; supplying an empty `a` raises a runtime error.
 - `ASSERT(ANY: a)` ; crashes if `INT`-style` truthiness of `a` is 0
+- `THROW(INT|STR: a1, INT|STR: a2, ...):STR` ; concatenates its arguments using the same rendering rules as `PRINT` and raises a runtime error with the resulting string as the message (rewrite: `THROW`).
 - `MAIN():INT` — Returns `1` when the call site belongs to the primary program file (the file passed as the interpreter's first argument, or `<string>` when `-source` is used). Returns `0` when executed from code that came from an `IMPORT` (including nested imports). The result is determined solely by the source file that contains the call expression, not by the caller's call stack.
 - `DEL(SYMBOL: x)` ; delete variable `x` from environment
 - `EXIT()` or `EXIT(INT:code)` — Requests immediate termination of the interpreter. If an integer `code` is supplied, it is used as the interpreter's process exit code; otherwise `0` is used. Execution stops immediately when `EXIT` is executed (no further statements run), and an entry is recorded in the state log to make deterministic replay possible. Using `EXIT` inside a function terminates the entire program (not just the function).
@@ -505,6 +506,7 @@
 - `CONTINUE()` ; skip remaining statements in the innermost loop iteration and proceed to the next iteration; if used in the last iteration it acts like `BREAK(1)`. Using `CONTINUE()` outside of a loop is a runtime error.
 - `GOTOPOINT(n)` ; register a gotopoint with identifier `n` at this statement's location (identifier may be `INT` or `STR`) (n evaluated at runtime). Gotopoints are visible across the containing function or top-level scope rather than being restricted to a single lexical block.
 - `GOTO(n)` ; jump to a previously-registered gotopoint with identifier `n` (`INT` or `STR`) within the same function or top-level scope; runtime error if not registered in that scope
+- `ASYNC{ block }` ; execute `block` asynchronously in a separate thread (while sharing the same namespace); the caller continues executing immediately without waiting for the async block to complete. Any uncaught errors in the async block are logged to the interpreter's error log but do not affect the caller.
 
 ### Notes
 - Built-ins are statically typed. Boolean contexts treat `INT` 0 as false and non-zero as true; `FLT` is false when 0.0 and true otherwise; `STR` is false when empty and true when non-empty unless a rule explicitly converts via `INT`. A `TNS` is true if any element is true by those rules.

asm-lang.exe

@@ -12,6 +12,40 @@
 from parser import Parser, Statement
 
 
+def _print_internal_error(*, exc: BaseException, interpreter: Optional[Interpreter] = None, verbose: bool = False, traceback_json: bool = False) -> int:
+    """Last-resort error handler.
+
+    Requirement: no ASM-Lang error should ever surface as a Python traceback.
+    """
+    # Let deliberate exits behave normally.
+    if isinstance(exc, SystemExit):
+        raise exc
+    if isinstance(exc, KeyboardInterrupt):
+        print("Interrupted", file=sys.stderr)
+        return 130
+
+    message = f"InternalError: {exc.__class__.__name__}: {exc}"
+    if interpreter is not None:
+        try:
+            location = None
+            if interpreter.logger.entries:
+                location = interpreter.logger.entries[-1].source_location
+            error = ASMRuntimeError(message, location=location, rewrite_rule="INTERNAL")
+            if interpreter.logger.entries:
+                error.step_index = interpreter.logger.entries[-1].step_index
+            formatter = TracebackFormatter(interpreter)
+            print(formatter.format_text(error, verbose=verbose), file=sys.stderr)
+            if traceback_json:
+                print(formatter.to_json(error), file=sys.stderr)
+            return 1
+        except Exception:
+            # If formatting itself fails, fall back to a simple one-liner.
+            pass
+
+    print(message, file=sys.stderr)
+    return 1
+
+
 def _parse_statements_from_source(text: str, filename: str, *, type_names: Optional[set[str]] = None) -> List[Statement]:
     lexer = Lexer(text, filename)
     tokens = lexer.tokenize()
@@ -44,7 +78,13 @@ def _output_sink(text: str) -> None:
                 output_sink=_output_sink,
             ),
         )
-        return runner(ctx)
+        try:
+            return runner(ctx)
+        except ASMExtensionError as exc:
+            print(f"ExtensionError: {exc}", file=sys.stderr)
+            return 1
+        except BaseException as exc:
+            return _print_internal_error(exc=exc, interpreter=None, verbose=verbose)
 
     try:
         interpreter = Interpreter(
@@ -58,6 +98,8 @@ def _output_sink(text: str) -> None:
     except ASMExtensionError as exc:
         print(f"ExtensionError: {exc}", file=sys.stderr)
         return 1
+    except BaseException as exc:
+        return _print_internal_error(exc=exc, interpreter=None, verbose=verbose)
     global_env = Environment()
     # Make the REPL top-level frame mimic script top-level frame
     global_frame = interpreter._new_frame("<top-level>", global_env, None)
@@ -93,9 +135,17 @@ def _output_sink(text: str) -> None:
                     interpreter._execute_block(statements, global_env)
                 except ExitSignal as sig:
                     return sig.code
+                except ASMRuntimeError as error:
+                    if interpreter.logger.entries:
+                        error.step_index = interpreter.logger.entries[-1].step_index
+                    formatter = TracebackFormatter(interpreter)
+                    print(formatter.format_text(error, verbose=interpreter.verbose), file=sys.stderr)
+                    interpreter.call_stack = [global_frame]
             except ASMParseError:
                 # If a single-line parse fails, treat it as start of multi-line input
                 buffer.append(line)
+            except BaseException as exc:
+                _print_internal_error(exc=exc, interpreter=interpreter, verbose=verbose)
             continue
 
         if stripped == "" and buffer:
@@ -115,19 +165,28 @@ def _output_sink(text: str) -> None:
                 print(formatter.format_text(error, verbose=interpreter.verbose), file=sys.stderr)
                 # reset call stack to single top-level frame to keep REPL usable
                 interpreter.call_stack = [global_frame]
+            except BaseException as exc:
+                _print_internal_error(exc=exc, interpreter=interpreter, verbose=verbose)
+                interpreter.call_stack = [global_frame]
             continue
 
         buffer.append(line)
 
 
 def run_cli(argv: Optional[List[str]] = None) -> int:
-    parser = argparse.ArgumentParser(description="ASM-Lang reference interpreter")
-    parser.add_argument("inputs", nargs="*", help="Program path/source and/or extension files (.py/.asmxt)")
-    parser.add_argument("--ext", action="append", default=[], help="Extension path (.py) or pointer file (.asmxt)")
-    parser.add_argument("-source", "--source", dest="source_mode", action="store_true", help="Treat program argument as literal source text")
-    parser.add_argument("-verbose", "--verbose", dest="verbose", action="store_true", help="Emit env snapshots in tracebacks")
-    parser.add_argument("--traceback-json", action="store_true", help="Also emit JSON traceback")
-    args = parser.parse_args(argv)
+    try:
+        parser = argparse.ArgumentParser(description="ASM-Lang reference interpreter")
+        parser.add_argument("inputs", nargs="*", help="Program path/source and/or extension files (.py/.asmxt)")
+        parser.add_argument("--ext", action="append", default=[], help="Extension path (.py) or pointer file (.asmxt)")
+        parser.add_argument("-source", "--source", dest="source_mode", action="store_true", help="Treat program argument as literal source text")
+        parser.add_argument("-verbose", "--verbose", dest="verbose", action="store_true", help="Emit env snapshots in tracebacks")
+        parser.add_argument("--traceback-json", action="store_true", help="Also emit JSON traceback")
+        args = parser.parse_args(argv)
+    except SystemExit:
+        # argparse uses SystemExit for -h and parse failures; preserve behavior.
+        raise
+    except BaseException as exc:
+        return _print_internal_error(exc=exc, interpreter=None)
 
     inputs: List[str] = list(args.inputs or [])
     ext_paths: List[str] = list(args.ext or [])
@@ -171,6 +230,8 @@ def run_cli(argv: Optional[List[str]] = None) -> int:
     except ASMExtensionError as exc:
         print(f"ExtensionError: {exc}", file=sys.stderr)
         return 1
+    except BaseException as exc:
+        return _print_internal_error(exc=exc, interpreter=None, verbose=bool(getattr(args, "verbose", False)))
 
     program: Optional[str] = None
     if remaining:
@@ -198,11 +259,15 @@ def run_cli(argv: Optional[List[str]] = None) -> int:
             print(f"Failed to read {filename}: {exc}", file=sys.stderr)
             return 1
 
+    interpreter: Optional[Interpreter] = None
     try:
         interpreter = Interpreter(source=source_text, filename=filename, verbose=args.verbose, services=services)
     except ASMExtensionError as exc:
         print(f"ExtensionError: {exc}", file=sys.stderr)
         return 1
+    except BaseException as exc:
+        return _print_internal_error(exc=exc, interpreter=None, verbose=args.verbose, traceback_json=args.traceback_json)
+
     try:
         interpreter.run()
     except ASMParseError as error:
@@ -216,8 +281,20 @@ def run_cli(argv: Optional[List[str]] = None) -> int:
         if args.traceback_json:
             print(formatter.to_json(error), file=sys.stderr)
         return 1
+    except BaseException as exc:
+        return _print_internal_error(exc=exc, interpreter=interpreter, verbose=args.verbose, traceback_json=args.traceback_json)
     return 0
 
 
 if __name__ == "__main__":
-    raise SystemExit(run_cli())
+    try:
+        raise SystemExit(run_cli())
+    except KeyboardInterrupt:
+        print("Interrupted", file=sys.stderr)
+        raise SystemExit(130)
+    except SystemExit:
+        raise
+    except BaseException as exc:
+        # Absolute last-resort catch: never print a Python traceback.
+        code = _print_internal_error(exc=exc, interpreter=None)
+        raise SystemExit(code)

asm-lang.py

@@ -313,13 +313,16 @@ def load_extension_module(path: str) -> Any:
     try:
         try:
             spec.loader.exec_module(module)  # type: ignore[union-attr]
-        except Exception:
+        except Exception as exc:
             # restore previous sys.modules state
             if prev_mod is None:
                 sys.modules.pop(mod_name, None)
             else:
                 sys.modules[mod_name] = prev_mod
-            raise
+            # Never allow a Python traceback to escape due to extension code.
+            raise ASMExtensionError(
+                f"Failed to load extension module {path}: {exc.__class__.__name__}: {exc}"
+            )
     finally:
         if sys.path and sys.path[0] == ext_dir:
             sys.path.pop(0)

extensions.py

@@ -402,6 +402,7 @@ def __init__(self) -> None:
         self._register_custom("INPUT", 0, 1, self._input)
         self._register_custom("PRINT", 0, None, self._print)
         self._register_custom("ASSERT", 1, 1, self._assert)
+        self._register_custom("THROW", 0, None, self._throw)
         self._register_custom("DEL", 1, 1, self._delete)
         self._register_custom("FREEZE", 1, 1, self._freeze)
         self._register_custom("THAW", 1, 1, self._thaw)
@@ -443,8 +444,6 @@ def __init__(self) -> None:
         self._register_custom("FLIP", 1, 1, self._flip)
         self._register_custom("TFLIP", 2, 2, self._tflip)
         self._register_custom("SCATTER", 3, 3, self._scatter)
-        # PARALLEL accepts either a single TNS of functions, or any number
-        # of function arguments passed directly (variadic form).
         self._register_custom("PARALLEL", 1, None, self._parallel)
 
     def _register_int_only(self, name: str, arity: int, func: Callable[..., int]) -> None:
@@ -1593,6 +1592,37 @@ def _assert(
             raise ASMRuntimeError("Assertion failed", location=location, rewrite_rule="ASSERT")
         return Value(TYPE_INT, 1)
 
+    def _throw(
+        self,
+        interpreter: "Interpreter",
+        args: List[Value],
+        __: List[Expression],
+        ___: Environment,
+        location: SourceLocation,
+    ) -> Value:
+        # Render arguments the same way PRINT does, then raise with the
+        # concatenated string as the error message.
+        rendered: List[str] = []
+        for arg in args:
+            if arg.type == TYPE_INT:
+                number = self._expect_int(arg, "THROW", location)
+                rendered.append(("-" + format(-number, "b")) if number < 0 else format(number, "b"))
+            elif arg.type == TYPE_STR:
+                rendered.append(arg.value)  # type: ignore[arg-type]
+            else:
+                spec = interpreter.type_registry.get_optional(arg.type)
+                if spec is not None and spec.printable:
+                    ctx = TypeContext(interpreter=interpreter, location=location)
+                    rendered.append(spec.to_str(ctx, arg))
+                else:
+                    raise ASMRuntimeError(
+                        "THROW accepts INT or STR arguments",
+                        location=location,
+                        rewrite_rule="THROW",
+                    )
+        msg = "".join(rendered)
+        raise ASMRuntimeError(msg, location=location, rewrite_rule="THROW")
+
     def _delete(
         self,
         interpreter: "Interpreter",

interpreter.py

@@ -19,7 +19,7 @@ FUNC DEC_CHAR_TO_INT(STR:ch):INT{
     IF(EQ(ch, "7")){ RETURN(111) }
     IF(EQ(ch, "8")){ RETURN(1000) }
     IF(EQ(ch, "9")){ RETURN(1001) }
-    ASSERT(0)
+    THROW("Invalid decimal character: '", ch, "'")
     RETURN(0)
 }
 
@@ -34,7 +34,7 @@ FUNC INT_TO_DEC_CHAR(INT:d):STR{
     IF(EQ(d, 111)){ RETURN("7") }
     IF(EQ(d, 1000)){ RETURN("8") }
     IF(EQ(d, 1001)){ RETURN("9") }
-    ASSERT(0)
+    THROW("Invalid decimal digit: '", INT_TO_DEC(d), "'")
     RETURN("")
 }
 

lib/decimal.asmln

@@ -59,8 +59,7 @@ FUNC LOAD(STR: img_path):TNS{
     } ELSEIF (EQ(ext, "bmp")){
         RETURN(image.LOAD_BMP(img_path))
     } ELSE {
-        PRINT("Unsupported image format: ",ext)
-        ASSERT(0)
+        THROW("Unsupported image format: ",ext)
     }
 }
 

lib/image.asmln

@@ -81,8 +81,7 @@ FUNC TEMPFILE(STR: local_path):STR{
     IF(EQ(OS(),"win")){
         STR: temp = "C:/Windows/Temp/"
     } ELSE {
-        PRINT("TEMPFILE not implemented for ", OS())
-        ASSERT(0)
+        ASSERT("TEMPFILE not implemented for ", OS())
     }
     STR: final_path = JOIN(temp, local_path)
     DEL(temp)