sonolus.py 0.1.0__py3-none-any.whl

sonolus/backend/excepthook.py

@@ -0,0 +1,37 @@
+"""Exception hook to filter out compiler internal frames from tracebacks."""
+
+import sys
+from types import TracebackType
+
+
+def should_filter_traceback(tb: TracebackType | None) -> bool:
+    return tb is not None and (
+        tb.tb_frame.f_globals.get("_filter_traceback_", False) or should_filter_traceback(tb.tb_next)
+    )
+
+
+def is_compiler_internal(tb: TracebackType):
+    return tb.tb_frame.f_locals.get("_compiler_internal_", False) or tb.tb_frame.f_globals.get(
+        "_compiler_internal_", False
+    )
+
+
+def filter_traceback(tb: TracebackType | None) -> TracebackType | None:
+    if tb is None:
+        return None
+    if is_compiler_internal(tb):
+        return filter_traceback(tb.tb_next)
+    tb.tb_next = filter_traceback(tb.tb_next)
+    return tb
+
+
+def excepthook(exc, value, tb):
+    import traceback
+
+    if should_filter_traceback(tb):
+        tb = filter_traceback(tb)
+    traceback.print_exception(exc, value, tb)
+
+
+def install_excepthook():
+    sys.excepthook = excepthook

sonolus/backend/finalize.py

@@ -0,0 +1,69 @@
+from sonolus.backend.flow import BasicBlock, traverse_cfg_preorder
+from sonolus.backend.ir import IRConst, IRGet, IRInstr, IRPureInstr, IRSet
+from sonolus.backend.node import ConstantNode, EngineNode, FunctionNode
+from sonolus.backend.ops import Op
+from sonolus.backend.place import BlockPlace
+
+
+def cfg_to_engine_node(entry: BasicBlock):
+    block_indexes = {block: i for i, block in enumerate(traverse_cfg_preorder(entry))}
+    block_statements = []
+    for block in block_indexes:
+        statements = []
+        statements.extend(ir_to_engine_node(stmt) for stmt in block.statements)
+        outgoing = {edge.cond: edge.dst for edge in block.outgoing}
+        match outgoing:
+            case {**other} if not other:
+                statements.append(ConstantNode(value=len(block_indexes)))
+            case {None: target, **other} if not other:
+                statements.append(ConstantNode(value=block_indexes[target]))
+            case {0: f_branch, None: t_branch, **other} if not other:
+                statements.append(
+                    FunctionNode(
+                        func=Op.If,
+                        args=[
+                            ir_to_engine_node(block.test),
+                            ConstantNode(value=block_indexes[t_branch]),
+                            ConstantNode(value=block_indexes[f_branch]),
+                        ],
+                    )
+                )
+            case dict() as tgt:
+                args = [ir_to_engine_node(block.test)]
+                default = len(block_indexes)
+                for cond, target in tgt.items():
+                    if cond is None:
+                        default = block_indexes[target]
+                    args.append(ConstantNode(value=cond))
+                    args.append(ConstantNode(value=block_indexes[target]))
+                args.append(ConstantNode(value=default))
+                statements.append(FunctionNode(Op.SwitchWithDefault, args))
+        block_statements.append(FunctionNode(Op.Execute, statements))
+    block_statements.append(ConstantNode(value=0))
+    return FunctionNode(Op.Block, [FunctionNode(Op.JumpLoop, block_statements)])
+
+
+def ir_to_engine_node(stmt) -> EngineNode:
+    match stmt:
+        case int() | float():
+            return ConstantNode(value=float(stmt))
+        case IRConst(value=value):
+            return ConstantNode(value=value)
+        case IRPureInstr(op=op, args=args) | IRInstr(op=op, args=args):
+            return FunctionNode(func=op, args=[ir_to_engine_node(arg) for arg in args])
+        case IRGet(place=place):
+            return ir_to_engine_node(place)
+        case BlockPlace() as place:
+            if place.offset == 0:
+                index = ir_to_engine_node(place.index)
+            elif place.index == 0:
+                index = ConstantNode(value=place.offset)
+            else:
+                index = FunctionNode(
+                    func=Op.Add, args=[ir_to_engine_node(place.index), ConstantNode(value=place.offset)]
+                )
+            return FunctionNode(func=Op.Get, args=[ir_to_engine_node(place.block), index])
+        case IRSet(place=place, value=value):
+            return FunctionNode(func=Op.Set, args=[*ir_to_engine_node(place).args, ir_to_engine_node(value)])
+        case _:
+            raise TypeError(f"Unsupported IR statement: {stmt}")

