astreum 0.2.41__py3-none-any.whl → 0.2.61__py3-none-any.whl

astreum/_lispeum/high_evaluation.py

@@ -1,177 +1,236 @@
-from typing import List, Union
+from typing import List, Optional, Union
 import uuid
 
 from .environment import Env
-from .expression import Expr
+from .expression import Expr, error_expr, ERROR_SYMBOL
 from .meter import Meter
-
-
-def high_eval(self, env_id: uuid.UUID, expr: Expr, meter = None) -> Expr:
-
-        if meter is None:
-            meter = Meter()
-
-        # ---------- atoms ----------
-        if isinstance(expr, Expr.Error):
-            return expr
-
-        if isinstance(expr, Expr.Symbol):
-            bound = self.env_get(env_id, expr.value.encode())
-            if bound is None:
-                return Expr.Error(f"unbound symbol '{expr.value}'", origin=expr)
-            return bound
-
-        if not isinstance(expr, Expr.ListExpr):
-            return expr  # Expr.Byte or other literals passthrough
-
-        # ---------- empty / single ----------
-        if len(expr.elements) == 0:
-            return expr
-        if len(expr.elements) == 1:
-            return self.high_eval(env_id=env_id, expr=expr.elements[0], meter=meter)
-
-        tail = expr.elements[-1]
-
-        # ---------- (value name def) ----------
-        if isinstance(tail, Expr.Symbol) and tail.value == "def":
-            if len(expr.elements) < 3:
-                return Expr.Error("def expects (value name def)", origin=expr)
-            name_e = expr.elements[-2]
-            if not isinstance(name_e, Expr.Symbol):
-                return Expr.Error("def name must be symbol", origin=name_e)
-            value_e = expr.elements[-3]
-            value_res = self.high_eval(env_id=env_id, expr=value_e, meter=meter)
-            if isinstance(value_res, Expr.Error):
-                return value_res
-            self.env_set(env_id, name_e.value.encode(), value_res)
-            return value_res
-
-        # ---- LOW-LEVEL call: ( arg1 arg2 ... ( (body) sk ) ) ----
-        if isinstance(tail, Expr.ListExpr):
-            inner = tail.elements
-            if len(inner) >= 2 and isinstance(inner[-1], Expr.Symbol) and inner[-1].value == "sk":
-                body_expr = inner[-2]
-                if not isinstance(body_expr, Expr.ListExpr):
-                    return Expr.Error("sk body must be list", origin=body_expr)
-
-                # helper: turn an Expr into a contiguous bytes buffer
-                def to_bytes(v: Expr) -> Union[bytes, Expr.Error]:
-                    if isinstance(v, Expr.Byte):
-                        return bytes([v.value & 0xFF])
-                    if isinstance(v, Expr.ListExpr):
-                        # expect a list of Expr.Byte
-                        out: bytearray = bytearray()
-                        for el in v.elements:
-                            if isinstance(el, Expr.Byte):
-                                out.append(el.value & 0xFF)
-                            else:
-                                return Expr.Error("byte list must contain only Byte", origin=el)
-                        return bytes(out)
-                    if isinstance(v, Expr.Error):
-                        return v
-                    return Expr.Error("argument must resolve to Byte or (Byte ...)", origin=v)
-
-                # resolve ALL preceding args into bytes (can be Byte or List[Byte])
-                args_exprs = expr.elements[:-1]
-                arg_bytes: List[bytes] = []
-                for a in args_exprs:
-                    v = self.high_eval(env_id=env_id, expr=a, meter=meter)
-                    if isinstance(v, Expr.Error):
-                        return v
-                    vb = to_bytes(v)
-                    if isinstance(vb, Expr.Error):
-                        return vb
-                    arg_bytes.append(vb)
-
-                # build low-level code with $0-based placeholders ($0 = first arg)
-                code: List[bytes] = []
-
-                def emit(tok: Expr) -> Union[None, Expr.Error]:
-                    if isinstance(tok, Expr.Symbol):
-                        name = tok.value
-                        if name.startswith("$"):
-                            idx_s = name[1:]
-                            if not idx_s.isdigit():
-                                return Expr.Error("invalid sk placeholder", origin=tok)
-                            idx = int(idx_s)  # $0 is first
-                            if idx < 0 or idx >= len(arg_bytes):
-                                return Expr.Error("arity mismatch in sk placeholder", origin=tok)
-                            code.append(arg_bytes[idx])
-                            return None
-                        code.append(name.encode())
-                        return None
-
-                    if isinstance(tok, Expr.Byte):
-                        code.append(bytes([tok.value & 0xFF]))
-                        return None
-
-                    if isinstance(tok, Expr.ListExpr):
-                        rv = self.high_eval(env_id, tok, meter=meter)
-                        if isinstance(rv, Expr.Error):
-                            return rv
-                        rb = to_bytes(rv)
-                        if isinstance(rb, Expr.Error):
-                            return rb
-                        code.append(rb)
-                        return None
-
-                    if isinstance(tok, Expr.Error):
-                        return tok
-
-                    return Expr.Error("invalid token in sk body", origin=tok)
-
-                for t in body_expr.elements:
-                    err = emit(t)
-                    if isinstance(err, Expr.Error):
-                        return err
-
-                # Execute low-level code built from sk-body using the caller's meter
-                res = self.low_eval(code, meter=meter)
-                return res
-
-        # ---------- (... (body params fn))  HIGH-LEVEL CALL ----------
-        if isinstance(tail, Expr.ListExpr):
-            fn_form = tail
-            if (len(fn_form.elements) >= 3
-                and isinstance(fn_form.elements[-1], Expr.Symbol)
-                and fn_form.elements[-1].value == "fn"):
-
-                body_expr   = fn_form.elements[-3]
-                params_expr = fn_form.elements[-2]
-
-                if not isinstance(body_expr, Expr.ListExpr):
-                    return Expr.Error("fn body must be list", origin=body_expr)
-                if not isinstance(params_expr, Expr.ListExpr):
-                    return Expr.Error("fn params must be list", origin=params_expr)
-
-                params: List[bytes] = []
-                for p in params_expr.elements:
-                    if not isinstance(p, Expr.Symbol):
-                        return Expr.Error("fn param must be symbol", origin=p)
-                    params.append(p.value.encode())
-
-                args_exprs = expr.elements[:-1]
-                if len(args_exprs) != len(params):
-                    return Expr.Error("arity mismatch", origin=expr)
-
-                arg_bytes: List[bytes] = []
-                for a in args_exprs:
-                    v = self.high_eval(env_id, a, meter=meter)
-                    if isinstance(v, Expr.Error):
-                        return v
-                    if not isinstance(v, Expr.Byte):
-                        return Expr.Error("argument must resolve to Byte", origin=a)
-                    arg_bytes.append(bytes([v.value & 0xFF]))
-
-                # child env, bind params -> Expr.Byte
-                child_env = uuid.uuid4()
-                self.environments[child_env] = Env(parent_id=env_id)
-                for name_b, val_b in zip(params, arg_bytes):
-                    self.env_set(child_env, name_b, Expr.Byte(val_b[0]))
-
-                # evaluate HL body, metered from the top
-                return self.high_eval(child_env, body_expr, meter=meter)
-
-        # ---------- default: resolve each element and return list ----------
-        resolved: List[Expr] = [self.high_eval(env_id, e, meter=meter) for e in expr.elements]
-        return Expr.ListExpr(resolved)
+
+
+def _is_error(expr: Expr) -> bool:
+    return (
+        isinstance(expr, Expr.ListExpr)
+        and bool(expr.elements)
+        and isinstance(expr.elements[0], Expr.Symbol)
+        and expr.elements[0].value == ERROR_SYMBOL
+    )
+
+
+def _hex_symbol_to_bytes(value: Optional[str]) -> Optional[bytes]:
+    if not value:
+        return None
+    data = value.strip()
+    if data.startswith(("0x", "0X")):
+        data = data[2:]
+    if len(data) % 2:
+        data = "0" + data
+    try:
+        return bytes.fromhex(data)
+    except ValueError:
+        return None
+
+
+def _expr_to_bytes(expr: Expr) -> Optional[bytes]:
+    if isinstance(expr, Expr.Bytes):
+        return expr.value
+    if isinstance(expr, Expr.Symbol):
+        return _hex_symbol_to_bytes(expr.value)
+    return None
+
+
+def high_eval(self, env_id: uuid.UUID, expr: Expr, meter = None) -> Expr:
+    if meter is None:
+        meter = Meter()
+
+    call_env_id = uuid.uuid4()
+    self.environments[call_env_id] = Env(parent_id=env_id)
+    env_id = call_env_id
+
+    try:
+        # ---------- atoms ----------
+        if _is_error(expr):
+            return expr
+
+        if isinstance(expr, Expr.Symbol):
+            bound = self.env_get(env_id, expr.value.encode())
+            if bound is None:
+                return error_expr("eval", f"unbound symbol '{expr.value}'")
+            return bound
+
+        if not isinstance(expr, Expr.ListExpr):
+            return expr  # Expr.Byte or other literals passthrough
+
+        # ---------- empty / single ----------
+        if len(expr.elements) == 0:
+            return expr
+        if len(expr.elements) == 1:
+            return self.high_eval(env_id, expr.elements[0], meter)
+
+        tail = expr.elements[-1]
+
+        # ---------- (value name def) ----------
+        if isinstance(tail, Expr.Symbol) and tail.value == "def":
+            if len(expr.elements) < 3:
+                return error_expr("eval", "def expects (value name def)")
+            name_e = expr.elements[-2]
+            if not isinstance(name_e, Expr.Symbol):
+                return error_expr("eval", "def name must be symbol")
+            value_e = expr.elements[-3]
+            value_res = self.high_eval(env_id, value_e, meter)
+            if _is_error(value_res):
+                return value_res
+            self.env_set(env_id, name_e.value.encode(), value_res)
+            return value_res
+        
+        # Reference Call
+        # (atom_id ref)
+        if isinstance(tail, Expr.Symbol) and tail.value == "ref":
+            if len(expr.elements) != 2:
+                return error_expr("eval", "ref expects (atom_id ref)")
+            key_bytes = _expr_to_bytes(expr.elements[0])
+            if not key_bytes:
+                return error_expr("eval", "ref expects (atom_id ref)")
+            stored_list = self.get_expr_list_from_storage(key_bytes)
+            if stored_list is None:
+                return error_expr("eval", "ref target not found")
+            return stored_list
+
+        # Low Level Call
+        # (arg1 arg2 ... ((body) sk))
+        if isinstance(tail, Expr.ListExpr):
+            inner = tail.elements
+            if len(inner) >= 2 and isinstance(inner[-1], Expr.Symbol) and inner[-1].value == "sk":
+                body_expr = inner[-2]
+                if not isinstance(body_expr, Expr.ListExpr):
+                    return error_expr("eval", "sk body must be list")
+
+                # helper: turn an Expr into a contiguous bytes buffer
+                def to_bytes(v: Expr) -> Union[bytes, Expr]:
+                    if isinstance(v, Expr.Byte):
+                        return bytes([v.value & 0xFF])
+                    if isinstance(v, Expr.ListExpr):
+                        # expect a list of Expr.Byte
+                        out: bytearray = bytearray()
+                        for el in v.elements:
+                            if isinstance(el, Expr.Byte):
+                                out.append(el.value & 0xFF)
+                            else:
+                                return error_expr("eval", "byte list must contain only Byte elements")
+                        return bytes(out)
+                    if _is_error(v):
+                        return v
+                    return error_expr("eval", "argument must resolve to Byte or (Byte ...)")
+
+                # resolve ALL preceding args into bytes (can be Byte or List[Byte])
+                args_exprs = expr.elements[:-1]
+                arg_bytes: List[bytes] = []
+                for a in args_exprs:
+                    v = self.high_eval(env_id, a, meter)
+                    if _is_error(v):
+                        return v
+                    vb = to_bytes(v)
+                    if not isinstance(vb, bytes):
+                        if _is_error(vb):
+                            return vb
+                        return error_expr("eval", "unexpected expression while coercing to bytes")
+                    arg_bytes.append(vb)
+
+                # build low-level code with $0-based placeholders ($0 = first arg)
+                code: List[bytes] = []
+
+                def emit(tok: Expr) -> Union[None, Expr]:
+                    if isinstance(tok, Expr.Symbol):
+                        name = tok.value
+                        if name.startswith("$"):
+                            idx_s = name[1:]
+                            if not idx_s.isdigit():
+                                return error_expr("eval", "invalid sk placeholder")
+                            idx = int(idx_s)  # $0 is first
+                            if idx < 0 or idx >= len(arg_bytes):
+                                return error_expr("eval", "arity mismatch in sk placeholder")
+                            code.append(arg_bytes[idx])
+                            return None
+                        code.append(name.encode())
+                        return None
+
+                    if isinstance(tok, Expr.Byte):
+                        code.append(bytes([tok.value & 0xFF]))
+                        return None
+
+                    if isinstance(tok, Expr.ListExpr):
+                        rv = self.high_eval(env_id, tok, meter)
+                        if _is_error(rv):
+                            return rv
+                        rb = to_bytes(rv)
+                        if not isinstance(rb, bytes):
+                            if _is_error(rb):
+                                return rb
+                            return error_expr("eval", "unexpected expression while coercing list token to bytes")
+                        code.append(rb)
+                        return None
+
+                    if _is_error(tok):
+                        return tok
+
+                    return error_expr("eval", "invalid token in sk body")
+
+                for t in body_expr.elements:
+                    err = emit(t)
+                    if err is not None and _is_error(err):
+                        return err
+
+                # Execute low-level code built from sk-body using the caller's meter
+                res = self.low_eval(code, meter=meter)
+                return res
+
+        # High Level Call
+        # (arg1 arg2 ... ((body) (params) fn))
+        if isinstance(tail, Expr.ListExpr):
+            fn_form = tail
+            if (len(fn_form.elements) >= 3
+                and isinstance(fn_form.elements[-1], Expr.Symbol)
+                and fn_form.elements[-1].value == "fn"):
+
+                body_expr   = fn_form.elements[-3]
+                params_expr = fn_form.elements[-2]
+
+                if not isinstance(body_expr, Expr.ListExpr):
+                    return error_expr("eval", "fn body must be list")
+                if not isinstance(params_expr, Expr.ListExpr):
+                    return error_expr("eval", "fn params must be list")
+
+                params: List[bytes] = []
+                for p in params_expr.elements:
+                    if not isinstance(p, Expr.Symbol):
+                        return error_expr("eval", "fn param must be symbol")
+                    params.append(p.value.encode())
+
+                args_exprs = expr.elements[:-1]
+                if len(args_exprs) != len(params):
+                    return error_expr("eval", "arity mismatch")
+
+                arg_bytes: List[bytes] = []
+                for a in args_exprs:
+                    v = self.high_eval(env_id, a, meter)
+                    if _is_error(v):
+                        return v
+                    if not isinstance(v, Expr.Byte):
+                        return error_expr("eval", "argument must resolve to Byte")
+                    arg_bytes.append(bytes([v.value & 0xFF]))
+
+                # child env, bind params -> Expr.Byte
+                child_env = uuid.uuid4()
+                self.environments[child_env] = Env(parent_id=env_id)
+                try:
+                    for name_b, val_b in zip(params, arg_bytes):
+                        self.env_set(child_env, name_b, Expr.Byte(val_b[0]))
+
+                    # evaluate HL body, metered from the top
+                    return self.high_eval(child_env, body_expr, meter)
+                finally:
+                    self.environments.pop(child_env, None)
+
+        # ---------- default: resolve each element and return list ----------
+        resolved: List[Expr] = [self.high_eval(env_id, e, meter) for e in expr.elements]
+        return Expr.ListExpr(resolved)
+    finally:
+        self.environments.pop(call_env_id, None)

