toyc 0.1.0__tar.gz

toyc-0.1.0/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: toyc
+Version: 0.1.0
+Summary: A toy compiler with GPU backends (Vulkan + OpenGL)
+Author: spy1345a
+License: MIT License
+        
+        Copyright (c) 2026 spy1345a
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+        associated documentation files (the "Software"), to deal in the Software without restriction, including
+        without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the
+        following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all copies or substantial
+        portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+        LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
+        EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+        IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+        USE OR OTHER DEALINGS IN THE SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/spy1345a/toyc-repo
+Project-URL: Repository, https://github.com/spy1345a/toyc-repo
+Keywords: compiler,gpu,vulkan,opengl,toy
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Compilers
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pyopengl>=3.1
+Requires-Dist: vulkan>=1.3.275.1
+Provides-Extra: vulkan
+Requires-Dist: vulkan; extra == "vulkan"
+Provides-Extra: opengl
+Requires-Dist: PyOpenGL; extra == "opengl"

toyc-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "toyc"
+version = "0.1.0"
+description = "A toy compiler with GPU backends (Vulkan + OpenGL)"
+readme = "README.md"
+license = { file = "toyc/LICENSE" }
+requires-python = ">=3.10"
+authors = [
+  { name = "spy1345a"}
+]
+keywords = ["compiler", "gpu", "vulkan", "opengl", "toy"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",   
+  "Operating System :: OS Independent",
+  "Topic :: Software Development :: Compilers",
+]
+
+# list any actual pip deps your code imports at runtime:
+dependencies = [
+    "pyopengl>=3.1",
+    "vulkan>=1.3.275.1"
+]
+
+[project.urls]
+Homepage = "https://github.com/spy1345a/toyc-repo"   
+Repository = "https://github.com/spy1345a/toyc-repo"
+
+[project.optional-dependencies]
+vulkan = ["vulkan"]     
+opengl = ["PyOpenGL"]
+
+# If you want a CLI entrypoint (e.g. `toyc compile foo.tc`): comming soon
+# [project.scripts]
+# toyc = "toyc.compiler:main"

toyc-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

toyc-0.1.0/toyc/LICENSE

@@ -0,0 +1,18 @@
+MIT License
+
+Copyright (c) 2026 spy1345a
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the
+following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
+EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+USE OR OTHER DEALINGS IN THE SOFTWARE.

toyc-0.1.0/toyc/__init__.py

@@ -0,0 +1,10 @@
+# compiler/__init__.py
+
+from .lexer     import Lexer
+from .parser    import Parser
+from .gpu       import Flattener
+from .vm        import Cpu , GpuVulkan , GpuOpengl
+from .compiler import Compiler
+
+__all__     = ["Lexer", "Parser", "Evaluator", "Flattener",
+               "Instruction", "compile_to_file", "load_from_file"]

toyc-0.1.0/toyc/ast_nodes.py

@@ -0,0 +1,68 @@
+# compiler/ast_nodes.py
+
+from dataclasses import dataclass
+from typing import Any
+
+@dataclass
+class Number:
+    value: float | int
+
+    def __repr__(self):
+        return f"Number({self.value})"
+
+    def to_dict(self):
+        return {"type": "Number", "value": self.value}
+
+    @staticmethod
+    def from_dict(d):
+        return Number(d["value"])
+
+
+@dataclass
+class Var:
+    name: str
+
+    def __repr__(self):
+        return f"Var({self.name!r})"
+
+    def to_dict(self):
+        return {"type": "Var", "name": self.name}
+
+    @staticmethod
+    def from_dict(d):
+        return Var(d["name"])
+
+
+@dataclass
+class BinOp:
+    op:    str
+    left:  Any
+    right: Any
+
+    def __repr__(self):
+        return f"BinOp({self.op!r}, {self.left}, {self.right})"
+
+    def to_dict(self):
+        return {
+            "type":  "BinOp",
+            "op":    self.op,
+            "left":  self.left.to_dict(),
+            "right": self.right.to_dict(),
+        }
+
+    @staticmethod
+    def from_dict(d):
+        return BinOp(
+            op    = d["op"],
+            left  = node_from_dict(d["left"]),
+            right = node_from_dict(d["right"]),
+        )
+
+
+def node_from_dict(d):
+    """Reconstruct any AST node from a dict."""
+    kind = d["type"]
+    if kind == "Number": return Number.from_dict(d)
+    if kind == "Var":    return Var.from_dict(d)
+    if kind == "BinOp":  return BinOp.from_dict(d)
+    raise ValueError(f"Unknown node type: {kind!r}")

toyc-0.1.0/toyc/compiler.py