sonolus/backend/flow.py

@@ -0,0 +1,92 @@
+import textwrap
+from collections import deque
+from collections.abc import Iterator
+
+from sonolus.backend.ir import IRConst, IRExpr, IRStmt
+
+
+class FlowEdge:
+    src: "BasicBlock"
+    dst: "BasicBlock"
+    cond: IRExpr | None
+
+    def __init__(self, src: "BasicBlock", dst: "BasicBlock", cond: IRExpr | None = None):
+        self.src = src
+        self.dst = dst
+        self.cond = cond
+
+
+class BasicBlock:
+    statements: list[IRStmt]
+    test: IRExpr
+    incoming: set[FlowEdge]
+    outgoing: set[FlowEdge]
+
+    def __init__(
+        self,
+        statements: list[IRStmt] | None = None,
+        test: IRExpr | None = None,
+        incoming: set[FlowEdge] | None = None,
+        outgoing: set[FlowEdge] | None = None,
+    ):
+        self.statements = statements or []
+        self.test = test or IRConst(1)
+        self.incoming = incoming or set()
+        self.outgoing = outgoing or set()
+
+    def connect_to(self, other: "BasicBlock", cond: IRExpr | None = None):
+        edge = FlowEdge(self, other, cond)
+        self.outgoing.add(edge)
+        other.incoming.add(edge)
+
+
+def traverse_cfg_preorder(block: BasicBlock) -> Iterator[BasicBlock]:
+    visited = set()
+    queue = deque([block])
+    while queue:
+        block = queue.popleft()
+        if block in visited:
+            continue
+        visited.add(block)
+        yield block
+        for edge in sorted(block.outgoing, key=lambda e: (e.cond is None, e.cond)):
+            queue.append(edge.dst)
+
+
+def cfg_to_mermaid(entry: BasicBlock):
+    def pre(s: str):
+        return "\"<pre style='text-align: left;'>" + s.replace("\n", "<br/>") + '</pre>"'
+
+    def fmt(nodes):
+        if nodes:
+            return "\n".join(str(n) for n in nodes)
+        else:
+            return "{}"
+
+    block_indexes = {block: i for i, block in enumerate(traverse_cfg_preorder(entry))}
+
+    lines = ["Entry([Entry]) --> 0"]
+    for block in traverse_cfg_preorder(entry):
+        index = block_indexes[block]
+        lines.append(f"{index}[{pre(fmt([f'#{index}', *block.statements]))}]")
+
+        outgoing = {edge.cond: edge.dst for edge in block.outgoing}
+        match outgoing:
+            case {**other} if not other:
+                lines.append(f"{index} --> Exit")
+            case {None: target, **other} if not other:
+                lines.append(f"{index} --> {block_indexes[target]}")
+            case {0: f_branch, None: t_branch, **other} if not other:
+                lines.append(f"{index}_{{{pre(fmt([block.test]))}}}")
+                lines.append(f"{index} --> {index}_")
+                lines.append(f"{index}_ --> |true| {block_indexes[t_branch]}")
+                lines.append(f"{index}_ --> |false| {block_indexes[f_branch]}")
+            case dict() as tgt:
+                lines.append(f"{index}_{{{{{pre(fmt([block.test]))}}}}}")
+                lines.append(f"{index} --> {index}_")
+                for cond, target in tgt.items():
+                    lines.append(f"{index}_ --> |{pre(fmt([cond or "default"]))}| {block_indexes[target]}")
+    lines.append("Exit([Exit])")
+
+    body = textwrap.indent("\n".join(lines), "    ")
+    return f"graph\n{body}"

sonolus/backend/interpret.py