astreum/_lispeum/low_evaluation.py

@@ -1,6 +1,6 @@
-from typing import Dict, List, Union
-from .expression import Expr
-from .meter import Meter
+from typing import Dict, List, Union
+from .expression import Expr, error_expr
+from .meter import Meter
 
 def tc_to_int(b: bytes) -> int:
     """bytes -> int using two's complement (width = len(b)*8)."""
@@ -35,19 +35,19 @@ def nand_bytes(a: bytes, b: bytes) -> bytes:
     resu = (~(au & bu)) & mask
     return resu.to_bytes(w, "big", signed=False)
 
-def low_eval(self, code: List[bytes], meter: Meter) -> Expr:
+def low_eval(self, code: List[bytes], meter: Meter) -> Expr:
         
         heap: Dict[bytes, bytes] = {}
 
         stack: List[bytes] = []
         pc = 0
 
-        while True:
-            if pc >= len(code):
-                if len(stack) != 1:
-                    return Expr.Error("bad stack")
-                # wrap successful result as an Expr.Bytes
-                return Expr.Bytes(stack.pop())
+        while True:
+            if pc >= len(code):
+                if len(stack) != 1:
+                    return error_expr("low_eval", "bad stack")
+                # wrap successful result as an Expr.Bytes
+                return Expr.Bytes(stack.pop())
 
             tok = code[pc]
             pc += 1