@@ -0,0 +1,199 @@
+# compiler/compiler.py
+#
+# Responsible for:
+#   • Defining the Instr dataclass (the instruction set)
+#   • .toyc binary serialisation / deserialisation helpers
+#   • The Compiler class  (AST → list[Instr], with disk write)
+#
+# It knows nothing about execution — import vm.py for that.
+#
+# Two calling styles are supported:
+#
+#   A) AST-first  (you already have an AST node):
+#         Compiler.compile(ast)                    → writes out.toyc
+#         Compiler.compile(ast, path="foo.toyc")   → writes foo.toyc
+#         Compiler.compile(ast, path=None)          → memory only
+#
+#   B) File-first (point straight at a .toy source file):
+#         Compiler.compile("script.toy")            → writes script.toyc
+#         Compiler.compile("script.toy", path=None) → memory only
+#
+#      The Lexer and Parser are invoked internally so the caller doesn't
+#      need to tokenise or build an AST manually.
+
+import os
+import pickle
+from dataclasses import dataclass
+from typing      import Any
+
+from .ast_nodes import Number, Var, BinOp
+from .lexer     import Lexer
+from .parser    import Parser
+
+
+# ── instruction set ───────────────────────────────────────────────────────────
+# These map 1-to-1 to SPIR-V ops later:
+#   PUSH  → OpConstant
+#   LOAD  → OpLoad
+#   ADD   → OpFAdd
+#   SUB   → OpFSub
+#   MUL   → OpFMul
+#   DIV   → OpFDiv
+
+@dataclass
+class Instr:
+    op:  str
+    arg: Any = None
+
+    def __repr__(self):
+        return f"{self.op} {self.arg!r}" if self.arg is not None else self.op
+
+
+# ── .toyc binary format ───────────────────────────────────────────────────────
+# Layout:
+#   bytes 0-3 : MAGIC  b'\x54\x4F\x59\x43'  ("TOYC")
+#   bytes 4+  : pickle.dumps(list[Instr])
+#
+# The magic header lets Cpu.run() detect compiled files by peeking at raw
+# bytes, without relying on the file extension alone.
+
+MAGIC = b'\x54\x4F\x59\x43'   # "TOYC"
+
+
+def write_bytecode(path: str, instructions: list) -> None:
+    """Serialise *instructions* to a .toyc file at *path*."""
+    with open(path, "wb") as f:
+        f.write(MAGIC)
+        pickle.dump(instructions, f)
+
+
+def read_bytecode(path: str) -> list:
+    """Deserialise a .toyc file and return the list[Instr]."""
+    with open(path, "rb") as f:
+        magic = f.read(4)
+        if magic != MAGIC:
+            raise ValueError(
+                f"{path!r} is not a valid .toyc file (bad magic bytes)"
+            )
+        return pickle.load(f)
+
+
+def is_compiled_bytecode(path: str) -> bool:
+    """Return True if *path* starts with the TOYC magic number."""
+    try:
+        with open(path, "rb") as f:
+            return f.read(4) == MAGIC
+    except OSError:
+        return False
+
+
+# ── helpers ───────────────────────────────────────────────────────────────────
+
+def _source_to_ast(toy_path: str):
+    """Read a .toy file and return its parsed AST using Lexer + Parser."""
+    with open(toy_path, "r", encoding="utf-8") as f:
+        source = f.read()
+    tokens = Lexer.tokenize(source)
+    return Parser.parse(tokens)
+
+
+# ── Compiler: AST → bytecode ──────────────────────────────────────────────────
+
+class Compiler:
+    """Walk an AST and emit a flat list[Instr].
+
+    Calling styles
+    --------------
+    # A) You already have tokens / an AST (original workflow):
+    tokens = Lexer.tokenize(code)
+    ast    = Parser.parse(tokens)
+    Compiler.compile(ast)                     # writes out.toyc
+    Compiler.compile(ast, path="expr.toyc")   # writes expr.toyc
+    Compiler.compile(ast, path=None)          # memory only
+
+    # B) Point straight at a .toy source file:
+    Compiler.compile("script.toy")            # reads script.toy,
+                                              # writes script.toyc next to it
+    Compiler.compile("script.toy", path=None) # reads script.toy,
+                                              # memory only (no .toyc written)
+    """
+
+    @staticmethod
+    def compile(node_or_path, path: str = "out.toyc") -> list:
+        """
+        Compile source or an AST node into bytecode.
+
+        Parameters
+        ----------
+        node_or_path : AST node  OR  str
+            • An AST node  → compiled directly (original behaviour).
+            • A str ending in ``.toy``  → the file is read, lexed, and parsed
+              first; the default output path becomes a sibling .toyc with the
+              same stem (overrides the ``path`` default of ``"out.toyc"``).
+
+        path : str | None, optional
+            Where to write the .toyc file.
+            • ``"out.toyc"`` (default) when *node_or_path* is an AST node.
+            • Auto-derived sibling path   when *node_or_path* is a .toy file.
+            • ``None``  → compile but do not write anything to disk.
+            The .toyc extension is enforced regardless of what is passed.
+
+        Returns
+        -------
+        list[Instr]
+            Flat bytecode list (always returned).
+        """
+
+        # ── resolve the input ────────────────────────────────────────────────
+
+        if isinstance(node_or_path, str):
+            # File-first mode
+            toy_path = node_or_path
+            if not toy_path.endswith(".toy"):
+                raise ValueError(
+                    f"Expected a .toy source file, got: {toy_path!r}"
+                )
+            if not os.path.isfile(toy_path):
+                raise FileNotFoundError(f"Source file not found: {toy_path!r}")
+
+            node = _source_to_ast(toy_path)
+
+            # Derive sibling .toyc path unless the caller overrode it
+            if path == "out.toyc":   # still the default → replace with sibling
+                path = os.path.splitext(os.path.abspath(toy_path))[0] + ".toyc"
+
+        else:
+            # AST-first mode — node_or_path is an AST node
+            node = node_or_path
+            # path stays as whatever the caller passed ("out.toyc" or explicit)
+
+        # ── emit bytecode ────────────────────────────────────────────────────
+
+        instructions: list[Instr] = []
+        Compiler._emit(node, instructions)
+
+        # ── write to disk ────────────────────────────────────────────────────
+
+        if path is not None:
+            if not path.endswith(".toyc"):
+                path = os.path.splitext(path)[0] + ".toyc"
+            write_bytecode(path, instructions)
+
+        return instructions
+
+    @staticmethod
+    def _emit(node, out: list) -> None:
+        if isinstance(node, Number):
+            out.append(Instr("PUSH", node.value))
+
+        elif isinstance(node, Var):
+            out.append(Instr("LOAD", node.name))
+
+        elif isinstance(node, BinOp):
+            Compiler._emit(node.left,  out)   # push left operand
+            Compiler._emit(node.right, out)   # push right operand
+            op_map = {"+": "ADD", "-": "SUB", "*": "MUL", "/": "DIV"}
+            out.append(Instr(op_map[node.op]))
+
+        else:
+            raise TypeError(f"Unknown AST node: {type(node).__name__}")