@@ -0,0 +1,333 @@
+import math
+import operator
+import random
+
+from sonolus.backend.node import ConstantNode, EngineNode
+from sonolus.backend.ops import Op
+
+
+class BreakException(Exception):  # noqa: N818
+    n: int
+    value: float
+
+    def __init__(self, n: int, value: float):
+        self.n = n
+        self.value = value
+
+
+class Interpreter:
+    blocks: dict[int, list[int]]
+    log: list[float]
+
+    def __init__(self):
+        self.blocks = {}
+        self.log = []
+
+    def run(self, node: EngineNode) -> float:
+        if isinstance(node, ConstantNode):
+            return node.value
+        func = node.func
+        args = node.args
+        match func:
+            case Op.Execute:
+                result = 0.0
+                for arg in args:
+                    result = self.run(arg)
+                return result
+            case Op.Execute0:
+                for arg in args:
+                    self.run(arg)
+                return 0.0
+            case Op.If:
+                test, t_branch, f_branch = args
+                if self.run(test) != 0.0:
+                    return self.run(t_branch)
+                else:
+                    return self.run(f_branch)
+            case Op.Switch:
+                test, *branches = args
+                test_result = self.run(test)
+                for i in range(0, len(branches), 2):
+                    case, branch = branches[i], branches[i + 1]
+                    if test_result == self.run(case):
+                        return self.run(branch)
+                return 0.0
+            case Op.SwitchWithDefault:
+                test, *branches, default = args
+                test_result = self.run(test)
+                for i in range(0, len(branches), 2):
+                    case, branch = branches[i], branches[i + 1]
+                    if test_result == self.run(case):
+                        return self.run(branch)
+                return self.run(default)
+            case Op.SwitchInteger:
+                test, *branches = args
+                test_result = int(self.run(test))
+                if 0 <= test_result < len(branches):
+                    return self.run(branches[test_result])
+                else:
+                    return 0.0
+            case Op.SwitchIntegerWithDefault:
+                test, *branches, default = args
+                test_result = int(self.run(test))
+                if 0 <= test_result < len(branches):
+                    return self.run(branches[test_result])
+                else:
+                    return self.run(default)
+            case Op.While:
+                test, body = args
+                while self.run(test) != 0.0:
+                    self.run(body)
+                return 0.0
+            case Op.DoWhile:
+                body, test = args
+                while True:
+                    self.run(body)
+                    if self.run(test) == 0.0:
+                        break
+                return 0.0
+            case Op.And:
+                result = 0.0
+                for arg in args:
+                    result = self.run(arg)
+                    if result == 0.0:
+                        break
+                return result
+            case Op.Or:
+                result = 0.0
+                for arg in args:
+                    result = self.run(arg)
+                    if result != 0.0:
+                        break
+                return result
+            case Op.JumpLoop:
+                index = 0
+                while 0 <= index < len(args):
+                    if index == len(args) - 1:
+                        return self.run(args[index])
+                    index = int(self.run(args[index]))
+                return 0.0
+            case Op.Block:
+                try:
+                    return self.run(args[0])
+                except BreakException as e:
+                    if e.n > 1:
+                        e.n -= 1
+                        raise e from None
+                    return e.value
+            case Op.Break:
+                raise BreakException(self.ensure_int(self.run(args[0])), self.run(args[1]))
+
+            case Op.Abs:
+                return abs(self.run(args[0]))
+            case Op.Add:
+                return self.reduce_args(args, operator.add)
+            case Op.Arccos:
+                return math.acos(self.run(args[0]))
+            case Op.Arcsin:
+                return math.asin(self.run(args[0]))
+            case Op.Arctan:
+                return math.atan(self.run(args[0]))
+            case Op.Arctan2:
+                return math.atan2(self.run(args[0]), self.run(args[1]))
+            case Op.Ceil:
+                return math.ceil(self.run(args[0]))
+            case Op.Clamp:
+                x, a, b = (self.run(arg) for arg in args)
+                return max(a, min(b, x))
+            case Op.Copy:
+                src_id, src_index, dst_id, dst_index, count = (self.ensure_int(self.run(arg)) for arg in args)
+                assert count >= 0, "Count must be non-negative"
+                values = [self.get(src_id, src_index + i) for i in range(count)]
+                for i, value in enumerate(values):
+                    self.set(dst_id, dst_index + i, value)
+                return 0.0
+            case Op.Cos:
+                return math.cos(self.run(args[0]))
+            case Op.Cosh:
+                return math.cosh(self.run(args[0]))
+            case Op.DebugLog:
+                value = self.run(args[0])
+                self.log.append(value)
+                return 0.0
+            case Op.DebugPause:
+                return 0.0
+            case Op.Degree:
+                return math.degrees(self.run(args[0]))
+            case Op.Divide:
+                return self.reduce_args(args, operator.truediv)
+            case Op.Equal:
+                return 1.0 if self.run(args[0]) == self.run(args[1]) else 0.0
+            case Op.Floor:
+                return math.floor(self.run(args[0]))
+            case Op.Frac:
+                result = self.run(args[0]) % 1
+                return result if result >= 0 else result + 1
+            case Op.Get:
+                block, index = (self.ensure_int(self.run(arg)) for arg in args)
+                return self.get(block, index)
+            case Op.GetPointed:
+                block, index, offset = (self.ensure_int(self.run(arg)) for arg in args)
+                return self.get(self.get(block, index), self.get(block, index + 1) + offset)
+            case Op.GetShifted:
+                block, offset, index, stride = (self.ensure_int(self.run(arg)) for arg in args)
+                return self.get(block, offset + index * stride)
+            case Op.Greater:
+                return 1.0 if self.run(args[0]) > self.run(args[1]) else 0.0
+            case Op.GreaterOr:
+                return 1.0 if self.run(args[0]) >= self.run(args[1]) else 0.0
+            case Op.IncrementPost:
+                block, index = (self.ensure_int(self.run(arg)) for arg in args)
+                value = self.get(block, index)
+                self.set(block, index, value + 1)
+                return value
+            case Op.IncrementPostPointed:
+                block, index, offset = (self.ensure_int(self.run(arg)) for arg in args)
+                deref_block = self.get(block, index)
+                deref_index = self.get(block, index + 1) + offset
+                value = self.get(deref_block, deref_index)
+                self.set(deref_block, deref_index, value + 1)
+                return value
+            case Op.IncrementPostShifted:
+                block, offset, index, stride = (self.ensure_int(self.run(arg)) for arg in args)
+                value = self.get(block, offset + index * stride)
+                self.set(block, offset + index * stride, value + 1)
+                return value
+            case Op.IncrementPre:
+                block, index = (self.ensure_int(self.run(arg)) for arg in args)
+                value = self.get(block, index) + 1
+                self.set(block, index, value)
+                return value
+            case Op.IncrementPrePointed:
+                block, index, offset = (self.ensure_int(self.run(arg)) for arg in args)
+                deref_block = self.get(block, index)
+                deref_index = self.get(block, index + 1) + offset
+                value = self.get(deref_block, deref_index) + 1
+                self.set(deref_block, deref_index, value)
+                return value
+            case Op.IncrementPreShifted:
+                block, offset, index, stride = (self.ensure_int(self.run(arg)) for arg in args)
+                value = self.get(block, offset + index * stride) + 1
+                self.set(block, offset + index * stride, value)
+                return value
+            case Op.Lerp:
+                x, y, s = (self.run(arg) for arg in args)
+                return x + (y - x) * s
+            case Op.LerpClamped:
+                x, y, s = (self.run(arg) for arg in args)
+                return x + (y - x) * max(0, min(1, s))
+            case Op.Less:
+                return 1.0 if self.run(args[0]) < self.run(args[1]) else 0.0
+            case Op.LessOr:
+                return 1.0 if self.run(args[0]) <= self.run(args[1]) else 0.0
+            case Op.Log:
+                return math.log(self.run(args[0]))
+            case Op.Max:
+                return max(self.run(args[0]), self.run(args[1]))
+            case Op.Min:
+                return min(self.run(args[0]), self.run(args[1]))
+            case Op.Mod:
+                return self.reduce_args(args, operator.mod)
+            case Op.Multiply:
+                return self.reduce_args(args, operator.mul)
+            case Op.Negate:
+                return -self.run(args[0])
+            case Op.Not:
+                return 1.0 if self.run(args[0]) == 0.0 else 0.0
+            case Op.NotEqual:
+                return 1.0 if self.run(args[0]) != self.run(args[1]) else 0.0
+            case Op.Power:
+                return self.reduce_args(args, operator.pow)
+            case Op.Radian:
+                return math.radians(self.run(args[0]))
+            case Op.Random:
+                lo, hi = (self.run(arg) for arg in args)
+                return lo + (hi - lo) * random.random()
+            case Op.RandomInteger:
+                lo, hi = (self.ensure_int(self.run(arg)) for arg in args)
+                return random.randint(lo, hi)
+            case Op.Rem:
+                return self.reduce_args(args, math.remainder)
+            case Op.Remap:
+                from_min, from_max, to_min, to_max, value = (self.run(arg) for arg in args)
+                return to_min + (to_max - to_min) * (value - from_min) / (from_max - from_min)
+            case Op.RemapClamped:
+                from_min, from_max, to_min, to_max, value = (self.run(arg) for arg in args)
+                return to_min + (to_max - to_min) * max(0, min(1, (value - from_min) / (from_max - from_min)))
+            case Op.Round:
+                return round(self.run(args[0]))
+            case Op.Set:
+                block, index, value = (self.run(arg) for arg in args)
+                block, index = self.ensure_int(block), self.ensure_int(index)
+                return self.set(block, index, value)
+            case Op.SetPointed:
+                block, index, offset, value = (self.run(arg) for arg in args)
+                block, index, offset = self.ensure_int(block), self.ensure_int(index), self.ensure_int(offset)
+                return self.set(self.get(block, index), self.get(block, index + 1) + offset, value)
+            case Op.SetShifted:
+                block, offset, index, stride, value = (self.run(arg) for arg in args)
+                block, offset, index, stride = (
+                    self.ensure_int(block),
+                    self.ensure_int(offset),
+                    self.ensure_int(index),
+                    self.ensure_int(stride),
+                )
+
+                return self.set(block, offset + index * stride, value)
+            case Op.Sign:
+                return math.copysign(1, self.run(args[0]))
+            case Op.Sin:
+                return math.sin(self.run(args[0]))
+            case Op.Sinh:
+                return math.sinh(self.run(args[0]))
+            case Op.Subtract:
+                return self.reduce_args(args, operator.sub)
+            case Op.Tan:
+                return math.tan(self.run(args[0]))
+            case Op.Tanh:
+                return math.tanh(self.run(args[0]))
+            case Op.Trunc:
+                return math.trunc(self.run(args[0]))
+            case Op.Unlerp:
+                lo, hi, value = (self.run(arg) for arg in args)
+                return (value - lo) / (hi - lo)
+            case Op.UnlerpClamped:
+                lo, hi, value = (self.run(arg) for arg in args)
+                return max(0, min(1, (value - lo) / (hi - lo)))
+            case _:
+                raise NotImplementedError(f"Unsupported operation: {func}")
+
+    def reduce_args(self, args: list[EngineNode], operator) -> float:
+        if not args:
+            return 0.0
+        acc, *rest = (self.run(arg) for arg in args)
+        for arg in rest:
+            acc = operator(acc, arg)
+        return acc
+
+    def get(self, block: float, index: float) -> float:
+        block = self.ensure_int(block)
+        index = self.ensure_int(index)
+        assert index >= 0, "Index must be non-negative"
+        assert index <= 65535, "Index is too large"
+        if block not in self.blocks:
+            self.blocks[block] = []
+        if len(self.blocks[block]) <= index:
+            self.blocks[block] += [-1.0] * (index - len(self.blocks[block]) + 1)
+        return self.blocks[block][index]
+
+    def set(self, block: float, index: float, value: float):
+        block = self.ensure_int(block)
+        index = self.ensure_int(index)
+        assert index >= 0, "Index must be non-negative"
+        assert index <= 65535, "Index is too large"
+        if block not in self.blocks:
+            self.blocks[block] = []
+        if len(self.blocks[block]) <= index:
+            self.blocks[block] += [-1.0] * (index - len(self.blocks[block]) + 1)
+        self.blocks[block][index] = value
+        return value
+
+    def ensure_int(self, value: float) -> int:
+        assert value == int(value), "Value must be an integer"
+        return int(value)