@@ -55,7 +55,7 @@ def low_eval(self, code: List[bytes], meter: Meter) -> Expr:
             # ---------- ADD ----------
             if tok == b"add":
                 if len(stack) < 2:
-                    return Expr.Error("underflow")
+                    return error_expr("low_eval", "underflow")
                 b_b = stack.pop()
                 a_b = stack.pop()
                 a_i = tc_to_int(a_b)
@@ -65,56 +65,56 @@ def low_eval(self, code: List[bytes], meter: Meter) -> Expr:
                 res_b = int_to_tc(res_i, width)
                 # charge for both operands' byte widths
                 if not meter.charge_bytes(len(a_b) + len(b_b)):
-                    return Expr.Error("meter limit")
+                    return error_expr("low_eval", "meter limit")
                 stack.append(res_b)
                 continue
 
             # ---------- NAND ----------
             if tok == b"nand":
                 if len(stack) < 2:
-                    return Expr.Error("underflow")
+                    return error_expr("low_eval", "underflow")
                 b_b = stack.pop()
                 a_b = stack.pop()
                 res_b = nand_bytes(a_b, b_b)
                 # bitwise cost: 2 * max(len(a), len(b))
                 if not meter.charge_bytes(2 * max(len(a_b), len(b_b), 1)):
-                    return Expr.Error("meter limit")
+                    return error_expr("low_eval", "meter limit")
                 stack.append(res_b)
                 continue
 
             # ---------- JUMP ----------
             if tok == b"jump":
                 if len(stack) < 1:
