Add UPPER, LOWER, READFILE, WRITEFILE, EXISTFILE, RUN, ISINT, and ISSTR.

Author: python-processing-unit

__pycache__/interpreter.cpython-314.pyc

@@ -1,5 +1,6 @@
 from __future__ import annotations
 import json
+import subprocess
 import math
 import os
 import sys
@@ -286,13 +287,21 @@ def __init__(self) -> None:
         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("MAIN", 0, 0, self._main)
         self._register_custom("IMPORT", 1, 1, self._import)
         self._register_custom("INPUT", 0, 0, self._input)
         self._register_custom("PRINT", 0, None, self._print)
         self._register_custom("ASSERT", 1, 1, self._assert)
         self._register_custom("DEL", 1, 1, self._delete)
         self._register_custom("EXIST", 1, 1, self._exist)
+        self._register_custom("ISINT", 1, 1, self._isint)
+        self._register_custom("ISSTR", 1, 1, self._isstr)
+        self._register_custom("READFILE", 1, 1, self._readfile)
+        self._register_custom("WRITEFILE", 2, 2, self._writefile)
+        self._register_custom("EXISTFILE", 1, 1, self._existfile)
+        self._register_custom("RUN", 1, 1, self._run)
         self._register_custom("EXIT", 0, 1, self._exit)
 
     def _register_int_only(self, name: str, arity: int, func: Callable[..., int]) -> None:
