Add operators: ARGV, SPLIT, STRIP, REPLACE.

Rename DRETURN to POP.
Add lib\path.asmln

Author: python-processing-unit

SPECIFICATION.md

@@ -87,17 +87,25 @@ After the module finishes executing the first time, the interpreter caches the m
 
 This caching behavior ensures that importing a module multiple times produces the same shared namespace instance for all importers. The interpreter does not automatically perform cycle detection beyond using the cached instance once execution has completed; careful module design should avoid import cycles where possible.
 
+`ARGV()` returns the interpreter's argument vector as a one-dimensional `TNS` of `STR`. The tensor's elements are the command-line argument strings supplied to the process, in the same order as the process `argv`, with index 1 holding the interpreter's invocation entry (TNS indices are 1-based). This lets programs inspect their launch arguments from within ASM-Lang.
+
 `ASSERT(a)` checks that its argument is true in the Boolean sense. If `a` is non-zero, execution proceeds normally; if `a` is `0`, the program crashes with an assertion failure.
 
 `BYTES(n)` converts a non-negative integer into its big-endian byte representation. The result is a one-dimensional `TNS` whose elements are `INT` values in the range `0..11111111` (0-255 decimal), ordered most-significant byte first. The tensor length is `max(1, ceil(bit_length(n)/8))`; `BYTES(0)` returns a single zero byte. Supplying a negative integer is a runtime error.
 