-                    return Expr.Error("underflow")
+                    return error_expr("low_eval", "underflow")
                 tgt_b = stack.pop()
                 if not meter.charge_bytes(1):
-                    return Expr.Error("meter limit")
+                    return error_expr("low_eval", "meter limit")
                 tgt_i = tc_to_int(tgt_b)
                 if tgt_i < 0 or tgt_i >= len(code):
-                    return Expr.Error("bad jump")
+                    return error_expr("low_eval", "bad jump")
                 pc = tgt_i
                 continue
 
             # ---------- HEAP GET ----------
             if tok == b"heap_get":
                 if len(stack) < 1:
-                    return Expr.Error("underflow")
+                    return error_expr("low_eval", "underflow")
                 key = stack.pop()
                 val = heap.get(key) or b""
                 # get cost: 1
                 if not meter.charge_bytes(1):
-                    return Expr.Error("meter limit")
+                    return error_expr("low_eval", "meter limit")
                 stack.append(val)
                 continue
 
             # ---------- HEAP SET ----------
             if tok == b"heap_set":
                 if len(stack) < 2:
-                    return Expr.Error("underflow")
+                    return error_expr("low_eval", "underflow")
                 val = stack.pop()
                 key = stack.pop()
                 if not meter.charge_bytes(len(val)):