toyc-0.1.0/toyc/evaluator.py

@@ -0,0 +1,36 @@
+# compiler/evaluator.py
+
+from .ast_nodes import Number, Var, BinOp
+
+class Evaluator:
+    def __init__(self, env=None):
+        # env holds variable values e.g {"a": 10, "b": 5}
+        self.env = env or {}
+
+    def eval(self, node):
+        # base case — just return the number
+        if isinstance(node, Number):
+            return node.value
+
+        # variable lookup
+        if isinstance(node, Var):
+            if node.name not in self.env:
+                raise NameError(f"Undefined variable: {node.name!r}")
+            return self.env[node.name]
+
+        # recursive case — evaluate both sides then apply operator
+        if isinstance(node, BinOp):
+            left  = self.eval(node.left)
+            right = self.eval(node.right)
+
+            if node.op == "+": return left + right
+            if node.op == "-": return left - right
+            if node.op == "*": return left * right
+            if node.op == "/":
+                if right == 0:
+                    raise ZeroDivisionError("Division by zero in expression")
+                return left / right
+
+            raise ValueError(f"Unknown operator: {node.op!r}")
+
+        raise TypeError(f"Unknown AST node: {type(node)}")

toyc-0.1.0/toyc/gpu/__init__.py

@@ -0,0 +1,6 @@
+# compiler/__init__.py
+
+from .flattener import Flattener
+
+
+__version__ = "0.1.0"

toyc-0.1.0/toyc/gpu/flattener.py

@@ -0,0 +1,56 @@
+# compiler/flattener.py
+
+from ..ast_nodes    import Number, Var, BinOp
+from .instructions import Instruction, ADD, SUB, MUL, DIV, LOAD, VAR
+
+class Flattener:
+    def __init__(self):
+        self.instructions = []
+        self.reg_counter  = 0       # next free register
+        self.var_map      = {}      # var name → register index
+        self.const_values = []      # constant pool [1.0, 2.5, ...]
+
+    def new_reg(self):
+        """Allocate a new register, return its index."""
+        r = self.reg_counter
+        self.reg_counter += 1
+        return r
+
+    def flatten(self, node):
+        """Recursively flatten an AST node, return the register holding result."""
+
+        if isinstance(node, Number):
+            dest  = self.new_reg()
+            const_idx = len(self.const_values)
+            self.const_values.append(float(node.value))
+            self.instructions.append(Instruction(LOAD, dest, const_idx))
+            return dest
+
+        if isinstance(node, Var):
+            # each unique variable gets one register
+            if node.name not in self.var_map:
+                dest = self.new_reg()
+                var_idx = len(self.var_map)
+                self.var_map[node.name] = (dest, var_idx)
+                self.instructions.append(Instruction(VAR, dest, var_idx))
+            return self.var_map[node.name][0]
+
+        if isinstance(node, BinOp):
+            left_reg  = self.flatten(node.left)
+            right_reg = self.flatten(node.right)
+            dest      = self.new_reg()
+
+            op = {"+": ADD, "-": SUB, "*": MUL, "/": DIV}[node.op]
+            self.instructions.append(Instruction(op, dest, left_reg, right_reg))
+            return dest
+
+        raise TypeError(f"Unknown node: {type(node)}")
+
+    def get_flat(self):
+        """Return flat int list ready for GPU upload.
+           Layout: [op, dest, src1, src2,  op, dest, src1, src2, ...]
+        """
+        flat = []
+        for instr in self.instructions:
+            flat.extend(instr.to_list())
+        return flat

toyc-0.1.0/toyc/gpu/instructions.py

@@ -0,0 +1,27 @@
+# compiler/instructions.py
+
+# opcodes
+ADD  = 0
+SUB  = 1
+MUL  = 2
+DIV  = 3
+LOAD = 4   # load a constant value into a register
+VAR  = 5   # load a variable into a register
+
+OP_NAMES = {ADD: "ADD", SUB: "SUB", MUL: "MUL",
+            DIV: "DIV", LOAD: "LOAD", VAR: "VAR"}
+
+class Instruction:
+    def __init__(self, op, dest, src1=0, src2=0):
+        self.op   = op     # opcode int
+        self.dest = dest   # destination register index
+        self.src1 = src1   # source register 1 (or value for LOAD)
+        self.src2 = src2   # source register 2
+
+    def __repr__(self):
+        name = OP_NAMES.get(self.op, "???")
+        return f"{name:4} r{self.dest} r{self.src1} r{self.src2}"
+
+    def to_list(self):
+        """Serialize to flat list of 4 ints for GPU upload."""
+        return [self.op, self.dest, self.src1, self.src2]