+`SPLIT(string, delimiter = " ")` splits `string` on the exact substring `delimiter` and returns the parts as a one-dimensional `TNS` of `STR`. The delimiter defaults to a single space. The delimiter must be non-empty; otherwise a runtime error is raised. Consecutive delimiters and trailing delimiters are preserved, so empty-string elements may appear in the result. The tensor length equals the number of resulting segments.
+
+`STRIP(string, remove)` 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. `STRIP` does not mutate its inputs and always returns a new `STR` value.
+
+`REPLACE(string, a, b)` 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. `REPLACE` does not mutate its inputs and always returns a new `STR` value.
+
 `MAIN()` 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). It 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.
 
 Program termination is exposed via `EXIT`. `EXIT()` or `EXIT(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).
 
 Memory-management and function-return behavior are also exposed via operators. `DEL(x)` deletes the variable `x` from the current environment, freeing its memory; any subsequent reference to `x` is an error unless `x` is re-assigned. `RETURN(a)`, when executed inside a function body, immediately terminates that function and returns the value of `a` to the caller. Executing `RETURN` outside of a function is a runtime error.
 
-`DRETURN(x)` is a convenience operator combining `RETURN` and `DEL`: when executed inside a function body it retrieves the current value of the identifier `x`, deletes the binding `x` from the environment (so subsequent references are an error), and returns the retrieved value to the caller. Using `DRETURN` outside of a function is a runtime error. If `x` is frozen or undefined, `DRETURN(x)` raises the same runtime errors as `DEL(x)` or a reference to `x` would.
+`POP(x)` is a convenience operator combining `RETURN` and `DEL`: when executed inside a function body it retrieves the current value of the identifier `x`, deletes the binding `x` from the environment (so subsequent references are an error), and returns the retrieved value to the caller. Using `POP` outside of a function is a runtime error. If `x` is frozen or undefined, `POP(x)` raises the same runtime errors as `DEL(x)` or a reference to `x` would.
 
 
 ## 5. Statements and Control Flow

__pycache__/interpreter.cpython-314.pyc

@@ -34,7 +34,7 @@
     Parser,
     Program,
     ReturnStatement,
-    DReturnStatement,
+    PopStatement,
     SourceLocation,
     Statement,
     TensorLiteral,
@@ -329,6 +329,7 @@ def __init__(self) -> None:
         self._register_custom("OR", 2, 2, self._or)
         self._register_custom("XOR", 2, 2, self._xor)
         self._register_custom("NOT", 1, 1, self._not)
+        self._register_custom("ARGV", 0, 0, self._argv)
         self._register_custom("EQ", 2, 2, self._eq)
         self._register_custom("IN", 2, 2, self._in)
         self._register_int_only("GT", 2, lambda a, b: 1 if a > b else 0)
@@ -345,12 +346,15 @@ def __init__(self) -> None:
         self._register_custom("SLEN", 1, 1, self._slen)
         self._register_custom("ILEN", 1, 1, self._ilen)
         self._register_variadic("JOIN", 1, self._join)
+        self._register_custom("SPLIT", 1, 2, self._split)
         self._register_int_only("LOG", 1, self._safe_log)
         self._register_int_only("CLOG", 1, self._safe_clog)
         self._register_custom("INT", 1, 1, self._int_op)
         self._register_custom("STR", 1, 1, self._str_op)
         self._register_custom("UPPER", 1, 1, self._upper)
         self._register_custom("LOWER", 1, 1, self._lower)
+        self._register_custom("STRIP", 2, 2, self._strip)
+        self._register_custom("REPLACE", 3, 3, self._replace)
         self._register_custom("MAIN", 0, 0, self._main)
         self._register_custom("OS", 0, 0, self._os)
         self._register_custom("IMPORT", 1, 1, self._import)
@@ -669,6 +673,23 @@ def _join(self, values: List[Value], location: SourceLocation) -> Value:
         bits = "".join("0" if v == 0 else format(v, "b") for v in ints)
         return Value(TYPE_INT, int(bits or "0", 2))
 
+    def _split(
+        self,
+        _: "Interpreter",
+        args: List[Value],
+        __: List[Expression],
+        ___: Environment,
+        location: SourceLocation,
+    ) -> Value:
+        text = self._expect_str(args[0], "SPLIT", location)
+        delimiter = " " if len(args) == 1 else self._expect_str(args[1], "SPLIT", location)
+        if delimiter == "":
+            raise ASMRuntimeError("SPLIT delimiter must not be empty", location=location, rewrite_rule="SPLIT")
+
+        parts = text.split(delimiter)
+        data = np.array([Value(TYPE_STR, part) for part in parts], dtype=object)
+        return Value(TYPE_TNS, Tensor(shape=[len(parts)], data=data))
+
     # Boolean-like operators treating strings via emptiness
     def _and(self, _: "Interpreter", args: List[Value], __: List[Expression], ___: Environment, location: SourceLocation) -> Value:
         a, b = args
@@ -777,6 +798,37 @@ def _lower(
         # Convert ASCII letters to lower-case; other bytes are unchanged
         return Value(TYPE_STR, s.lower())
 
+    def _strip(
+        self,
+        interpreter: "Interpreter",
+        args: List[Value],
+        __: List[Expression],
+        ___: Environment,
+        location: SourceLocation,
+    ) -> Value:
+        # STRIP(STR: string, STR: remove):STR -> remove all occurrences of `remove` from `string`
+        s = self._expect_str(args[0], "STRIP", location)
+        rem = self._expect_str(args[1], "STRIP", location)
+        if rem == "":
+            raise ASMRuntimeError("STRIP: remove substring must not be empty", location=location, rewrite_rule="STRIP")
+        return Value(TYPE_STR, s.replace(rem, ""))
+
+    def _replace(
+        self,
+        interpreter: "Interpreter",
+        args: List[Value],
+        __: List[Expression],
+        ___: Environment,
+        location: SourceLocation,
+    ) -> Value:
+        # REPLACE(STR: string, STR: a, STR: b):STR -> replace all occurrences of `a` in `string` with `b`
+        s = self._expect_str(args[0], "REPLACE", location)
+        a = self._expect_str(args[1], "REPLACE", location)
+        b = self._expect_str(args[2], "REPLACE", location)
+        if a == "":
+            raise ASMRuntimeError("REPLACE: substring must not be empty", location=location, rewrite_rule="REPLACE")
+        return Value(TYPE_STR, s.replace(a, b))
+
     def _safe_log(self, value: int) -> int:
         if value <= 0:
             raise ASMRuntimeError("LOG argument must be > 0", rewrite_rule="LOG")
@@ -1011,6 +1063,19 @@ def _print(
         interpreter.io_log.append({"event": "PRINT", "values": [arg.value for arg in args]})
         return Value(TYPE_INT, 0)
 
+    def _argv(
+        self,
+        interpreter: "Interpreter",
+        args: List[Value],
+        __: List[Expression],
+        ___: Environment,
+        ____: SourceLocation,
+    ) -> Value:
+        # Return the process argument vector as a 1-D TNS of STR values.
+        entries: List[str] = [str(s) for s in sys.argv]
+        data = np.array([Value(TYPE_STR, s) for s in entries], dtype=object)
+        return Value(TYPE_TNS, Tensor(shape=[len(data)], data=data))
+
     def _assert(
         self,
         interpreter: "Interpreter",
@@ -1891,14 +1956,14 @@ def _execute_statement(self, statement: Statement, env: Environment) -> None:
                 closure=env,
             )
             return
-        if isinstance(statement, DReturnStatement):
+        if isinstance(statement, PopStatement):
             frame: Frame = self.call_stack[-1]
             if frame.name == "<top-level>":
-                raise ASMRuntimeError("DRETURN outside of function", location=statement.location, rewrite_rule="DRETURN")
+                raise ASMRuntimeError("POP outside of function", location=statement.location, rewrite_rule="POP")
             # Expect identifier expression to delete a symbol
             expr = statement.expression
             if not isinstance(expr, Identifier):
-                raise ASMRuntimeError("DRETURN expects identifier", location=statement.location, rewrite_rule="DRETURN")
+                raise ASMRuntimeError("POP expects identifier", location=statement.location, rewrite_rule="POP")
             name = expr.name
             try:
                 value = env.get(name)

__pycache__/lexer.cpython-314.pyc

@@ -27,7 +27,7 @@ class Token:
     "FOR",
     "FUNC",
     "RETURN",
-    "DRETURN",
+    "POP",
     "BREAK",
     "CONTINUE",
     "GOTO",

__pycache__/parser.cpython-314.pyc

@@ -0,0 +1,71 @@
+# Path utilities for ASM-Lang
+
+FUNC NORMALIZE_PATH(STR: path):STR{
+    RETURN(REPLACE(path,"\","/"))
+}
+
+FUNC BASEPATH(STR: path):STR{
+    TNS: tpath = SPLIT(NORMALIZE_PATH(path), "/")
+    STR: abspath = ""
+    FOR(i,SUB(TLEN(tpath,1),1) ){
+        IF(EQ(i,0)){CONTINUE()}
+        abspath = JOIN(abspath,tpath[i],"/")
+    }
+    DEL(tpath)
+    POP(abspath)
+}
+
+FUNC BASENAME(STR: path):STR{
+    TNS: tpath = SPLIT(NORMALIZE_PATH(path), "/")
+    STR: basename = tpath[MAX(TLEN(tpath,1),1)]
+    DEL(tpath)
+    POP(basename)
+}
+
+FUNC SPLITEXT(STR: path):TNS{
+    STR: npath = NORMALIZE_PATH(path)
+    STR: base = BASENAME(npath)
+    STR: dir = BASEPATH(npath)
+    TNS: parts = SPLIT(base, ".")
+    # If there is no dot, return the path unchanged and empty ext
+    IF(EQ(TLEN(parts,1),1)){
+        DEL(base)
+        TNS: result = [npath, ""]
+        POP(result)
+    }
+    # Extension is the last segment (1-based indexing)
+    STR: ext = parts[ TLEN(parts,1) ]
+    # Name is base without the final "." + ext suffix
+    STR: name = REPLACE(base, JOIN(".", ext), "")
+    DEL(parts)
+    STR: delex = ""
+    IF(EQ(dir, "")){
+        delex = name
+    } ELSE {
+        delex = JOIN(dir, name)
+    }
+    DEL(dir)
+    DEL(name)
+    TNS: result = [delex, ext]
+    DEL(ext)
+    DEL(delex)
+    POP(result)
+}
+
+FUNC EXTNAME(STR: path):STR{
+    RETURN(SPLITEXT(path)[10])
+}
+
+FUNC DELEXT(STR: path):STR{
+    RETURN(SPLITEXT(path)[1])
+}
+
+STR: interpreter = ARGV()[1]
+STR: interpreter_dir = NORMALIZE_PATH(BASEPATH(ARGV()[1]))
+IF(GTE(TLEN(ARGV(),1),10)){
+    STR: script = ARGV()[10]
+    STR: script_dir = NORMALIZE_PATH(BASEPATH(ARGV()[10]))
+} ELSE {
+    STR: script = ""
+    STR: script_dir = ""
+}

interpreter.py

@@ -92,7 +92,7 @@ class ReturnStatement(Statement):
 
 
 @dataclass
-class DReturnStatement(Statement):
+class PopStatement(Statement):
     expression: "Expression"
 
 
@@ -197,8 +197,8 @@ def _parse_statement(self) -> Statement:
             return self._parse_for()
         if token.type == "RETURN":
             return self._parse_return()
-        if token.type == "DRETURN":
-            return self._parse_dreturn()
+        if token.type == "POP":
+            return self._parse_pop()
         if token.type == "BREAK":
             return self._parse_break()
         if token.type == "CONTINUE":
@@ -297,10 +297,10 @@ def _parse_return(self) -> ReturnStatement:
         expression: Expression = self._parse_parenthesized_expression()
         return ReturnStatement(location=self._location_from_token(keyword), expression=expression)
 
-    def _parse_dreturn(self) -> DReturnStatement:
-        keyword = self._consume("DRETURN")
+    def _parse_pop(self) -> PopStatement:
+        keyword = self._consume("POP")
         expression: Expression = self._parse_parenthesized_expression()
-        return DReturnStatement(location=self._location_from_token(keyword), expression=expression)
+        return PopStatement(location=self._location_from_token(keyword), expression=expression)
 
     def _parse_break(self) -> BreakStatement:
         keyword = self._consume("BREAK")

lexer.py

@@ -2,6 +2,7 @@ IMPORT(prng)
 IMPORT(csprng)
 IMPORT(prime)
 IMPORT(decimal)
+IMPORT(path)
 IMPORT(waveforms)
 
 FUNC RUN_TESTS():INT{
@@ -54,6 +55,16 @@ FUNC RUN_TESTS():INT{
 
     PRINT("Decimal library tests passed.")
 
+    # Path library tests
+    ASSERT( EQ(path.NORMALIZE_PATH("a\b\c"), "a/b/c") )
+    ASSERT( EQ(path.BASENAME("a/b/c.txt"), "c.txt") )
+    ASSERT( EQ(path.EXTNAME("foo.bar"), "bar") )
+    ASSERT( EQ(path.DELEXT("foo.bar"), "foo") )
+    ASSERT( EQ(path.EXTNAME("foo"), "") )
+    ASSERT( EQ(path.DELEXT("foo"), "foo") )
+
+    PRINT("Path library tests passed.")
+
     # Waveform library tests
     INT: freq = 1100100      # 100
     INT: ms = 1010           # 10