-                    return Expr.Error("meter limit")
+                    return error_expr("low_eval", "meter limit")
                 heap[key] = val
                 continue
 

astreum/_lispeum/parser.py

@@ -1,5 +1,5 @@
-from typing import List, Tuple
-from src.astreum._lispeum import Expr
+from typing import List, Tuple
+from . import Expr
 
 class ParseError(Exception):
     pass
@@ -14,12 +14,7 @@ def _parse_one(tokens: List[str], pos: int = 0) -> Tuple[Expr, int]:
         i = pos + 1
         while i < len(tokens):
             if tokens[i] == ')':
-                # special-case error form at close: (origin topic err) or (topic err)
-                if len(items) >= 3 and isinstance(items[-1], Expr.Symbol) and items[-1].value == 'err' and isinstance(items[-2], Expr.Symbol):
-                    return Expr.Error(items[-2].value, origin=items[-3]), i + 1
-                if len(items) == 2 and isinstance(items[-1], Expr.Symbol) and items[-1].value == 'err' and isinstance(items[-2], Expr.Symbol):
-                    return Expr.Error(items[-2].value), i + 1
-                return Expr.ListExpr(items), i + 1
+                return Expr.ListExpr(items), i + 1
             expr, i = _parse_one(tokens, i)
             items.append(expr)
         raise ParseError("expected ')'")