toyc-0.1.0/toyc/gpu/opengl/__init__.py

@@ -0,0 +1,9 @@
+# compiler/gpu/vulkan/__init__.py
+#
+# Re-exports GpuOpengl so callers can do either:
+#   from compiler.gpu.vulkan import GpuOpengl
+#   from compiler.gpu.vulkan.backend import GpuOpengl
+
+from .backend import GpuOpengl
+
+__all__ = ["GpuOpengl"]

toyc-0.1.0/toyc/gpu/opengl/backend.py

@@ -0,0 +1,136 @@
+# compiler/gpu/vulkan/backend.py
+#
+# GpuVulkan — Vulkan compute backend for the toy VM.
+#
+# Translates list[Instr] → SPIR-V opcodes → dispatches a Vulkan compute
+# pipeline and reads back the result.
+#
+# Right now the SPIR-V emission and Vulkan dispatch are stubbed with clear
+# TODO markers so the structure is in place and wires up cleanly to vm.py.
+# Fill each stub in as you port your existing vulkan-llm Vulkan engine across.
+#
+# Instruction → SPIR-V opcode mapping (matches compiler.py comments):
+#   PUSH  → OpConstant
+#   LOAD  → OpLoad
+#   ADD   → OpFAdd
+#   SUB   → OpFSub
+#   MUL   → OpFMul
+#   DIV   → OpFDiv
+
+from __future__ import annotations
+from typing import Any
+
+
+class GpuOpengl:
+    """Vulkan compute backend.
+
+    Accepts the same *program* forms as ``Cpu.run()``:
+
+    * ``list[Instr]``  — already-compiled bytecode, dispatch directly.
+    * ``str`` ending in ``.toyc`` — load compiled file, dispatch.
+    * ``str`` ending in ``.toy``  — lex + parse + compile in memory, dispatch.
+
+    The ``silent`` flag mirrors ``Cpu.run()`` — False by default so the result
+    is printed automatically, True to suppress printing when you capture the
+    return value yourself.
+    """
+
+    @staticmethod
+    def run(program, env: dict = None, silent: bool = False) -> Any:
+        """
+        Compile (if needed), emit SPIR-V, dispatch on GPU, return result.
+
+        Parameters
+        ----------
+        program : list[Instr] | str
+            Bytecode list, .toyc path, or .toy source path.
+        env : dict, optional
+            Variable bindings for LOAD instructions  {name: value}.
+        silent : bool, optional
+            False (default) → result is printed before returning.
+            True            → result returned quietly, no stdout output.
+        """
+        # Resolve whatever the caller passed into a flat list[Instr].
+        # We reuse Cpu._resolve() so file loading / on-the-fly compilation
+        # lives in exactly one place.
+        #from compiler.vm import Cpu   # local import to avoid circular dependency
+        #instructions = Cpu._resolve(program)
+
+        #spirv  = GpuVulkan._emit_spirv(instructions, env or {})
+        #result = GpuVulkan._dispatch(spirv)
+
+        #if not silent:
+            #print(result)
+
+        #return result
+
+    # ── SPIR-V emission ───────────────────────────────────────────────────────
+
+    @staticmethod
+    def _emit_spirv(instructions: list, env: dict) -> bytes:
+        """
+        Translate list[Instr] into a SPIR-V compute shader binary.
+
+        Each toy opcode maps to one SPIR-V op:
+            PUSH value  → OpConstant  (f32 constant)
+            LOAD name   → OpLoad      (load from uniform/push-constant)
+            ADD         → OpFAdd
+            SUB         → OpFSub
+            MUL         → OpFMul
+            DIV         → OpFDiv
+
+        Returns raw SPIR-V bytes ready to pass to vkCreateShaderModule.
+        """
+        # TODO: build the SPIR-V word stream here.
+        #
+        # Suggested approach:
+        #   1. Walk `instructions` and track a virtual register stack.
+        #   2. Emit OpConstant / OpLoad for PUSH / LOAD.
+        #   3. Emit OpFAdd / OpFSub / OpFMul / OpFDiv for arithmetic ops,
+        #      consuming the top two registers and producing a new one.
+        #   4. Emit OpStore to write the final register to the output buffer.
+        #   5. Assemble the header (magic, version, bound, schema) and
+        #      return the whole thing as bytes.
+        #
+        # Libraries that help:
+        #   • pyspirv   — pure-Python SPIR-V assembler
+        #   • spirv-cross (via ctypes) — if you prefer C bindings
+        #   • hand-roll with struct.pack('<I', word) — minimal dependency
+
+        raise NotImplementedError(
+            "GpuVulkan._emit_spirv() is not yet implemented.\n"
+            "Fill in the SPIR-V word stream in compiler/gpu/vulkan/backend.py."
+        )
+
+    # ── Vulkan dispatch ───────────────────────────────────────────────────────
+
+    @staticmethod
+    def _dispatch(spirv: bytes) -> Any:
+        """
+        Create a Vulkan compute pipeline from *spirv*, dispatch it, and
+        read back the scalar result from the output buffer.
+
+        Steps (mirrors a typical compute dispatch):
+            1. vkCreateShaderModule(spirv)
+            2. vkCreateComputePipeline(shader)
+            3. Allocate input / output VkBuffers, upload constants / env vars.
+            4. vkCmdDispatch(1, 1, 1)   ← single workgroup for scalar ops
+            5. vkMapMemory → read f32 result → vkUnmapMemory
+            6. Teardown (pipeline, shader module, buffers).
+
+        Returns the scalar result as a Python float (or int).
+        """
+        # TODO: wire up your existing Vulkan engine from spy1345a/vulkan-llm.
+        #
+        # If you're using ctypes bindings to your C++ engine, the call will
+        # look roughly like:
+        #
+        #   from compiler.gpu.vulkan._bindings import vulkan_lib
+        #   result_buf = (ctypes.c_float * 1)()
+        #   vulkan_lib.dispatch_spirv(spirv, len(spirv), result_buf)
+        #   return result_buf[0]
+
+        raise NotImplementedError(
+            "GpuVulkan._dispatch() is not yet implemented.\n"
+            "Wire up the Vulkan compute dispatch in compiler/gpu/vulkan/backend.py."
+        )

