dedekind 3.0.0__py3-none-any.whl

dedekind/__init__.py

@@ -0,0 +1,17 @@
+"""Dedekind -- a programming language for scientific computing.
+
+Public entry points:
+    dedekind.compile_source(src, ...)  - compile a .ddk source string to Python
+    dedekind.dedekind_exec(code, ...)  - run compiled code with mapped tracebacks
+    dedekind.export_to_latex(src)      - export formulas as LaTeX
+
+CLI: `dedekind <file.ddk>` (see dedekind.cli).
+"""
+
+__version__ = "3.0.0"
+
+from .compiler import (  # noqa: F401  (re-export)
+    compile_source,
+    dedekind_exec,
+    export_to_latex,
+)

dedekind/aot_compiler.py

@@ -0,0 +1,93 @@
+import os
+import subprocess
+import sys
+from .lexer import Lexer
+from .parser import Parser
+from .mlir_codegen import MLIRCodeGenerator
+
+class AOTCompiler:
+    """
+    Dedekind Ahead-of-Time (AOT) Compiler.
+    Orchestrates the transition from Dedekind source to native binaries.
+    """
+    def __init__(self, source_path: str):
+        self.source_path = source_path
+        self.output_dir = os.path.dirname(source_path)
+        self.base_name = os.path.splitext(os.path.basename(source_path))[0]
+
+    def compile(self) -> str:
+        """
+        Runs the full AOT pipeline.
+        Returns the path to the generated binary.
+        """
+        print(f"Dedekind AOT: Compiling {self.source_path}...")
+        
+        # 1. Lexing & Parsing
+        with open(self.source_path, 'r', encoding='utf-8') as f:
+            source = f.read()
+        
+        lexer = Lexer(source)
+        tokens = lexer.tokenize()
+        parser = Parser(tokens)
+        ast = parser.parse()
+        
+        # 2. MLIR Generation
+        mlir_gen = MLIRCodeGenerator()
+        mlir_ir = mlir_gen.generate(ast)
+        
+        mlir_path = os.path.join(self.output_dir, f"{self.base_name}.mlir")
+        with open(mlir_path, 'w', encoding='utf-8') as f:
+            f.write(mlir_ir)
+        print(f"Dedekind AOT: MLIR generated at {mlir_path}")
+        
+        # 3. Native Mock (Prototype v0.4)
+        # In a full implementation, we would call mlir-opt and mlir-translate here.
+        # For the prototype, we generate a companion C++ 'lowering' of the MLIR to show the path.
+        cpp_path = os.path.join(self.output_dir, f"{self.base_name}_native.cpp")
+        self._generate_cpp_stubs(mlir_ir, cpp_path)
+        
+        binary_path = os.path.join(self.output_dir, f"{self.base_name}.exe")
+        
+        # Attempt to compile if a C++ compiler exists
+        success = self._compile_to_binary(cpp_path, binary_path)
+        
+        if success:
+            return binary_path
+        else:
+            print("Dedekind AOT: Native compiler not found. Project is ready for AOT lowering.")
+            return cpp_path # Return the C++ file for inspection if binary fails
+
+    def _generate_cpp_stubs(self, mlir_ir: str, output_path: str):
+        """Generates a C++ representation of the Dedekind program for native compilation."""
+        with open(output_path, 'w', encoding='utf-8') as f:
+            f.write("#include <iostream>\n")
+            f.write("#include <vector>\n\n")
+            f.write("// Dedekind Native Runtime Stubs\n")
+            f.write("int main() {\n")
+            f.write("    std::cout << \"--- Dedekind Native AOT Runtime ---\" << std::endl;\n")
+            f.write("    std::cout << \"Executing MLIR-lowered kernels...\" << std::endl;\n")
+            f.write("    // The AOT compiler links the Dedekind Dialect to LLVM here.\n")
+            f.write(f"    std::cout << \"Compiled from: {self.source_path}\" << std::endl;\n")
+            f.write("    return 0;\n")
+            f.write("}\n")
+
+    def _compile_to_binary(self, cpp_path: str, output_path: str) -> bool:
+        """Attempts to compile the generated C++/LLVM code using system tools."""
+        compilers = [
+            ['cl', '/EHsc', cpp_path, f'/Fe:{output_path}'],
+            ['clang++', cpp_path, '-o', output_path],
+            ['g++', cpp_path, '-o', output_path],
+        ]
+        for cmd in compilers:
+            try:
+                subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+                print(f"Dedekind AOT: Static binary created via {cmd[0]}")
+                return True
+            except (FileNotFoundError, subprocess.CalledProcessError):
+                continue
+        return False
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1:
+        compiler = AOTCompiler(sys.argv[1])
+        compiler.compile()

dedekind/ast_nodes.py

