pyOS-kernel 0.1.0__py3-none-any.whl

pyos/compiler/assembler.py

@@ -0,0 +1,180 @@
+"""
+pyOS Assembler - Assembly to Machine Code
+"""
+
+import subprocess
+import tempfile
+import os
+from typing import Optional
+from pathlib import Path
+
+
+class AssemblerError(Exception):
+    """Raised when assembly fails."""
+    pass
+
+
+class Assembler:
+    """
+    Assembles x86/x86_64 Assembly code to machine code.
+    
+    Uses NASM (Netwide Assembler) for assembly.
+    """
+    
+    def __init__(self, arch: str = "x86"):
+        """
+        Initialize assembler.
+        
+        Args:
+            arch: Target architecture ("x86" or "x86_64")
+        """
+        self.arch = arch
+        self.nasm_path = self._find_nasm()
+    
+    def _find_nasm(self) -> str:
+        """Find NASM executable."""
+        # Try common locations
+        paths = [
+            "nasm",
+            "/usr/bin/nasm",
+            "/usr/local/bin/nasm",
+            "C:\\Program Files\\NASM\\nasm.exe",
+            "C:\\NASM\\nasm.exe",
+        ]
+        
+        for path in paths:
+            try:
+                result = subprocess.run(
+                    [path, "-v"],
+                    capture_output=True,
+                    text=True,
+                )
+                if result.returncode == 0:
+                    return path
+            except FileNotFoundError:
+                continue
+        
+        return "nasm"  # Hope it's in PATH
+    
+    def assemble(self, asm_code: str, output_format: str = "bin") -> bytes:
+        """
+        Assemble code to machine code.
+        
+        Args:
+            asm_code: Assembly source code
+            output_format: Output format (bin, elf, elf64)
+        
+        Returns:
+            Binary machine code.
+        
+        Raises:
+            AssemblerError: If assembly fails.
+        """
+        with tempfile.TemporaryDirectory() as tmpdir:
+            asm_file = Path(tmpdir) / "kernel.asm"
+            out_file = Path(tmpdir) / "kernel.bin"
+            
+            # Write assembly to file
+            asm_file.write_text(asm_code)
+            
+            # Determine format
+            if self.arch == "x86_64":
+                fmt = "elf64" if output_format == "elf" else output_format
+            else:
+                fmt = "elf32" if output_format == "elf" else output_format
+            
+            # Run NASM
+            cmd = [
+                self.nasm_path,
+                "-f", fmt,
+                "-o", str(out_file),
+                str(asm_file),
+            ]
+            
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+            )
+            
+            if result.returncode != 0:
+                raise AssemblerError(f"NASM failed:\n{result.stderr}")
+            
+            # Read binary output
+            return out_file.read_bytes()
+    
+    def assemble_to_file(self, asm_code: str, output_path: str, output_format: str = "bin") -> str:
+        """
+        Assemble code and write to file.
+        
+        Args:
+            asm_code: Assembly source code
+            output_path: Output file path
+            output_format: Output format
+        
+        Returns:
+            Path to output file.
+        """
+        binary = self.assemble(asm_code, output_format)
+        
+        with open(output_path, "wb") as f:
+            f.write(binary)
+        
+        return output_path
+    
+    def link(self, object_files: list, output_path: str) -> str:
+        """
+        Link object files into executable.
+        
+        Args:
+            object_files: List of object file paths
+            output_path: Output executable path
+        
+        Returns:
+            Path to linked executable.
+        """
+        # Use ld for linking
+        cmd = ["ld", "-m"]
+        
+        if self.arch == "x86_64":
+            cmd.append("elf_x86_64")
+        else:
+            cmd.append("elf_i386")
+        
+        cmd.extend(["-T", "linker.ld"])
+        cmd.extend(["-o", output_path])
+        cmd.extend(object_files)
+        
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        
+        if result.returncode != 0:
+            raise AssemblerError(f"Linker failed:\n{result.stderr}")
+        
+        return output_path
+    
+    @staticmethod
+    def is_nasm_available() -> bool:
+        """Check if NASM is available."""
+        try:
+            result = subprocess.run(
+                ["nasm", "-v"],
+                capture_output=True,
+            )
+            return result.returncode == 0
+        except FileNotFoundError:
+            return False
+    
+    @staticmethod
+    def get_nasm_version() -> Optional[str]:
+        """Get NASM version string."""
+        try:
+            result = subprocess.run(
+                ["nasm", "-v"],
+                capture_output=True,
+                text=True,
+            )
+            if result.returncode == 0:
+                return result.stdout.strip()
+        except FileNotFoundError:
+            pass
+        return None