sonolus/backend/ir.py

@@ -0,0 +1,89 @@
+from sonolus.backend.ops import Op
+from sonolus.backend.place import BlockPlace, Place, SSAPlace
+
+type IRExpr = IRConst | IRPureInstr | IRGet
+type IRStmt = IRExpr | IRInstr | IRSet
+
+
+class IRConst:
+    value: float
+
+    def __init__(self, value: float):
+        self.value = value
+
+    def __repr__(self):
+        return f"IRConst({self.value!r})"
+
+    def __str__(self):
+        return f"{self.value}"
+
+    def __eq__(self, other):
+        return isinstance(other, IRConst) and self.value == other.value
+
+    def __hash__(self):
+        return hash(self.value)
+
+
+class IRPureInstr:
+    op: Op
+    args: list[IRExpr]
+
+    def __init__(self, op: Op, args: list[IRExpr]):
+        assert op.pure
+        self.op = op
+        self.args = args
+
+    def __repr__(self):
+        return f"IRPureInstr({self.op!r}, {self.args!r})"
+
+    def __str__(self):
+        return f"{self.op.name}({', '.join(map(str, self.args))})"
+
+
+class IRInstr:
+    op: Op
+    args: list[IRExpr]
+
+    def __init__(self, op: Op, args: list[IRExpr]):
+        self.op = op
+        self.args = args
+
+    def __repr__(self):
+        return f"IRInstr({self.op!r}, {self.args!r})"
+
+    def __str__(self):
+        return f"{self.op.name}({', '.join(map(str, self.args))})"
+
+
+class IRGet:
+    place: Place
+
+    def __init__(self, place: Place):
+        self.place = place
+
+    def __repr__(self):
+        return f"IRGet({self.place!r})"
+
+    def __str__(self):
+        return f"{self.place}"
+
+
+class IRSet:
+    place: Place
+    value: IRStmt
+
+    def __init__(self, place: Place, value: IRStmt):
+        self.place = place
+        self.value = value
+
+    def __repr__(self):
+        return f"IRSet({self.place!r}, {self.value!r})"
+
+    def __str__(self):
+        match self.place:
+            case BlockPlace():
+                return f"{self.place} <- {self.value}"
+            case SSAPlace():
+                return f"{self.place} := {self.value}"
+            case _:
+                raise TypeError(f"Invalid place: {self.place}")