toyc-0.1.0/toyc/gpu/vulkan/__init__.py

@@ -0,0 +1,9 @@
+# compiler/gpu/vulkan/__init__.py
+#
+# Re-exports GpuVulkan so callers can do either:
+#   from compiler.gpu.vulkan import GpuVulkan
+#   from compiler.gpu.vulkan.backend import GpuVulkan
+
+from .backend import GpuVulkan
+
+__all__ = ["GpuVulkan"]

toyc-0.1.0/toyc/gpu/vulkan/backend.py

@@ -0,0 +1,136 @@
+# compiler/gpu/vulkan/backend.py
+#
+# GpuVulkan — Vulkan compute backend for the toy VM.
+#
+# Translates list[Instr] → SPIR-V opcodes → dispatches a Vulkan compute
+# pipeline and reads back the result.
+#
+# Right now the SPIR-V emission and Vulkan dispatch are stubbed with clear
+# TODO markers so the structure is in place and wires up cleanly to vm.py.
+# Fill each stub in as you port your existing vulkan-llm Vulkan engine across.
+#
+# Instruction → SPIR-V opcode mapping (matches compiler.py comments):
+#   PUSH  → OpConstant
+#   LOAD  → OpLoad
+#   ADD   → OpFAdd
+#   SUB   → OpFSub
+#   MUL   → OpFMul
+#   DIV   → OpFDiv
+
+from __future__ import annotations
+from typing import Any
+
+
+class GpuVulkan:
+    """Vulkan compute backend.
+
+    Accepts the same *program* forms as ``Cpu.run()``:
+
+    * ``list[Instr]``  — already-compiled bytecode, dispatch directly.
+    * ``str`` ending in ``.toyc`` — load compiled file, dispatch.
+    * ``str`` ending in ``.toy``  — lex + parse + compile in memory, dispatch.
+
+    The ``silent`` flag mirrors ``Cpu.run()`` — False by default so the result
+    is printed automatically, True to suppress printing when you capture the
+    return value yourself.
+    """
+
+    @staticmethod
+    def run(program, env: dict = None, silent: bool = False) -> Any:
+        """
+        Compile (if needed), emit SPIR-V, dispatch on GPU, return result.
+
+        Parameters
+        ----------
+        program : list[Instr] | str
+            Bytecode list, .toyc path, or .toy source path.
+        env : dict, optional
+            Variable bindings for LOAD instructions  {name: value}.
+        silent : bool, optional
+            False (default) → result is printed before returning.
+            True            → result returned quietly, no stdout output.
+        """
+        # Resolve whatever the caller passed into a flat list[Instr].
+        # We reuse Cpu._resolve() so file loading / on-the-fly compilation
+        # lives in exactly one place.
+        from compiler.vm import Cpu   # local import to avoid circular dependency
+        instructions = Cpu._resolve(program)
+
+        spirv  = GpuVulkan._emit_spirv(instructions, env or {})
+        result = GpuVulkan._dispatch(spirv)
+
+        if not silent:
+            print(result)
+
+        return result
+
+    # ── SPIR-V emission ───────────────────────────────────────────────────────
+
+    @staticmethod
+    def _emit_spirv(instructions: list, env: dict) -> bytes:
+        """
+        Translate list[Instr] into a SPIR-V compute shader binary.
+
+        Each toy opcode maps to one SPIR-V op:
+            PUSH value  → OpConstant  (f32 constant)
+            LOAD name   → OpLoad      (load from uniform/push-constant)
+            ADD         → OpFAdd
+            SUB         → OpFSub
+            MUL         → OpFMul
+            DIV         → OpFDiv
+
+        Returns raw SPIR-V bytes ready to pass to vkCreateShaderModule.
+        """
+        # TODO: build the SPIR-V word stream here.
+        #
+        # Suggested approach:
+        #   1. Walk `instructions` and track a virtual register stack.
+        #   2. Emit OpConstant / OpLoad for PUSH / LOAD.
+        #   3. Emit OpFAdd / OpFSub / OpFMul / OpFDiv for arithmetic ops,
+        #      consuming the top two registers and producing a new one.
+        #   4. Emit OpStore to write the final register to the output buffer.
+        #   5. Assemble the header (magic, version, bound, schema) and
+        #      return the whole thing as bytes.
+        #
+        # Libraries that help:
+        #   • pyspirv   — pure-Python SPIR-V assembler
+        #   • spirv-cross (via ctypes) — if you prefer C bindings
+        #   • hand-roll with struct.pack('<I', word) — minimal dependency
+
+        raise NotImplementedError(
+            "GpuVulkan._emit_spirv() is not yet implemented.\n"
+            "Fill in the SPIR-V word stream in compiler/gpu/vulkan/backend.py."
+        )
+
+    # ── Vulkan dispatch ───────────────────────────────────────────────────────
+
+    @staticmethod
+    def _dispatch(spirv: bytes) -> Any:
+        """
+        Create a Vulkan compute pipeline from *spirv*, dispatch it, and
+        read back the scalar result from the output buffer.
+
+        Steps (mirrors a typical compute dispatch):
+            1. vkCreateShaderModule(spirv)
+            2. vkCreateComputePipeline(shader)
+            3. Allocate input / output VkBuffers, upload constants / env vars.
+            4. vkCmdDispatch(1, 1, 1)   ← single workgroup for scalar ops
+            5. vkMapMemory → read f32 result → vkUnmapMemory
+            6. Teardown (pipeline, shader module, buffers).
+
+        Returns the scalar result as a Python float (or int).
+        """
+        # TODO: wire up your existing Vulkan engine from spy1345a/vulkan-llm.
+        #
+        # If you're using ctypes bindings to your C++ engine, the call will
+        # look roughly like:
+        #
+        #   from compiler.gpu.vulkan._bindings import vulkan_lib
+        #   result_buf = (ctypes.c_float * 1)()
+        #   vulkan_lib.dispatch_spirv(spirv, len(spirv), result_buf)
+        #   return result_buf[0]
+
+        raise NotImplementedError(
+            "GpuVulkan._dispatch() is not yet implemented.\n"
+            "Wire up the Vulkan compute dispatch in compiler/gpu/vulkan/backend.py."
+        )