@@ -0,0 +1,187 @@
+from dataclasses import dataclass, field
+from typing import List, Optional, Union, Any
+
+
+class CompileError(Exception):
+    """Compiler error with line and optional context."""
+    def __init__(self, message: str, line: Optional[int] = None, filepath: Optional[str] = None):
+        self.message = message
+        self.line = line
+        self.filepath = filepath
+        super().__init__(self._format())
+
+    def _format(self) -> str:
+        parts = []
+        if self.filepath:
+            parts.append(self.filepath)
+        if self.line is not None:
+            parts.append(f"Line {self.line}")
+        parts.append(self.message)
+        return ": ".join(str(p) for p in parts)
+
+
+@dataclass
+class Node:
+    """Base for all AST nodes; line for error messages."""
+    line: Optional[int] = field(default=None, kw_only=True)
+
+@dataclass
+class Program(Node):
+    statements: List[Node]
+
+@dataclass
+class FunctionDef(Node):
+    name: str
+    args: List[str]
+    body: List[Node]
+    arg_units: Optional[List[Optional[str]]] = None  # Per-arg unit annotations ([m], [kg], …); None per slot = not annotated
+    return_unit: Optional[str] = None  # Return unit annotation
+    arg_shapes: Optional[List[Optional[List]]] = None  # Per-arg shape annotations (Vector[2], Tensor[batch,N]); None per slot = not annotated
+    return_shape: Optional[List] = None  # Return shape annotation
+    is_pub: bool = False  # `pub fn` -> True; only relevant for module visibility
+    type_params: List[str] = field(default_factory=list)  # `fn name<T, U>(...)`: polymorphic type parameters
+
+
+@dataclass
+class UseStmt(Node):
+    """Module/Import statement: `use math` loads math.ddk into the current compilation pass."""
+    module: str
+
+
+@dataclass
+class UnitDef(Node):
+    """User-defined unit: `unit Foot = 0.3048[m]` registers Foot as a length unit
+    with conversion factor 0.3048 to the base unit. base_unit must already belong to a known dimension."""
+    name: str
+    factor: float
+    base_unit: str
+
+
+@dataclass
+class PyImport(Node):
+    """Imports a Python module from the PyPI ecosystem: `pyimport scipy.special as ss`.
+    Generates an `import MODULE as ALIAS` in the generated code."""
+    module: str
+    alias: str
+
+@dataclass
+class ReturnStmt(Node):
+    value: Node
+
+@dataclass
+class Assignment(Node):
+    target: str
+    value: Node
+
+@dataclass
+class BinaryOp(Node):
+    left: Node
+    op: str
+    right: Node
+
+@dataclass
+class UnaryOp(Node):
+    """Unary operator, e.g., not x."""
+    op: str
+    operand: Node
+
+@dataclass
+class Call(Node):
+    func_name: Node  # Can be an identifier or another call (chaining)
+    args: List[Node]
+    kwargs: List[Any]  # List of (name, value) tuples
+    modifiers: List[str]  # e.g., ['gpu', 'cpu']
+
+@dataclass
+class Identifier(Node):
+    name: str
+
+@dataclass
+class Literal(Node):
+    value: Any
+    raw: bool = False  # True = Raw string (r"...") in Dedekind
+
+@dataclass
+class Quantity(Node):
+    """Physical quantity: number with unit, e.g., 10[m], 5[m/s]."""
+    value: Union[int, float]
+    unit: str
+
+@dataclass
+class QuaternionLiteral(Node):
+    value: float
+    component: str # 'i', 'j', or 'k'
+
+@dataclass
+class VectorLiteral(Node):
+    elements: List[Node]
+
+@dataclass
+class DictLiteral(Node):
+    """Dict literal: {"key": value, "k2": v2} — gets transpiled to a Python dict."""
+    keys: List[Node]
+    values: List[Node]
+
+@dataclass
+class Lambda(Node):
+    arg: str
+    body: Node
+
+@dataclass
+class IfStmt(Node):
+    condition: Node
+    then_branch: List[Node]
+    else_branch: Optional[List[Node]]
+
+@dataclass
+class WhileStmt(Node):
+    condition: Node
+    body: List[Node]
+
+@dataclass
+class ForStmt(Node):
+    variable: str
+    collection: Node
+    body: List[Node]
+
+@dataclass
+class MemberAccess(Node):
+    obj: Node
+    member: str
+
+@dataclass
+class IndexedVariable(Node):
+    name: str
+    indices: str # String of indices, e.g., "ij"
+
+@dataclass
+class Subscript(Node):
+    value: Node
+    index: Node
+
+
+@dataclass
+class Slice(Node):
+    """Python-style slice for subscript indices: x[start:stop:step].
+    Each component can be None (open bound)."""
+    start: Optional[Node] = None
+    stop: Optional[Node] = None
+    step: Optional[Node] = None
+
+
+@dataclass
+class TryCatch(Node):
+    """try { body } catch var { handler } — catches every exception and binds it to var."""
+    body: List[Node]
+    catch_var: str
+    handler: List[Node]
+
+@dataclass
+class ItemAssignment(Node):
+    target: Subscript
+    value: Node
+
+@dataclass
+class PostfixFactorial(Node):
+    """Postfix factorial: n!"""
+    operand: Node

dedekind/build_runtime.py

@@ -0,0 +1,14 @@
+import os
+import glob
+
+src_dir = os.path.join(os.path.dirname(__file__), "runtime_modules")
+out_file = os.path.join(os.path.dirname(__file__), "ml_runtime.py")
+
+modules = sorted(glob.glob(os.path.join(src_dir, "*.py")))
+
+with open(out_file, "w", encoding="utf-8") as out:
+    for mod in modules:
+        with open(mod, "r", encoding="utf-8") as f:
+            out.write(f.read())
+
+print(f"Successfully generated ml_runtime.py from {len(modules)} modules.")

dedekind/cli.py

@@ -0,0 +1,11 @@
+"""CLI entry point: `dedekind <file.ddk> [--latex] [--reproducibility-report PATH] ...`.
+
+Thin wrapper around `dedekind.compiler.main()` so that pip can install a
+shell command. The heavy-lifting argparse-equivalent lives in compiler.py
+for legacy `python -m dedekind.compiler` invocations.
+"""
+from .compiler import main
+
+
+if __name__ == "__main__":
+    main()