sonolus/backend/mode.py

@@ -0,0 +1,24 @@
+from enum import Enum
+from functools import cached_property
+
+from sonolus.backend.blocks import Block, PlayBlock, PreviewBlock, TutorialBlock, WatchBlock
+
+
+class Mode(Enum):
+    blocks: type[Block]
+
+    Play = (PlayBlock,)
+    Watch = (WatchBlock,)
+    Preview = (PreviewBlock,)
+    Tutorial = (TutorialBlock,)
+
+    def __init__(self, blocks: type[Block]):
+        self.blocks = blocks
+
+    @cached_property
+    def callbacks(self) -> frozenset[str]:
+        cbs = set()
+        for block in self.blocks:
+            cbs.update(block.readable)
+            cbs.update(block.writable)
+        return frozenset(cbs)

sonolus/backend/node.py

@@ -0,0 +1,40 @@
+import textwrap
+from dataclasses import dataclass
+
+from sonolus.backend.ops import Op
+
+type EngineNode = ConstantNode | FunctionNode
+
+
+@dataclass
+class ConstantNode:
+    value: float
+
+    def __hash__(self):
+        return hash(self.value)
+
+
+@dataclass
+class FunctionNode:
+    func: Op
+    args: list[EngineNode]
+
+    def __hash__(self):
+        return hash((self.func, tuple(self.args)))
+
+
+def format_engine_node(node: EngineNode) -> str:
+    if isinstance(node, ConstantNode):
+        return str(node.value)
+    elif isinstance(node, FunctionNode):
+        match len(node.args):
+            case 0:
+                return f"{node.func.name}()"
+            case 1:
+                return f"{node.func.name}({format_engine_node(node.args[0])})"
+            case _:
+                return f"{node.func.name}(\n{
+                    textwrap.indent("\n".join(format_engine_node(arg) for arg in node.args), "  ")
+                }\n)"
+    else:
+        raise ValueError(f"Invalid engine node: {node}")