@@ -27,30 +22,30 @@ def _parse_one(tokens: List[str], pos: int = 0) -> Tuple[Expr, int]:
     if tok == ')':
         raise ParseError("unexpected ')'")
 
-    # try integer → Bytes (variable-length two's complement)
-    try:
-        n = int(tok)
-        # encode as minimal-width signed two's complement, big-endian
-        def int_to_min_tc(v: int) -> bytes:
-            """Return the minimal-width signed two's complement big-endian
-            byte encoding of integer v. Width expands just enough so that
-            decoding with signed=True yields the same value and sign.
-            Example: 0 -> b"\x00", 127 -> b"\x7f", 128 -> b"\x00\x80".
-            """
-            if v == 0:
-                return b"\x00"
-            w = 1
-            while True:
-                try:
-                    return v.to_bytes(w, "big", signed=True)
-                except OverflowError:
-                    w += 1
-
-        return Expr.Bytes(int_to_min_tc(n)), pos + 1
-    except ValueError:
-        return Expr.Symbol(tok), pos + 1
+    # try integer → Bytes (variable-length two's complement)
+    try:
+        n = int(tok)
+        # encode as minimal-width signed two's complement, big-endian
+        def int_to_min_tc(v: int) -> bytes:
+            """Return the minimal-width signed two's complement big-endian
+            byte encoding of integer v. Width expands just enough so that
+            decoding with signed=True yields the same value and sign.
+            Example: 0 -> b"\x00", 127 -> b"\x7f", 128 -> b"\x00\x80".
+            """
+            if v == 0:
+                return b"\x00"
+            w = 1
+            while True:
+                try:
+                    return v.to_bytes(w, "big", signed=True)
+                except OverflowError:
+                    w += 1
+
+        return Expr.Bytes(int_to_min_tc(n)), pos + 1
+    except ValueError:
+        return Expr.Symbol(tok), pos + 1
 
 def parse(tokens: List[str]) -> Tuple[Expr, List[str]]:
     """Parse tokens into an Expr and return (expr, remaining_tokens)."""
     expr, next_pos = _parse_one(tokens, 0)
-    return expr, tokens[next_pos:]
+    return expr, tokens[next_pos:]