pyos/compiler/codegen.py

@@ -0,0 +1,238 @@
+"""
+pyOS Code Generator - Generates Assembly from Python
+"""
+
+from typing import TYPE_CHECKING, List, Dict, Any
+from ..drivers.screen import Screen
+from ..drivers.keyboard import Keyboard
+from ..memory.manager import Memory
+from ..memory.gdt import GDT
+
+if TYPE_CHECKING:
+    from ..kernel import Kernel
+
+
+class CodeGenerator:
+    """
+    Generates x86/x86_64 Assembly code from Python kernel code.
+    """
+    
+    def __init__(self, kernel: 'Kernel'):
+        self.kernel = kernel
+        self.arch = kernel.config.arch.value
+        self.asm_lines: List[str] = []
+        self.string_counter = 0
+        self.label_counter = 0
+        self._strings_to_emit = []
+        self._func_operations = {}  # Operations per function
+    
+    def generate(self) -> str:
+        """Generate complete Assembly code."""
+        self.asm_lines = []
+        self.string_counter = 0
+        self._strings_to_emit = []
+        self._func_operations = {}
+        
+        # Execute each boot function separately and capture its operations
+        for boot_func in self.kernel._boot_functions:
+            Screen._reset()
+            boot_func.func()
+            ops = Screen._get_operations().copy()
+            self._func_operations[boot_func.name] = ops
+            
+            # Collect strings from this function
+            for op in ops:
+                if op["type"] == "print" and "text" in op:
+                    label = f"str_{self.string_counter}"
+                    self.string_counter += 1
+                    text = op["text"]
+                    self._strings_to_emit.append((label, text))
+                    op["_string_label"] = label
+        
+        # Header
+        self._emit_header()
+        
+        # Text section
+        self._emit_text_section()
+        
+        return '\n'.join(self.asm_lines)
+    
+    def _emit(self, line: str) -> None:
+        """Emit a line of assembly."""
+        self.asm_lines.append(line)
+    
+    def _emit_header(self) -> None:
+        """Emit assembly header."""
+        self._emit("; pyOS Generated Kernel")
+        self._emit(f"; Architecture: {self.arch}")
+        self._emit("; Generated by pyOS Compiler")
+        self._emit("")
+        
+        if self.arch == "x86":
+            self._emit("[BITS 32]")
+        else:
+            self._emit("[BITS 64]")
+        
+        self._emit("[ORG 0x1000]")
+        self._emit("")
+    
+    def _emit_text_section(self) -> None:
+        """Emit text section with code."""
+        self._emit("; ==================")
+        self._emit("; Kernel Entry Point")
+        self._emit("; ==================")
+        self._emit("")
+        self._emit("_start:")
+        self._emit("    mov esp, 0x90000")
+        
+        # Call boot functions in correct order (sorted by priority, lower first)
+        sorted_funcs = sorted(self.kernel._boot_functions, key=lambda x: x.priority)
+        
+        self._emit("")
+        self._emit("    ; Call boot functions")
+        for boot_func in sorted_funcs:
+            self._emit(f"    call {boot_func.name}")
+        
+        # Main loop
+        self._emit("")
+        self._emit("    ; Main loop - halt CPU")
+        self._emit(".main_loop:")
+        self._emit("    hlt")
+        self._emit("    jmp .main_loop")
+        
+        # Generate boot functions
+        self._emit("")
+        self._generate_boot_functions()
+        
+        # Generate helper functions
+        self._emit("")
+        self._generate_screen_functions()
+        self._generate_keyboard_functions()
+    
+    def _generate_boot_functions(self) -> None:
+        """Generate code for boot functions."""
+        for boot_func in self.kernel._boot_functions:
+            self._emit(f"; Function: {boot_func.name}")
+            self._emit(f"{boot_func.name}:")
+            self._emit("    push ebp")
+            self._emit("    mov ebp, esp")
+            
+            # Get operations for THIS function only
+            ops = self._func_operations.get(boot_func.name, [])
+            
+            # Generate code for screen operations
+            for op in ops:
+                if op["type"] == "clear":
+                    self._emit("    call screen_clear")
+                elif op["type"] == "print":
+                    label = op.get("_string_label", "str_0")
+                    row = op.get("row", 0)
+                    col = op.get("col", 0)
+                    fg = op.get("foreground", 15)
+                    bg = op.get("background", 0)
+                    color = (bg << 4) | fg
+                    self._emit(f"    push dword {color}")
+                    self._emit(f"    push dword {col}")
+                    self._emit(f"    push dword {row}")
+                    self._emit(f"    push dword {label}")
+                    self._emit("    call screen_print")
+                    self._emit("    add esp, 16")
+            
+            self._emit("    pop ebp")
+            self._emit("    ret")
+            self._emit("")
+    
+    def _generate_screen_functions(self) -> None:
+        """Generate VGA screen functions."""
+        self._emit("; ==================")
+        self._emit("; Screen Functions")
+        self._emit("; ==================")
+        self._emit("VGA_MEMORY equ 0xB8000")
+        self._emit("VGA_WIDTH equ 80")
+        self._emit("VGA_HEIGHT equ 25")
+        self._emit("")
+        
+        # screen_clear
+        self._emit("screen_clear:")
+        self._emit("    push ebp")
+        self._emit("    mov ebp, esp")
+        self._emit("    push edi")
+        self._emit("    push eax")
+        self._emit("    push ecx")
+        self._emit("")
+        self._emit("    mov edi, VGA_MEMORY")
+        self._emit("    mov ecx, VGA_WIDTH * VGA_HEIGHT")
+        self._emit("    mov ax, 0x0720")
+        self._emit("    rep stosw")
+        self._emit("")
+        self._emit("    pop ecx")
+        self._emit("    pop eax")
+        self._emit("    pop edi")
+        self._emit("    pop ebp")
+        self._emit("    ret")
+        self._emit("")
+        
+        # screen_print (string, row, col, color)
+        self._emit("screen_print:")
+        self._emit("    push ebp")
+        self._emit("    mov ebp, esp")
+        self._emit("    push esi")
+        self._emit("    push edi")
+        self._emit("    push eax")
+        self._emit("    push ebx")
+        self._emit("")
+        self._emit("    mov esi, [ebp+8]")
+        self._emit("    mov eax, [ebp+12]")
+        self._emit("    mov ebx, VGA_WIDTH * 2")
+        self._emit("    mul ebx")
+        self._emit("    mov edi, [ebp+16]")
+        self._emit("    shl edi, 1")
+        self._emit("    add edi, eax")
+        self._emit("    add edi, VGA_MEMORY")
+        self._emit("    mov ah, [ebp+20]")
+        self._emit("")
+        self._emit(".sp_loop:")
+        self._emit("    lodsb")
+        self._emit("    test al, al")
+        self._emit("    jz .sp_done")
+        self._emit("    stosw")
+        self._emit("    jmp .sp_loop")
+        self._emit("")
+        self._emit(".sp_done:")
+        self._emit("    pop ebx")
+        self._emit("    pop eax")
+        self._emit("    pop edi")
+        self._emit("    pop esi")
+        self._emit("    pop ebp")
+        self._emit("    ret")
+        self._emit("")
+    
+    def _generate_keyboard_functions(self) -> None:
+        """Generate keyboard functions."""
+        self._emit("; ==================")
+        self._emit("; Keyboard Functions")
+        self._emit("; ==================")
+        self._emit("KEYBOARD_DATA_PORT equ 0x60")
+        self._emit("KEYBOARD_STATUS_PORT equ 0x64")
+        self._emit("")
+        
+        self._emit("keyboard_read_scancode:")
+        self._emit("    push ebp")
+        self._emit("    mov ebp, esp")
+        self._emit(".kb_wait:")
+        self._emit("    in al, KEYBOARD_STATUS_PORT")
+        self._emit("    test al, 1")
+        self._emit("    jz .kb_wait")
+        self._emit("    in al, KEYBOARD_DATA_PORT")
+        self._emit("    movzx eax, al")
+        self._emit("    pop ebp")
+        self._emit("    ret")
+        self._emit("")
+        
+        # Emit strings at the end
+        self._emit("; ==================")
+        self._emit("; Data Section")
+        self._emit("; ==================")
+        for label, text in self._strings_to_emit:
+            escaped = text.replace('\\', '\\\\').replace('"', '\\"')
+            self._emit(f'{label}: db "{escaped}", 0')

pyos/drivers/__init__.py

@@ -0,0 +1,8 @@
+"""
+pyOS Hardware Drivers
+"""
+
+from .screen import Screen
+from .keyboard import Keyboard
+
+__all__ = ["Screen", "Keyboard"]