toyc-0.1.0/toyc/lexer.py

@@ -0,0 +1,98 @@
+NUMBER = "NUMBER"
+IDENT  = "IDENT"
+PLUS   = "PLUS"
+MINUS  = "MINUS"
+STAR   = "STAR"
+SLASH  = "SLASH"
+LPAREN = "LPAREN"
+RPAREN = "RPAREN"
+EOF    = "EOF"
+
+class Token:
+    def __init__(self, type, value):
+        self.type  = type
+        self.value = value
+
+    def __repr__(self):
+        return f"Token({self.type}, {self.value!r})"
+
+
+class Lexer:
+    KEYWORDS = {"kernel", "return"}
+
+    def __init__(self, text):
+        self.text    = text
+        self.pos     = 0
+        self.current = text[0] if text else None
+
+    # ── public API ──────────────────────────────────────────────────────────
+    @classmethod
+    def tokenize(cls, text):
+        """Lex *text* and return a list of Tokens (including the EOF token)."""
+        return cls(text)._run()
+
+    # ── internal helpers ─────────────────────────────────────────────────────
+    def _run(self):
+        tokens = []
+        while True:
+            tok = self._next_token()
+            tokens.append(tok)
+            if tok.type == EOF:
+                break
+        return tokens
+
+    def _advance(self):
+        self.pos += 1
+        self.current = self.text[self.pos] if self.pos < len(self.text) else None
+
+    def _skip_whitespace(self):
+        while self.current and self.current.isspace():
+            self._advance()
+
+    def _read_number(self):
+        result = ""
+        while self.current and (self.current.isdigit() or self.current == "."):
+            result += self.current
+            self._advance()
+        return Token(NUMBER, float(result) if "." in result else int(result))
+
+    def _read_ident(self):
+        result = ""
+        while self.current and (self.current.isalnum() or self.current == "_"):
+            result += self.current
+            self._advance()
+        tok_type = result.upper() if result in self.KEYWORDS else IDENT
+        return Token(tok_type, result)
+
+    _OPS = {"+": PLUS, "-": MINUS, "*": STAR, "/": SLASH,
+            "(": LPAREN, ")": RPAREN}
+
+    def _next_token(self):
+        while self.current:
+            if self.current.isspace():
+                self._skip_whitespace()
+                continue
+            if self.current.isdigit():
+                return self._read_number()
+            if self.current.isalpha() or self.current == "_":
+                return self._read_ident()
+            if self.current in self._OPS:
+                tok = Token(self._OPS[self.current], self.current)
+                self._advance()
+                return tok
+            raise SyntaxError(f"Unknown character: {self.current!r}")
+        return Token(EOF, None)
+
+
+# ── test ─────────────────────────────────────────────────────────────────────
+if __name__ == "__main__":
+    tests = [
+        "a + b * 2",
+        "(a + b) * (c - 3)",
+        "10.5 / x + y * 2",
+        "kernel",
+    ]
+    for src in tests:
+        print(f"\nInput:  {src!r}")
+        for tok in Lexer.tokenize(src):      # ← clean API
+            print(f"  {tok}")

