sonolus.py 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

sonolus/backend/excepthook.py

@@ -1,37 +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
+"""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

@@ -1,69 +1,77 @@
-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}")
+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.optimize.flow import BasicBlock, traverse_cfg_reverse_postorder
+from sonolus.backend.place import BlockPlace
+
+
+def cfg_to_engine_node(entry: BasicBlock):
+    block_indexes = {block: i for i, block in enumerate(traverse_cfg_reverse_postorder(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 targets:
+                args = [ir_to_engine_node(block.test)]
+                default = len(block_indexes)
+                conds = [cond for cond in targets if cond is not None]
+                if min(conds) == 0 and max(conds) == len(conds) - 1 and all(int(cond) == cond for cond in conds):
+                    args.extend(ConstantNode(value=block_indexes[targets[cond]]) for cond in range(len(conds)))
+                    if None in targets:
+                        default = block_indexes[targets[None]]
+                    args.append(ConstantNode(value=default))
+                    statements.append(FunctionNode(Op.SwitchIntegerWithDefault, args))
+                else:
+                    for cond, target in targets.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/interpret.py

@@ -62,16 +62,16 @@ class Interpreter:
                 return self.run(default)
             case Op.SwitchInteger:
                 test, *branches = args
-                test_result = int(self.run(test))
-                if 0 <= test_result < len(branches):
+                test_result = self.run(test)
+                if 0 <= test_result < len(branches) and int(test_result) == test_result:
                     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])
+                test_result = self.run(test)
+                if 0 <= test_result < len(branches) and int(test_result) == test_result:
+                    return self.run(branches[int(test_result)])
                 else:
                     return self.run(default)
             case Op.While:
@@ -242,10 +242,10 @@ class Interpreter:
                 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()
+                return random.uniform(lo, hi)
             case Op.RandomInteger:
                 lo, hi = (self.ensure_int(self.run(arg)) for arg in args)
-                return random.randint(lo, hi)
+                return random.randrange(lo, hi)
             case Op.Rem:
                 return self.reduce_args(args, math.remainder)
             case Op.Remap:

sonolus/backend/ir.py

@@ -6,9 +6,11 @@ type IRStmt = IRExpr | IRInstr | IRSet
 
 
 class IRConst:
-    value: float
+    value: float | int
 
     def __init__(self, value: float):
+        if isinstance(value, bool):
+            value = int(value)
         self.value = value
 
     def __repr__(self):
@@ -39,6 +41,12 @@ class IRPureInstr:
     def __str__(self):
         return f"{self.op.name}({', '.join(map(str, self.args))})"
 
+    def __eq__(self, other):
+        return isinstance(other, IRPureInstr) and self.op == other.op and self.args == other.args
+
+    def __hash__(self):
+        return hash((self.op, tuple(self.args)))
+
 
 class IRInstr:
     op: Op
@@ -54,6 +62,12 @@ class IRInstr:
     def __str__(self):
         return f"{self.op.name}({', '.join(map(str, self.args))})"
 
+    def __eq__(self, other):
+        return isinstance(other, IRInstr) and self.op == other.op and self.args == other.args
+
+    def __hash__(self):
+        return hash((self.op, tuple(self.args)))
+
 
 class IRGet:
     place: Place
@@ -67,12 +81,18 @@ class IRGet:
     def __str__(self):
         return f"{self.place}"
 
+    def __eq__(self, other):
+        return isinstance(other, IRGet) and self.place == other.place
+
+    def __hash__(self):
+        return hash(self.place)
+
 
 class IRSet:
     place: Place
-    value: IRStmt
+    value: IRExpr | IRInstr
 
-    def __init__(self, place: Place, value: IRStmt):
+    def __init__(self, place: Place, value: IRExpr | IRInstr):
         self.place = place
         self.value = value
 
@@ -87,3 +107,9 @@ class IRSet:
                 return f"{self.place} := {self.value}"
             case _:
                 raise TypeError(f"Invalid place: {self.place}")
+
+    def __eq__(self, other):
+        return isinstance(other, IRSet) and self.place == other.place and self.value == other.value
+
+    def __hash__(self):
+        return hash((self.place, self.value))

sonolus/backend/mode.py

@@ -1,24 +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)
+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

@@ -1,40 +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}")
+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}")