machine-dialect 0.1.0a1__py3-none-any.whl

machine_dialect/codegen/bytecode_module.py

@@ -0,0 +1,89 @@
+"""Bytecode module representation.
+
+This module defines the bytecode module structure for the Rust VM.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import IntEnum
+from typing import Any
+
+
+class ChunkType(IntEnum):
+    """Type of bytecode chunk."""
+
+    MAIN = 0
+    FUNCTION = 1
+
+
+class ConstantTag(IntEnum):
+    """Tags for constant pool values."""
+
+    EMPTY = 0x05
+    INT = 0x01
+    FLOAT = 0x02
+    STRING = 0x03
+    BOOL = 0x04
+
+
+@dataclass
+class Chunk:
+    """A bytecode chunk (function or main)."""
+
+    name: str
+    chunk_type: ChunkType
+    bytecode: bytearray
+    constants: list[tuple[ConstantTag, Any]]
+    num_locals: int
+    num_params: int
+
+
+@dataclass
+class BytecodeModule:
+    """A complete bytecode module."""
+
+    name: str = "__main__"
+    chunks: list[Chunk] = field(default_factory=list)
+    function_table: dict[str, int] = field(default_factory=dict)
+    global_names: list[str] = field(default_factory=list)
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+    def add_chunk(self, chunk: Chunk) -> int:
+        """Add a chunk and return its index.
+
+        Args:
+            chunk: Chunk to add.
+
+        Returns:
+            Index of the added chunk.
+        """
+        index = len(self.chunks)
+        self.chunks.append(chunk)
+        if chunk.chunk_type == ChunkType.FUNCTION:
+            # Record function entry point (bytecode offset)
+            self.function_table[chunk.name] = index
+        return index
+
+    def add_global(self, name: str) -> int:
+        """Add a global name and return its index.
+
+        Args:
+            name: Global name to add.
+
+        Returns:
+            Index of the global name.
+        """
+        if name not in self.global_names:
+            self.global_names.append(name)
+        return self.global_names.index(name)
+
+    def serialize(self) -> bytes:
+        """Serialize the module to bytecode format.
+
+        Returns:
+            Serialized bytecode.
+        """
+        from machine_dialect.codegen.vm_serializer import VMBytecodeSerializer
+
+        return VMBytecodeSerializer.serialize(self)

machine_dialect/codegen/bytecode_serializer.py

@@ -0,0 +1,300 @@
+"""Bytecode serializer for the Rust VM.
+
+This module serializes bytecode in the format expected by the Rust VM loader.
+"""
+
+from __future__ import annotations
+
+import struct
+from io import BytesIO
+from pathlib import Path
+from typing import Any, BinaryIO
+
+# Magic number for bytecode files
+MAGIC_NUMBER = b"MDBC"
+
+# Current bytecode version
+BYTECODE_VERSION = 1
+
+# Flags
+FLAG_LITTLE_ENDIAN = 0x0001
+
+
+class BytecodeWriter:
+    """Writes bytecode in the format expected by the Rust VM."""
+
+    def __init__(self, module: Any = None) -> None:
+        """Initialize the bytecode writer.
+
+        Args:
+            module: Optional module with bytecode data to write
+        """
+        self.buffer = BytesIO()
+
+        # Initialize attributes with type hints
+        self.constants: list[tuple[int, Any]]
+        self.instructions: list[bytes]
+        self.functions: dict[str, int]
+        self.global_names: list[str]
+        self.module_name: str
+
+        if module:
+            # Just use the module's attributes directly
+            self.constants = module.constants
+            self.instructions = module.instructions
+            self.functions = getattr(module, "function_table", {})
+            self.global_names = getattr(module, "global_names", [])
+            self.module_name = getattr(module, "name", "__main__")
+        else:
+            self.constants = []  # (tag, value) pairs
+            self.instructions = []
+            self.functions = {}  # name -> instruction offset
+            self.global_names = []
+            self.module_name = "__main__"
+
+    def set_module_name(self, name: str) -> None:
+        """Set the module name."""
+        self.module_name = name
+
+    def add_constant(self, tag: int, value: Any) -> int:
+        """Add a constant to the constant pool.
+
+        Args:
+            tag: Type tag (1=int, 2=float, 3=string, 4=bool, 5=empty)
+            value: The constant value
+
+        Returns:
+            Index of the constant in the pool
+        """
+        idx = len(self.constants)
+        self.constants.append((tag, value))
+        return idx
+
+    def add_int_constant(self, value: int) -> int:
+        """Add an integer constant."""
+        return self.add_constant(0x01, value)
+
+    def add_float_constant(self, value: float) -> int:
+        """Add a float constant."""
+        return self.add_constant(0x02, value)
+
+    def add_string_constant(self, value: str) -> int:
+        """Add a string constant."""
+        return self.add_constant(0x03, value)
+
+    def add_bool_constant(self, value: bool) -> int:
+        """Add a boolean constant."""
+        return self.add_constant(0x04, value)
+
+    def add_empty_constant(self) -> int:
+        """Add an empty/none constant."""
+        return self.add_constant(0x05, None)
+
+    def add_global_name(self, name: str) -> int:
+        """Add a global name and return its index."""
+        if name not in self.global_names:
+            self.global_names.append(name)
+        return self.global_names.index(name)
+
+    def add_instruction(self, instruction: bytes) -> None:
+        """Add a raw instruction."""
+        self.instructions.append(instruction)
+
+    def emit_load_const(self, dst: int, const_idx: int) -> None:
+        """Emit LoadConstR instruction."""
+        inst = struct.pack("<BBH", 0, dst, const_idx)
+        self.add_instruction(inst)
+
+    def emit_move(self, dst: int, src: int) -> None:
+        """Emit MoveR instruction."""
+        inst = struct.pack("<BBB", 1, dst, src)
+        self.add_instruction(inst)
+
+    def emit_load_global(self, dst: int, name_idx: int) -> None:
+        """Emit LoadGlobalR instruction."""
+        inst = struct.pack("<BBH", 2, dst, name_idx)
+        self.add_instruction(inst)
+
+    def emit_store_global(self, src: int, name_idx: int) -> None:
+        """Emit StoreGlobalR instruction."""
+        inst = struct.pack("<BBH", 3, src, name_idx)
+        self.add_instruction(inst)
+
+    def emit_add(self, dst: int, left: int, right: int) -> None:
+        """Emit AddR instruction."""
+        inst = struct.pack("<BBBB", 7, dst, left, right)
+        self.add_instruction(inst)
+
+    def emit_sub(self, dst: int, left: int, right: int) -> None:
+        """Emit SubR instruction."""
+        inst = struct.pack("<BBBB", 8, dst, left, right)
+        self.add_instruction(inst)
+
+    def emit_mul(self, dst: int, left: int, right: int) -> None:
+        """Emit MulR instruction."""
+        inst = struct.pack("<BBBB", 9, dst, left, right)
+        self.add_instruction(inst)
+
+    def emit_div(self, dst: int, left: int, right: int) -> None:
+        """Emit DivR instruction."""
+        inst = struct.pack("<BBBB", 10, dst, left, right)
+        self.add_instruction(inst)
+
+    def emit_jump(self, offset: int) -> None:
+        """Emit JumpR instruction."""
+        inst = struct.pack("<Bi", 22, offset)
+        self.add_instruction(inst)
+
+    def emit_jump_if(self, cond: int, offset: int) -> None:
+        """Emit JumpIfR instruction."""
+        inst = struct.pack("<BBi", 23, cond, offset)
+        self.add_instruction(inst)
+
+    def emit_return(self, src: int | None = None) -> None:
+        """Emit ReturnR instruction."""
+        if src is not None:
+            inst = struct.pack("<BBB", 26, 1, src)  # has_value=1, src
+        else:
+            inst = struct.pack("<BB", 26, 0)  # has_value=0
+        self.add_instruction(inst)
+
+    def emit_debug_print(self, src: int) -> None:
+        """Emit DebugPrint instruction."""
+        inst = struct.pack("<BB", 37, src)
+        self.add_instruction(inst)
+
+    def write(self) -> bytes:
+        """Write the bytecode to bytes.
+
+        Returns:
+            The serialized bytecode as bytes.
+        """
+        buffer = BytesIO()
+        self.write_to_stream(buffer)
+        return buffer.getvalue()
+
+    def write_to_file(self, path: Path) -> None:
+        """Write the bytecode to a file.
+
+        Args:
+            path: Path to write the bytecode file (without extension)
+        """
+        bytecode_path = path.with_suffix(".mdbc")
+        with open(bytecode_path, "wb") as f:
+            self.write_to_stream(f)
+
+    def write_to_stream(self, stream: BinaryIO) -> None:
+        """Write the bytecode to a binary stream.
+
+        Args:
+            stream: Binary stream to write to
+        """
+        # Calculate section offsets
+        header_size = 28  # 4 (magic) + 4 (version) + 4 (flags) + 16 (4 offsets)
+
+        # Module name section
+        name_bytes = self.module_name.encode("utf-8")
+        name_section_size = 4 + len(name_bytes)  # length prefix + name
+
+        # Constants section
+        const_buffer = BytesIO()
+        const_buffer.write(struct.pack("<I", len(self.constants)))
+        for tag, value in self.constants:
+            const_buffer.write(struct.pack("<B", tag))
+            if tag == 0x01:  # Int
+                const_buffer.write(struct.pack("<q", value))
+            elif tag == 0x02:  # Float
+                const_buffer.write(struct.pack("<d", value))
+            elif tag == 0x03:  # String
+                str_bytes = value.encode("utf-8")
+                const_buffer.write(struct.pack("<I", len(str_bytes)))
+                const_buffer.write(str_bytes)
+            elif tag == 0x04:  # Bool
+                const_buffer.write(struct.pack("<B", 1 if value else 0))
+            elif tag == 0x05:  # Empty
+                pass  # No data
+        const_data = const_buffer.getvalue()
+
+        # Function table section
+        func_buffer = BytesIO()
+        func_buffer.write(struct.pack("<I", len(self.functions)))
+        for name, offset in self.functions.items():
+            func_name_bytes = name.encode("utf-8")
+            func_buffer.write(struct.pack("<I", len(func_name_bytes)))
+            func_buffer.write(func_name_bytes)
+            func_buffer.write(struct.pack("<I", offset))
+        func_data = func_buffer.getvalue()
+
+        # Instructions section
+        inst_buffer = BytesIO()
+        inst_buffer.write(struct.pack("<I", len(self.instructions)))
+        for inst in self.instructions:
+            inst_buffer.write(inst)
+        inst_data = inst_buffer.getvalue()
+
+        # Calculate offsets
+        name_offset = header_size
+        const_offset = name_offset + name_section_size
+        func_offset = const_offset + len(const_data)
+        inst_offset = func_offset + len(func_data)
+
+        # Write header
+        stream.write(MAGIC_NUMBER)  # Magic number
+        stream.write(struct.pack("<I", BYTECODE_VERSION))  # Version
+        stream.write(struct.pack("<I", FLAG_LITTLE_ENDIAN))  # Flags
+        stream.write(struct.pack("<I", name_offset))  # Name offset
+        stream.write(struct.pack("<I", const_offset))  # Constant offset
+        stream.write(struct.pack("<I", func_offset))  # Function offset
+        stream.write(struct.pack("<I", inst_offset))  # Instruction offset
+
+        # Write sections
+        stream.write(struct.pack("<I", len(name_bytes)))
+        stream.write(name_bytes)
+        stream.write(const_data)
+        stream.write(func_data)
+        stream.write(inst_data)
+
+        # Write global names if any
+        if self.global_names:
+            stream.write(struct.pack("<I", len(self.global_names)))
+            for name in self.global_names:
+                name_bytes = name.encode("utf-8")
+                stream.write(struct.pack("<I", len(name_bytes)))
+                stream.write(name_bytes)
+
+
+def serialize_bytecode_module(
+    module_name: str,
+    constants: list[tuple[int, Any]],
+    instructions: list[bytes],
+    functions: dict[str, int] | None = None,
+    global_names: list[str] | None = None,
+    output_path: Path | None = None,
+) -> bytes:
+    """Serialize a bytecode module.
+
+    Args:
+        module_name: Name of the module
+        constants: List of (tag, value) pairs for the constant pool
+        instructions: List of instruction bytes
+        functions: Optional function table (name -> offset)
+        global_names: Optional list of global variable names
+        output_path: Optional path to write the bytecode file
+
+    Returns:
+        The serialized bytecode as bytes
+    """
+    writer = BytecodeWriter()
+    writer.set_module_name(module_name)
+    writer.constants = constants
+    writer.instructions = instructions
+    writer.functions = functions or {}
+    writer.global_names = global_names or []
+
+    if output_path:
+        writer.write_to_file(output_path)
+
+    # Also return the bytes
+    buffer = BytesIO()
+    writer.write_to_stream(buffer)
+    return buffer.getvalue()

machine_dialect/codegen/opcodes.py

@@ -0,0 +1,101 @@
+"""Opcode definitions for the Rust VM.
+
+This module defines the opcodes that match the Rust VM implementation.
+These must stay in sync with machine_dialect_vm/src/instructions/decoder.rs
+"""
+
+from __future__ import annotations
+
+from enum import IntEnum
+
+
+class Opcode(IntEnum):
+    """VM instruction opcodes."""
+
+    # Basic Operations (0-3)
+    LOAD_CONST_R = 0  # LoadConstR { dst: u8, const_idx: u16 }
+    MOVE_R = 1  # MoveR { dst: u8, src: u8 }
+    LOAD_GLOBAL_R = 2  # LoadGlobalR { dst: u8, name_idx: u16 }
+    STORE_GLOBAL_R = 3  # StoreGlobalR { src: u8, name_idx: u16 }
+
+    # Type Operations (4-6)
+    DEFINE_R = 4  # DefineR { dst: u8, type_id: u16 }
+    CHECK_TYPE_R = 5  # CheckTypeR { dst: u8, src: u8, type_id: u16 }
+    CAST_R = 6  # CastR { dst: u8, src: u8, to_type: u16 }
+
+    # Arithmetic (7-12)
+    ADD_R = 7  # AddR { dst: u8, left: u8, right: u8 }
+    SUB_R = 8  # SubR { dst: u8, left: u8, right: u8 }
+    MUL_R = 9  # MulR { dst: u8, left: u8, right: u8 }
+    DIV_R = 10  # DivR { dst: u8, left: u8, right: u8 }
+    MOD_R = 11  # ModR { dst: u8, left: u8, right: u8 }
+    NEG_R = 12  # NegR { dst: u8, src: u8 }
+
+    # Logical Operations (13-15)
+    NOT_R = 13  # NotR { dst: u8, src: u8 }
+    AND_R = 14  # AndR { dst: u8, left: u8, right: u8 }
+    OR_R = 15  # OrR { dst: u8, left: u8, right: u8 }
+
+    # Comparisons (16-21)
+    EQ_R = 16  # EqR { dst: u8, left: u8, right: u8 }
+    NEQ_R = 17  # NeqR { dst: u8, left: u8, right: u8 }
+    LT_R = 18  # LtR { dst: u8, left: u8, right: u8 }
+    GT_R = 19  # GtR { dst: u8, left: u8, right: u8 }
+    LTE_R = 20  # LteR { dst: u8, left: u8, right: u8 }
+    GTE_R = 21  # GteR { dst: u8, left: u8, right: u8 }
+
+    # Control Flow (22-26)
+    JUMP_R = 22  # JumpR { offset: i32 }
+    JUMP_IF_R = 23  # JumpIfR { cond: u8, offset: i32 }
+    JUMP_IF_NOT_R = 24  # JumpIfNotR { cond: u8, offset: i32 }
+    CALL_R = 25  # CallR { func: u8, args: Vec<u8>, dst: u8 }
+    RETURN_R = 26  # ReturnR { src: Option<u8> }
+
+    # MIR Support (27-30)
+    PHI_R = 27  # PhiR { dst: u8, sources: Vec<(u8, u16)> }
+    ASSERT_R = 28  # AssertR { reg: u8, msg_idx: u16 }
+    SCOPE_ENTER_R = 29  # ScopeEnterR { scope_id: u16 }
+    SCOPE_EXIT_R = 30  # ScopeExitR { scope_id: u16 }
+
+    # String Operations (31-32)
+    CONCAT_STR_R = 31  # ConcatStrR { dst: u8, left: u8, right: u8 }
+    STR_LEN_R = 32  # StrLenR { dst: u8, str: u8 }
+
+    # Arrays (33-36)
+    NEW_ARRAY_R = 33  # NewArrayR { dst: u8, size: u8 }
+    ARRAY_GET_R = 34  # ArrayGetR { dst: u8, array: u8, index: u8 }
+    ARRAY_SET_R = 35  # ArraySetR { array: u8, index: u8, value: u8 }
+    ARRAY_LEN_R = 36  # ArrayLenR { dst: u8, array: u8 }
+
+    # Debug (37-40)
+    DEBUG_PRINT = 37  # DebugPrint { src: u8 }
+    BREAKPOINT = 38  # BreakPoint
+    HALT = 39  # Halt execution
+    NOP = 40  # No operation
+
+    # Dictionaries (41-49) - Now match VM implementation
+    DICT_NEW_R = 41  # DictNewR { dst: u8 }
+    DICT_GET_R = 42  # DictGetR { dst: u8, dict: u8, key: u8 }
+    DICT_SET_R = 43  # DictSetR { dict: u8, key: u8, value: u8 }
+    DICT_REMOVE_R = 44  # DictRemoveR { dict: u8, key: u8 }
+    DICT_CONTAINS_R = 45  # DictContainsR { dst: u8, dict: u8, key: u8 }
+    DICT_KEYS_R = 46  # DictKeysR { dst: u8, dict: u8 }
+    DICT_VALUES_R = 47  # DictValuesR { dst: u8, dict: u8 }
+    DICT_CLEAR_R = 48  # DictClearR { dict: u8 }
+    DICT_LEN_R = 49  # DictLenR { dst: u8, dict: u8 }
+
+
+# Type IDs for type operations
+class TypeId(IntEnum):
+    """Type identifiers."""
+
+    EMPTY = 0x00
+    BOOL = 0x01
+    INT = 0x02
+    FLOAT = 0x03
+    STRING = 0x04
+    FUNCTION = 0x05
+    URL = 0x06
+    ARRAY = 0x07
+    DICT = 0x08
+    UNKNOWN = 0xFF