toyc-0.1.0/toyc/parser.py

@@ -0,0 +1,78 @@
+# compiler/parser.py
+
+from .lexer     import NUMBER, IDENT, PLUS, MINUS, STAR, SLASH, LPAREN, RPAREN, EOF
+from .ast_nodes import Number, Var, BinOp
+
+class Parser:
+    def __init__(self, tokens):
+        self.tokens  = tokens
+        self.pos     = 0
+        self.current = tokens[0]
+
+    # ── public API ───────────────────────────────────────────────────────────
+    @classmethod
+    def parse(cls, tokens):
+        """Parse a token list and return the AST root node."""
+        return cls(tokens)._run()
+
+    # ── internal helpers ─────────────────────────────────────────────────────
+    def _run(self):
+        node = self._expr()
+        self._eat(EOF)
+        return node
+
+    def _advance(self):
+        self.pos += 1
+        if self.pos < len(self.tokens):
+            self.current = self.tokens[self.pos]
+
+    def _eat(self, type):
+        if self.current.type == type:
+            tok = self.current
+            self._advance()
+            return tok
+        raise SyntaxError(
+            f"Expected {type}, got {self.current.type!r} ({self.current.value!r})"
+        )
+
+    # ── precedence level 3 (highest): numbers, vars, parenthesised expressions
+    def _factor(self):
+        tok = self.current
+
+        if tok.type == NUMBER:
+            self._advance()
+            return Number(tok.value)
+
+        if tok.type == IDENT:
+            self._advance()
+            return Var(tok.value)
+
+        if tok.type == LPAREN:
+            self._advance()
+            node = self._expr()
+            self._eat(RPAREN)
+            return node
+
+        raise SyntaxError(f"Unexpected token: {tok!r}")
+
+    # ── precedence level 2: * and /
+    def _term(self):
+        node = self._factor()
+
+        while self.current.type in (STAR, SLASH):
+            op = self.current.value
+            self._advance()
+            node = BinOp(op, node, self._factor())
+
+        return node
+
+    # ── precedence level 1 (lowest): + and -
+    def _expr(self):
+        node = self._term()
+
+        while self.current.type in (PLUS, MINUS):
+            op = self.current.value
+            self._advance()
+            node = BinOp(op, node, self._term())
+
+        return node

toyc-0.1.0/toyc/vm.py