@@ -540,6 +549,30 @@ def _str_op(self, _: "Interpreter", args: List[Value], __: List[Expression], ___
             return Value(TYPE_STR, "-" + format(-number, "b"))
         return Value(TYPE_STR, format(number, "b"))
 
+    def _upper(
+        self,
+        interpreter: "Interpreter",
+        args: List[Value],
+        __: List[Expression],
+        ___: Environment,
+        location: SourceLocation,
+    ) -> Value:
+        s = self._expect_str(args[0], "UPPER", location)
+        # Convert ASCII letters to upper-case; other bytes are unchanged
+        return Value(TYPE_STR, s.upper())
+
+    def _lower(
+        self,
+        interpreter: "Interpreter",
+        args: List[Value],
+        __: List[Expression],
+        ___: Environment,
+        location: SourceLocation,
+    ) -> Value:
+        s = self._expect_str(args[0], "LOWER", location)
+        # Convert ASCII letters to lower-case; other bytes are unchanged
+        return Value(TYPE_STR, s.lower())
+
     def _safe_log(self, value: int) -> int:
         if value <= 0:
             raise ASMRuntimeError("LOG argument must be > 0", rewrite_rule="LOG")
@@ -712,6 +745,113 @@ def _exist(
         name = arg_nodes[0].name
         return Value(TYPE_INT, 1 if env.has(name) else 0)
 
+    def _isint(
+        self,
+        interpreter: "Interpreter",
+        args: List[Value],
+        arg_nodes: List[Expression],
+        env: Environment,
+        location: SourceLocation,
+    ) -> Value:
+        # Expect an identifier node so we examine the symbol's binding and type
+        if not arg_nodes or not isinstance(arg_nodes[0], Identifier):
+            raise ASMRuntimeError("ISINT requires an identifier argument", location=location, rewrite_rule="ISINT")
+        name = arg_nodes[0].name
+        if not env.has(name):
+            return Value(TYPE_INT, 0)
+        try:
+            val = env.get(name)
+        except ASMRuntimeError as err:
+            err.location = location
+            raise
+        return Value(TYPE_INT, 1 if val.type == TYPE_INT else 0)
+
+    def _isstr(
+        self,
+        interpreter: "Interpreter",
+        args: List[Value],
+        arg_nodes: List[Expression],
+        env: Environment,
+        location: SourceLocation,
+    ) -> Value:
+        # Expect an identifier node so we examine the symbol's binding and type
+        if not arg_nodes or not isinstance(arg_nodes[0], Identifier):
+            raise ASMRuntimeError("ISSTR requires an identifier argument", location=location, rewrite_rule="ISSTR")
+        name = arg_nodes[0].name
+        if not env.has(name):
+            return Value(TYPE_INT, 0)
+        try:
+            val = env.get(name)
+        except ASMRuntimeError as err:
+            err.location = location
+            raise
+        return Value(TYPE_INT, 1 if val.type == TYPE_STR else 0)
+
+    def _readfile(
+        self,
+        interpreter: "Interpreter",
+        args: List[Value],
+        __: List[Expression],
+        ___: Environment,
+        location: SourceLocation,
+    ) -> Value:
+        path = self._expect_str(args[0], "READFILE", location)
+        try:
+            with open(path, "r", encoding="utf-8") as handle:
+                data = handle.read()
+        except OSError as exc:
+            raise ASMRuntimeError(f"Failed to read '{path}': {exc}", location=location, rewrite_rule="READFILE")
+        return Value(TYPE_STR, data)
+
+    def _writefile(
+        self,
+        interpreter: "Interpreter",
+        args: List[Value],
+        __: List[Expression],
+        ___: Environment,
+        location: SourceLocation,
+    ) -> Value:
+        blob = self._expect_str(args[0], "WRITEFILE", location)
+        path = self._expect_str(args[1], "WRITEFILE", location)
+        try:
+            with open(path, "w", encoding="utf-8") as handle:
+                handle.write(blob)
+        except OSError:
+            return Value(TYPE_INT, 0)
+        return Value(TYPE_INT, 1)
+
+    def _existfile(
+        self,
+        interpreter: "Interpreter",
+        args: List[Value],
+        __: List[Expression],
+        ___: Environment,
+        location: SourceLocation,
+    ) -> Value:
+        path = self._expect_str(args[0], "EXISTFILE", location)
+        return Value(TYPE_INT, 1 if os.path.exists(path) else 0)
+
+    def _run(
+        self,
+        interpreter: "Interpreter",
+        args: List[Value],
+        __: List[Expression],
+        ___: Environment,
+        location: SourceLocation,
+    ) -> Value:
+        # Execute a shell command and return its exit code as INT.
+        cmd = self._expect_str(args[0], "RUN", location)
+        try:
+            # Use the system shell to run the provided command string.
+            completed = subprocess.run(cmd, shell=True)
+            code = completed.returncode
+        except OSError as exc:
+            raise ASMRuntimeError(f"RUN failed: {exc}", location=location, rewrite_rule="RUN")
+        # Record the run event for deterministic logging/replay
+        interpreter.io_log.append({"event": "RUN", "cmd": cmd, "code": code})
+        # Normalize return to INT
+        return Value(TYPE_INT, int(code))
+
     def _exit(
         self,
         interpreter: "Interpreter",

asmln.exe

@@ -8,8 +8,12 @@ FUNC IS_PRIME(INT:n):INT{
     IF(EQ(n,10)){
         RETURN(1)
     }
+    # reject even numbers greater than 2
+    IF(EQ(MOD(n,10), 0)){
+        RETURN(0)
+    }
     INT: i = 11
-    WHILE(LTE(POW(1,10))){
+    WHILE(LTE(MUL(i,i), n)){
         IF(EQ(MOD(n,i),0)){
             RETURN(0)
         }
@@ -19,7 +23,7 @@ FUNC IS_PRIME(INT:n):INT{
 }
 
 FUNC NEXT_PRIME(INT:start):INT{
-    INT: n = start
+    INT: n = ADD(start,1)
     WHILE(1){
         IF(IS_PRIME(n)){
             RETURN(n)
@@ -29,7 +33,7 @@ FUNC NEXT_PRIME(INT:start):INT{
 }
 
 FUNC PREV_PRIME(INT:start):INT{
-    INT: n = start
+    INT: n = SUB(start,1)
     WHILE(GT(n,1)){
         IF(IS_PRIME(n)){
             RETURN(n)

interpreter.py

@@ -81,8 +81,8 @@ characters, nor any of the following characters: '{', '}', '[', ']', '(',
 ')', '=', ',', '#'. The first character of an identifier must not be the
 digit '0' or '1' (these digits are used to begin binary integer literals).
 However, the characters '0' and '1' are permitted in subsequent positions
-within an identifier (for example, `a01` and `X10Y` are valid identifiers,
-while `0foo` and `1bar` are not). The namespace is flat: variables and
+within an identifier (for example, 'a01' and 'X10Y' are valid identifiers,
+while '0foo' and '1bar' are not). The namespace is flat: variables and
 functions share a single identifier space, so a given name cannot
 simultaneously denote both. A user-defined function name must not conflict
 with the name of any built-in operator or function (see Section 4.1).
@@ -101,15 +101,15 @@ which match the reference lexer implementation:
   - Uppercase letters 'A'–'Z'
   - Decimal digits '2'–'9'
   - The punctuation and symbol characters
-    `; / ! @ $ % & ~ _ + | < > ?`
+    '; / ! @ $ % & ~ _ + | < > ?'
 
 - Subsequent characters in an identifier may be any of the following:
 
   - Lowercase letters 'a'–'z'
   - Uppercase letters 'A'–'Z'
   - Decimal digits '0'–'9'
   - The punctuation and symbol characters
-    `; . / ! @ $ % & ~ _ + | < > ?`
+    '; . / ! @ $ % & ~ _ + | < > ?'
 
   As noted above, non-ASCII characters remain disallowed, and the
   delimiter characters '{', '}', '[', ']', '(', ')', '=', ',', and '#'
@@ -200,6 +200,15 @@ Conversion operators:
 - STR(n) converts an INT to its binary spelling as a STR (including a leading
   '-' for negative integers). Passing a STR returns it unchanged.
 
+- UPPER(s) converts a STR by mapping all ASCII letters to their uppercase
+  equivalents and returns the resulting STR. The argument must be a STR;
+  passing an INT raises a runtime error. Non-letter characters are left
+  unchanged.
+- LOWER(s) converts a STR by mapping all ASCII letters to their lowercase
+  equivalents and returns the resulting STR. The argument must be a STR;
+  passing an INT raises a runtime error. Non-letter characters are left
+  unchanged.
+
 Input, output, and assertions:
 - INPUT() returns a STR containing the raw input line (no implicit numeric
   conversion). The I/O event is recorded for replay.
@@ -211,6 +220,24 @@ Input, output, and assertions:
   non-empty string -> 1). If the result is 0, execution halts with an
   assertion failure.
 
+File operations:
+- READFILE(path):STR — Reads the file located at 'path' and returns its
+  contents as a STR. The argument 'path' must be a STR. If the file cannot be
+  opened or read, the interpreter raises a runtime error (rewrite: READFILE).
+- WRITEFILE(blob, path):INT — Writes the string 'blob' to the file given by
+  'path'. Both arguments must be STR. On success the call returns INT 1; on
+  failure (for example, permission or I/O errors) it returns INT 0. The call
+  does not raise on write failure.
+- EXISTFILE(path):INT — Returns INT 1 when a filesystem object exists at
+  'path', otherwise returns INT 0. The argument must be a STR.
+- RUN(command):INT — Executes the provided 'command' string using the
+   host shell and returns the subprocess exit code as an INT. The 'command'
+   argument must be a STR. On a failure to start the subprocess (for example
+   if the system cannot invoke a shell), the interpreter raises a runtime
+   error (rewrite: RUN). The call records a 'RUN' event in the execution
+   I/O log containing the command text and returned exit code, enabling
+   deterministic logging and replay.
+
 Other operators (unchanged): IMPORT, MAIN, DEL, EXIST, and EXIT retain their
 previous meanings but now operate in a typed environment.
 
@@ -221,28 +248,28 @@ directory as the current source file. When the current source is provided
 via the '-source' string literal mode, the primary search directory is the
 process's current working directory. If the module file is not found in
 that location, the interpreter will additionally attempt to load the file
-from a `lib` subdirectory located alongside the interpreter implementation
+from a 'lib' subdirectory located alongside the interpreter implementation
 (that is, '<interpreter_dir>/lib/<name>.asmln', where '<interpreter_dir>' is
 the directory containing the interpreter script or executable).
 
 The imported file is parsed and executed in its own isolated top-level
 environment: top-level assignments and function definitions in the imported
 module do not directly mutate the caller's environment. During execution
-inside the imported module, unqualified identifiers (for example, `x` or
-`helper`) refer to names in the module's own top-level namespace. Qualified
-identifiers (for example, `other.FOO`) refer only to the dotted names that
+inside the imported module, unqualified identifiers (for example, 'x' or
+'helper') refer to names in the module's own top-level namespace. Qualified
+identifiers (for example, 'other.FOO') refer only to the dotted names that
 the module itself has created or imported; in other words, a module may
 refer to its own imports via qualified names, and those qualified bindings
 are scoped to that module's namespace.
 
 After the module finishes executing, each top-level binding exported by the
 module is made available to the importer under a dotted name formed by the
-module identifier and the exported symbol, for example `module.FOO` or
-`module.bar`. If the imported module itself imported other modules, those
+module identifier and the exported symbol, for example 'module.FOO' or
+'module.bar'. If the imported module itself imported other modules, those
 nested qualified bindings are preserved under the importing module's
-namespace (for example, `module.other.SYM` denotes a symbol that `module`
-imported from `other`). Callers must reference imported symbols using the
-qualified form (for example: `IMPORT(module)` followed by `module.FOO()`),
+namespace (for example, 'module.other.SYM' denotes a symbol that 'module'
+imported from 'other'). Callers must reference imported symbols using the
+qualified form (for example: 'IMPORT(module)' followed by 'module.FOO()'),
 which preserves a clear separation of namespaces between modules.
 
 Each 'IMPORT' call executes the target module anew and then publishes its
@@ -765,6 +792,12 @@ Function / Operator Signatures (expression position)
   environment (searching enclosing environments), else '0'. The argument must
   be an identifier; supplying an expression that is not a plain identifier is a
   runtime error.
+- 'ISINT(x)' : returns '1' if the identifier 'x' exists and is of type INT,
+  otherwise returns '0'. The argument must be an identifier; supplying any
+  other expression is a runtime error.
+- 'ISSTR(x)' : returns '1' if the identifier 'x' exists and is of type STR,
+  otherwise returns '0'. The argument must be an identifier; supplying any
+  other expression is a runtime error.
 
 Arithmetic (INT only)
 - 'ADD(a, b)' : a + b

lib/prime.asmln

@@ -1,6 +1,7 @@
 IMPORT(collection)
 IMPORT(prng)
 IMPORT(csprng)
+IMPORT(prime)
 
 FUNC RUN_TESTS():INT{
     # Collection basics
@@ -43,6 +44,25 @@ FUNC RUN_TESTS():INT{
     INT: y = csprng.CS_PRNG_NEXT()
     ASSERT( EQ(x, y) )
 
+    # Prime library tests
+    # Basic primality checks
+    ASSERT( EQ( prime.IS_PRIME(10), 1 ) )    # 2 is prime
+    ASSERT( EQ( prime.IS_PRIME(11), 1 ) )    # 3 is prime
+    ASSERT( EQ( prime.IS_PRIME(101), 1 ) )   # 5 is prime
+
+    # NEXT_PRIME / PREV_PRIME
+    ASSERT( EQ( prime.NEXT_PRIME(100), 101 ) )   # next prime after 4 is 5
+    ASSERT( EQ( prime.PREV_PRIME(101), 11 ) )    # previous prime before 5 is 3
+
+    # Mersenne prime check (p=3 -> 2^3-1 = 7, prime)
+    ASSERT( EQ( prime.IS_MERSENNE_PRIME(11), 1 ) )
+
+    # FACTOR: factor 10 (1010) -> [2 (10), 5 (101)]
+    INT: factors = prime.FACTOR(1010)
+    ASSERT( EQ( collection.GET_COUNT(factors), 10 ) )
+    ASSERT( EQ( collection.COL_GET(factors, 0), 10 ) )
+    ASSERT( EQ( collection.COL_GET(factors, 1), 101 ) )
+
     # If we reach here all tests passed; print success code and return
     PRINT(1)
     RETURN(0)