@@ -0,0 +1,182 @@
+# compiler/vm.py
+#
+# Responsible for:
+#   • The Cpu class       (execute bytecode on the host CPU)
+#   • Input resolution    (list[Instr], .toyc path, .toy path) — shared by
+#                          all backends so file loading lives in one place
+#   • Re-exporting GpuVulkan so callers can import both backends from here:
+#
+#       from compiler.vm import Cpu, GpuVulkan
+#
+# Calling styles (identical interface for both backends):
+#
+#   Cpu.run("script.toy")          → lex+parse+compile in memory, run on CPU
+#   Cpu.run("script.toyc")         → load compiled file, run on CPU
+#   Cpu.run(bytecode_list)         → run in memory directly
+#
+#   GpuVulkan.run("script.toy")    → same input forms, dispatches on GPU
+#   GpuVulkan.run("script.toyc")   → load compiled file, dispatch on GPU
+
+import os
+from typing import Any
+
+from .compiler import (
+    Instr,
+    Compiler,
+    read_bytecode,
+    is_compiled_bytecode,
+)
+from .lexer  import Lexer
+from .parser import Parser
+
+# Re-export so `from compiler.vm import GpuVulkan` works
+from .gpu.vulkan import GpuVulkan
+
+from .gpu.opengl import GpuOpengl
+
+__all__ = ["Cpu", "GpuVulkan"]
+
+
+# ── Cpu: execute bytecode ─────────────────────────────────────────────────────
+
+class Cpu:
+    """Stack-based virtual machine.
+
+    ``Cpu.run()`` accepts three forms of *program*:
+
+    1. ``list[Instr]``
+          Already-compiled bytecode; executed directly, no I/O.
+
+    2. ``str`` ending in ``.toyc``
+          Load the compiled file from disk and execute it.
+          No lexing, parsing, or compiling happens.
+
+    3. ``str`` ending in ``.toy``
+          Read the source file, lex it, parse it, compile it in memory,
+          then execute.  Nothing is written to disk.
+    """
+
+    @staticmethod
+    def run(program, env: dict = None, silent: bool = False) -> Any:
+        """
+        Execute *program* and return the top-of-stack result.
+
+        By default the result is printed to stdout automatically.
+        Pass ``silent=True`` when you are capturing the return value yourself
+        and do not want it printed as well.
+
+        Parameters
+        ----------
+        program : list[Instr] | str
+            Bytecode list, a .toyc compiled file path, or a .toy source path.
+        env : dict, optional
+            Variable bindings available to LOAD instructions  {name: value}.
+        silent : bool, optional
+            False (default) → result is printed before returning.
+            True            → result is returned quietly, no stdout output.
+
+        Examples
+        --------
+        Cpu.run("out.toyc")                        # prints result automatically
+        value = Cpu.run("out.toyc", silent=True)   # capture only, no print
+        """
+        instructions = Cpu._resolve(program)
+        result       = Cpu._execute(instructions, env or {})
+
+        if not silent:
+            print(result)
+
+        return result
+
+    # ── input resolution ──────────────────────────────────────────────────────
+
+    @staticmethod
+    def _resolve(program) -> list:
+        """Return a list[Instr] no matter what form *program* arrives in."""
+
+        # ① Already compiled in memory — use directly
+        if isinstance(program, list):
+            return program
+
+        if not isinstance(program, str):
+            raise TypeError(
+                f"Cpu.run() expects a list[Instr] or a file path str, "
+                f"got {type(program).__name__}"
+            )
+
+        path = program
+
+        # ② .toyc path — load compiled bytecode, skip all compile steps
+        if path.endswith(".toyc"):
+            if not os.path.isfile(path):
+                raise FileNotFoundError(f"Bytecode file not found: {path!r}")
+            return read_bytecode(path)
+
+        # ③ .toy source path — lex → parse → compile in memory, no disk write
+        if path.endswith(".toy"):
+            if not os.path.isfile(path):
+                raise FileNotFoundError(f"Source file not found: {path!r}")
+            return Cpu._compile_toy(path)
+
+        # ④ Unknown extension — peek at magic bytes as a last resort
+        if os.path.isfile(path) and is_compiled_bytecode(path):
+            return read_bytecode(path)
+
+        raise ValueError(
+            f"Cannot load {path!r}: expected a .toy source or .toyc bytecode file"
+        )
+
+    @staticmethod
+    def _compile_toy(toy_path: str) -> list:
+        """
+        Lex → parse → compile a .toy source file entirely in memory.
+        Nothing is written to disk (path=None passed to Compiler.compile).
+        """
+        with open(toy_path, "r", encoding="utf-8") as f:
+            source = f.read()
+
+        tokens = Lexer.tokenize(source)
+        ast    = Parser.parse(tokens)
+        # path=None → memory only, no .toyc file created
+        return Compiler.compile(ast, path=None)
+
+    # ── core interpreter ──────────────────────────────────────────────────────
+
+    @staticmethod
+    def _execute(instructions: list, env: dict) -> Any:
+        stack: list = []
+
+        for instr in instructions:
+            if instr.op == "PUSH":
+                stack.append(instr.arg)
+
+            elif instr.op == "LOAD":
+                if instr.arg not in env:
+                    raise NameError(f"Undefined variable: {instr.arg!r}")
+                stack.append(env[instr.arg])
+
+            elif instr.op == "ADD":
+                b, a = stack.pop(), stack.pop()
+                stack.append(a + b)
+
+            elif instr.op == "SUB":
+                b, a = stack.pop(), stack.pop()
+                stack.append(a - b)
+
+            elif instr.op == "MUL":
+                b, a = stack.pop(), stack.pop()
+                stack.append(a * b)
+
+            elif instr.op == "DIV":
+                b, a = stack.pop(), stack.pop()
+                if b == 0:
+                    raise ZeroDivisionError("Division by zero in VM")
+                stack.append(a / b)
+
+            else:
+                raise RuntimeError(f"Unknown opcode: {instr.op!r}")
+
+        if not stack:
+            raise RuntimeError("Execution finished with an empty stack")
+
+        return stack[-1]   # top of stack is the result

toyc-0.1.0/toyc.egg-info/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: toyc
+Version: 0.1.0
+Summary: A toy compiler with GPU backends (Vulkan + OpenGL)
+Author: spy1345a
+License: MIT License
+        
+        Copyright (c) 2026 spy1345a
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+        associated documentation files (the "Software"), to deal in the Software without restriction, including
+        without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the
+        following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all copies or substantial
+        portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+        LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
+        EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+        IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+        USE OR OTHER DEALINGS IN THE SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/spy1345a/toyc-repo
+Project-URL: Repository, https://github.com/spy1345a/toyc-repo
+Keywords: compiler,gpu,vulkan,opengl,toy
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Compilers
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pyopengl>=3.1
+Requires-Dist: vulkan>=1.3.275.1
+Provides-Extra: vulkan
+Requires-Dist: vulkan; extra == "vulkan"
+Provides-Extra: opengl
+Requires-Dist: PyOpenGL; extra == "opengl"

toyc-0.1.0/toyc.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+README.md
+pyproject.toml
+toyc/LICENSE
+toyc/__init__.py
+toyc/ast_nodes.py
+toyc/compiler.py
+toyc/evaluator.py
+toyc/lexer.py
+toyc/parser.py
+toyc/vm.py
+toyc.egg-info/PKG-INFO
+toyc.egg-info/SOURCES.txt
+toyc.egg-info/dependency_links.txt
+toyc.egg-info/requires.txt
+toyc.egg-info/top_level.txt
+toyc/gpu/__init__.py
+toyc/gpu/flattener.py
+toyc/gpu/instructions.py
+toyc/gpu/opengl/__init__.py
+toyc/gpu/opengl/backend.py
+toyc/gpu/vulkan/__init__.py
+toyc/gpu/vulkan/backend.py

toyc-0.1.0/toyc.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

toyc-0.1.0/toyc.egg-info/requires.txt

@@ -0,0 +1,8 @@
+pyopengl>=3.1
+vulkan>=1.3.275.1
+
+[opengl]
+PyOpenGL
+
+[vulkan]
+vulkan

toyc-0.1.0/toyc.egg-info/top_level.txt

@@ -0,0 +1 @@
+toyc