pyOS-kernel 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

pyos/__init__.py

@@ -10,7 +10,7 @@ from .memory.gdt import GDT
 from .interrupts.handler import Interrupts
 from .syscalls.handler import SysCall
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"
 __all__ = [
     "Kernel",
     "Screen", 

pyos/boot/bootloader.asm

@@ -1,174 +1,126 @@
-; pyOS Bootloader
-; Simple bootloader that loads kernel and switches to protected mode
-
+; pyOS Bootloader — LBA (int 13h AH=42h), QEMU-friendly
 [BITS 16]
 [ORG 0x7C00]
 
 KERNEL_OFFSET equ 0x1000
+KERNEL_SEGS   equ 0x0000
+KERNEL_SECTORS equ 64
 
 start:
-    ; Setup segments
+    cli
     xor ax, ax
     mov ds, ax
     mov es, ax
     mov ss, ax
     mov sp, 0x7C00
+    sti
+
+    mov [boot_drive], dl
 
-    ; Save boot drive
-    mov [BOOT_DRIVE], dl
+    mov al, 'B'
+    out 0xE9, al
 
-    ; Print message
-    mov si, MSG_BOOT
-    call print
+    ; Check extensions
+    mov ah, 0x41
+    mov bx, 0x55AA
+    mov dl, [boot_drive]
+    int 0x13
+    jc .no_lba
+    cmp bx, 0xAA55
+    jne .no_lba
 
-    ; Load kernel
-    call load_kernel
+    mov al, 'X'
+    out 0xE9, al
 
-    mov si, MSG_OK
-    call print
+    ; LBA read: DAP
+    mov si, dap
+    mov ah, 0x42
+    mov dl, [boot_drive]
+    int 0x13
+    jc .error
 
-    ; Go to protected mode
+    mov al, 'L'
+    out 0xE9, al
+    jmp .pm
+
+.no_lba:
+    ; Fallback CHS: one track from sector 2 (17 sectors)
+    mov al, 'C'
+    out 0xE9, al
+    mov ax, KERNEL_SEGS
+    mov es, ax
+    mov bx, KERNEL_OFFSET
+    mov ah, 0x02
+    mov al, 17
+    mov ch, 0
+    mov cl, 2
+    mov dh, 0
+    mov dl, [boot_drive]
+    int 0x13
+    jc .error
+    mov al, 'L'
+    out 0xE9, al
+
+.pm:
     cli
-    
-    ; Enable A20
     in al, 0x92
     or al, 2
     out 0x92, al
-    
-    ; Load GDT
     lgdt [gdt_desc]
-    
-    ; Enter protected mode
     mov eax, cr0
     or eax, 1
     mov cr0, eax
-    
     jmp 0x08:pm_start
 
-;----------------------------------------
-; Print (SI = string)
-;----------------------------------------
-print:
-    pusha
-.loop:
-    lodsb
-    test al, al
-    jz .done
-    mov ah, 0x0E
-    int 0x10
-    jmp .loop
-.done:
-    popa
-    ret
-
-;----------------------------------------
-; Load kernel - read sectors one by one
-;----------------------------------------
-load_kernel:
-    pusha
-    
-    mov si, MSG_LOAD
-    call print
-    
-    ; Read 16 sectors (8KB) - enough for our kernel
-    mov bx, KERNEL_OFFSET   ; Destination
-    mov cl, 2               ; Start sector
-    mov ch, 0               ; Cylinder
-    mov dh, 0               ; Head
-    mov dl, [BOOT_DRIVE]
-    
-    mov al, 16              ; Sectors to read
-    
-.read:
-    mov ah, 0x02            ; Read function
-    mov al, 1               ; Read 1 sector at a time
-    int 0x13
-    jc .error
-    
-    add bx, 512             ; Next buffer position
-    inc cl                  ; Next sector
-    cmp cl, 18              ; Sector 18 reached?
-    jne .continue
-    mov cl, 1               ; Reset to sector 1
-    inc dh                  ; Next head
-    cmp dh, 2
-    jne .continue
-    mov dh, 0
-    inc ch                  ; Next cylinder
-    
-.continue:
-    cmp bx, KERNEL_OFFSET + (16 * 512)  ; Read 16 sectors?
-    jb .read
-    
-    popa
-    ret
-
 .error:
-    mov si, MSG_ERR
-    call print
+    mov al, 'E'
+    out 0xE9, al
     jmp $
 
-;----------------------------------------
-; GDT
-;----------------------------------------
-gdt_start:
-    dq 0                    ; Null descriptor
+; Disk Address Packet
+align 4
+dap:
+    db 16
+    db 0
+    dw KERNEL_SECTORS
+    dw KERNEL_OFFSET
+    dw KERNEL_SEGS
+    dq 1                 ; LBA 1 (sector after MBR)
 
+gdt_start:
+    dq 0
 gdt_code:
-    dw 0xFFFF               ; Limit
-    dw 0x0000               ; Base low
-    db 0x00                 ; Base mid
-    db 10011010b            ; Access
-    db 11001111b            ; Flags + limit high
-    db 0x00                 ; Base high
-
+    dw 0xFFFF, 0x0000
+    db 0x00, 10011010b, 11001111b, 0x00
 gdt_data:
-    dw 0xFFFF
-    dw 0x0000
-    db 0x00
-    db 10010010b
-    db 11001111b
-    db 0x00
+    dw 0xFFFF, 0x0000
+    db 0x00, 10010010b, 11001111b, 0x00
 gdt_end:
-
 gdt_desc:
     dw gdt_end - gdt_start - 1
     dd gdt_start
 
-;----------------------------------------
-; 32-bit mode
-;----------------------------------------
 [BITS 32]
 pm_start:
-    mov ax, 0x10            ; Data segment
+    mov ax, 0x10
     mov ds, ax
     mov es, ax
     mov fs, ax
     mov gs, ax
     mov ss, ax
     mov esp, 0x90000
-    
-    ; Jump to kernel
+    mov al, 'K'
+    out 0xE9, al
     call KERNEL_OFFSET
-    
-    ; Halt
+    mov al, 'H'
+    out 0xE9, al
     cli
 .halt:
     hlt
     jmp .halt
 
-;----------------------------------------
-; Data
-;----------------------------------------
 [BITS 16]
-BOOT_DRIVE: db 0
-MSG_BOOT:   db "pyOS v0.1", 13, 10, 0
-MSG_LOAD:   db "Loading...", 13, 10, 0
-MSG_OK:     db "OK", 13, 10, 0
-MSG_ERR:    db "Disk Error!", 0
-
-;----------------------------------------
-; Boot signature
-;----------------------------------------
+boot_drive: db 0
+
 times 510 - ($ - $$) db 0
 dw 0xAA55

pyos/builder.py

@@ -1,177 +1,266 @@
 """
-pyOS Builder - Build OS images
+pyOS Builder — bootloader (ASM) + C kernel via MinGW-w64
 """
 
+from __future__ import annotations
+
+import json
+import shutil
 import subprocess
 import tempfile
-import shutil
-import os
 from pathlib import Path
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, List, Optional
+
+from .toolchain import Toolchain
 
 if TYPE_CHECKING:
     from .kernel import Kernel
 
 
 class BuildError(Exception):
-    """Raised when build fails."""
-    pass
+    """Raised when build fails, with human-readable reason."""
+
+    def __init__(self, message: str, hint: str = ""):
+        self.hint = hint
+        full = message
+        if hint:
+            full = f"{message}\n  Hint: {hint}"
+        super().__init__(full)
 
 
 class OSBuilder:
-    """
-    Builds complete OS images from compiled kernel.
-    """
-    
-    def __init__(self, kernel: 'Kernel'):
+    """Builds floppy OS images from Python kernel + C runtime."""
+
+    KERNEL_SECTORS = 64  # must match bootloader.asm
+
+    def __init__(self, kernel: "Kernel"):
         self.kernel = kernel
+        self.runtime_dir = Path(__file__).parent / "runtime"
         self.bootloader_path = Path(__file__).parent / "boot" / "bootloader.asm"
-    
+        self.toolchain = Toolchain()
+        self._last_glue: Optional[str] = None
+        self._last_symbols: list = []
+
+    def get_asm(self) -> str:
+        from .compiler.codegen import CodeGenerator
+
+        gen = CodeGenerator(self.kernel)
+        # Prefer C glue content for inspection
+        return gen.generate()
+
+    def save_asm(self, output_path: str) -> str:
+        glue = self.get_asm()
+        Path(output_path).write_text(glue, encoding="utf-8")
+        return output_path
+
     def build_bin(self, output_path: str) -> str:
-        """
-        Build a raw binary image.
-        
-        Args:
-            output_path: Output file path
-        
-        Returns:
-            Path to the built image.
-        """
-        from .compiler.assembler import Assembler
+        self.toolchain.require()
+        gcc = self.toolchain.gcc
+        nasm = self.toolchain.nasm
+        objcopy = self.toolchain.objcopy
+        if not objcopy:
+            raise BuildError(
+                "objcopy not found next to MinGW gcc",
+                "Reinstall WinLibs/MinGW so objcopy.exe is on PATH",
+            )
+
         from .compiler.codegen import CodeGenerator
-        
-        with tempfile.TemporaryDirectory() as tmpdir:
-            tmpdir = Path(tmpdir)
-            
+
+        generator = CodeGenerator(self.kernel)
+        glue = generator.generate()
+        self._last_glue = glue
+        self._last_symbols = generator.get_symbol_map()
+
+        with tempfile.TemporaryDirectory() as tmp:
+            tmpdir = Path(tmp)
+            glue_c = tmpdir / "glue.c"
+            glue_c.write_text(glue, encoding="utf-8")
+
             # Assemble bootloader
-            assembler = Assembler(self.kernel.config.arch.value)
-            bootloader_bin = tmpdir / "bootloader.bin"
-            
-            bootloader_asm = self.bootloader_path.read_text()
-            assembler.assemble_to_file(bootloader_asm, str(bootloader_bin), "bin")
-            
-            # Generate and assemble kernel
-            generator = CodeGenerator(self.kernel)
-            kernel_asm = generator.generate()
-            
+            boot_bin = tmpdir / "bootloader.bin"
+            self._run(
+                [nasm, "-f", "bin", str(self.bootloader_path), "-o", str(boot_bin)],
+                where="NASM bootloader",
+                hint="Check pyos/boot/bootloader.asm for syntax errors",
+            )
+
+            # Assemble start.S / isr.S with GCC (matches MinGW symbol decoration)
+            start_o = tmpdir / "start.o"
+            isr_o = tmpdir / "isr.o"
+            self._run(
+                [gcc, "-m32", "-c", str(self.runtime_dir / "src" / "start.S"), "-o", str(start_o)],
+                where="GCC assemble start.S",
+            )
+            self._run(
+                [gcc, "-m32", "-c", str(self.runtime_dir / "src" / "isr.S"), "-o", str(isr_o)],
+                where="GCC assemble isr.S",
+            )
+
+            c_sources = [
+                "debug.c",
+                "screen.c",
+                "keyboard.c",
+                "pic.c",
+                "idt.c",
+                "heap.c",
+                "syscall.c",
+                "kmain.c",
+            ]
+            objects: List[Path] = [start_o, isr_o]
+            include = str(self.runtime_dir / "include")
+            cflags = [
+                "-m32",
+                "-ffreestanding",
+                "-fno-builtin",
+                "-fno-stack-protector",
+                "-fno-pic",
+                "-fno-asynchronous-unwind-tables",
+                "-fno-exceptions",
+                "-nostdlib",
+                "-Wall",
+                "-Wextra",
+                "-O1",
+                f"-I{include}",
+            ]
+
+            for name in c_sources:
+                src = self.runtime_dir / "src" / name
+                obj = tmpdir / (name.replace(".c", ".o"))
+                self._run(
+                    [gcc, *cflags, "-c", str(src), "-o", str(obj)],
+                    where=f"GCC compile {name}",
+                    hint="A C runtime file failed to compile — see compiler output above",
+                )
+                objects.append(obj)
+
+            glue_o = tmpdir / "glue.o"
+            self._run(
+                [gcc, *cflags, "-c", str(glue_c), "-o", str(glue_o)],
+                where="GCC compile generated glue.c",
+                hint="Your Python Screen/Memory ops produced invalid C — check print strings and positions",
+            )
+            objects.append(glue_o)
+
             kernel_bin = tmpdir / "kernel.bin"
-            assembler.assemble_to_file(kernel_asm, str(kernel_bin), "bin")
-            
-            # Combine bootloader + kernel
-            with open(output_path, "wb") as out:
-                # Write bootloader (512 bytes)
-                bootloader_data = bootloader_bin.read_bytes()
-                out.write(bootloader_data)
-                
-                # Write kernel
-                kernel_data = kernel_bin.read_bytes()
-                out.write(kernel_data)
-                
-                # Pad to 16 sectors (8KB) after bootloader
-                current_size = len(bootloader_data) + len(kernel_data)
-                target_size = 512 + (16 * 512)  # Bootloader + 16 sectors
-                if current_size < target_size:
-                    out.write(bytes(target_size - current_size))
-        
-        return output_path
-    
+            map_file = tmpdir / "kernel.map"
+            pe = tmpdir / "kernel.pe"
+            ld = self.toolchain.ld
+            # Link PE/COFF first, then strip to flat binary at VMA 0x1000
+            if ld:
+                self._run(
+                    [
+                        ld,
+                        "-m",
+                        "i386pe",
+                        "--image-base",
+                        "0",
+                        "-T",
+                        str(self.runtime_dir / "linker.ld"),
+                        "-Map",
+                        str(map_file),
+                        "-o",
+                        str(pe),
+                        *[str(o) for o in objects],
+                    ],
+                    where="ld link kernel (PE)",
+                    hint="Missing symbol usually means glue/runtime mismatch",
+                )
+            else:
+                self._run(
+                    [
+                        gcc,
+                        "-m32",
+                        "-ffreestanding",
+                        "-nostdlib",
+                        "-nostartfiles",
+                        "-Wl,-T," + str(self.runtime_dir / "linker.ld"),
+                        "-Wl,-Map," + str(map_file),
+                        "-o",
+                        str(pe),
+                        *[str(o) for o in objects],
+                    ],
+                    where="GCC link kernel",
+                    hint="Missing symbol usually means glue/runtime mismatch",
+                )
+            self._run(
+                [objcopy, "-O", "binary", str(pe), str(kernel_bin)],
+                where="objcopy PE -> flat binary",
+            )
+
+            boot_data = boot_bin.read_bytes()
+            if len(boot_data) != 512 or boot_data[-2:] != b"\x55\xaa":
+                raise BuildError(
+                    "Bootloader is invalid (expected 512-byte sector ending with 0x55AA)",
+                    "bootloader.asm must end with times 510-($-$$) db 0 / dw 0xAA55",
+                )
+
+            kernel_data = kernel_bin.read_bytes()
+            max_kernel = self.KERNEL_SECTORS * 512
+            if len(kernel_data) > max_kernel:
+                raise BuildError(
+                    f"Kernel is too large ({len(kernel_data)} bytes > {max_kernel} byte limit)",
+                    "Reduce Screen.print strings or raise KERNEL_SECTORS in bootloader + builder",
+                )
+
+            # Write symbol map beside output for human debug
+            out = Path(output_path)
+            out.parent.mkdir(parents=True, exist_ok=True)
+            map_path = out.with_suffix(out.suffix + ".symbols.json")
+            map_path.write_text(
+                json.dumps(
+                    {
+                        "symbols": self._last_symbols,
+                        "kernel_bytes": len(kernel_data),
+                        "heap_size": self.kernel.config.heap_size,
+                    },
+                    indent=2,
+                ),
+                encoding="utf-8",
+            )
+
+            # Pad to a full 1.44MB floppy so BIOS int 0x13 does not hang in QEMU
+            floppy_size = 1474560
+            with open(out, "wb") as f:
+                f.write(boot_data)
+                f.write(kernel_data)
+                current = len(boot_data) + len(kernel_data)
+                if current < floppy_size:
+                    f.write(bytes(floppy_size - current))
+
+            # Also copy map file from linker if present
+            link_map = tmpdir / "kernel.map"
+            if link_map.exists():
+                shutil.copy(link_map, out.with_suffix(out.suffix + ".map"))
+
+        return str(output_path)
+
     def build_iso(self, output_path: str) -> str:
         """
-        Build an ISO image for CD/USB boot.
-        
-        Args:
-            output_path: Output file path
-        
-        Returns:
-            Path to the built ISO.
+        Build a bootable image.
+
+        Without grub-mkrescue, writes a floppy-style .bin under the given path
+        (QEMU should boot it with -fda). True ISO requires grub-mkrescue.
         """
-        with tempfile.TemporaryDirectory() as tmpdir:
-            tmpdir = Path(tmpdir)
-            
-            # Build binary first
-            bin_path = tmpdir / "os.bin"
-            self.build_bin(str(bin_path))
-            
-            # Create ISO directory structure
-            iso_dir = tmpdir / "iso"
-            boot_dir = iso_dir / "boot"
-            grub_dir = boot_dir / "grub"
-            grub_dir.mkdir(parents=True)
-            
-            # Copy kernel
-            shutil.copy(bin_path, boot_dir / "kernel.bin")
-            
-            # Create GRUB config
-            grub_cfg = grub_dir / "grub.cfg"
-            grub_cfg.write_text("""
-set timeout=0
-set default=0
-
-menuentry "pyOS" {
-    multiboot /boot/kernel.bin
-    boot
-}
-""")
-            
-            # Try to create ISO with grub-mkrescue
-            if self._has_grub_mkrescue():
-                self._create_iso_grub(iso_dir, output_path)
-            else:
-                # Fallback: just copy the binary
-                shutil.copy(bin_path, output_path)
-                print("Warning: grub-mkrescue not found, created raw binary instead of ISO")
-        
-        return output_path
-    
-    def _has_grub_mkrescue(self) -> bool:
-        """Check if grub-mkrescue is available."""
-        try:
-            result = subprocess.run(
-                ["grub-mkrescue", "--version"],
-                capture_output=True,
+        out = Path(output_path)
+        # Always produce a working floppy image first
+        bin_path = out.with_suffix(".bin") if out.suffix.lower() == ".iso" else out
+        self.build_bin(str(bin_path))
+
+        if out.suffix.lower() == ".iso":
+            # Honest fallback: copy bin to requested path and warn via print
+            shutil.copy(bin_path, out)
+            print(
+                "Warning: created floppy-boot image at "
+                f"{out} (not a GRUB ISO). Run with: qemu-system-i386 -fda {out}"
             )
-            return result.returncode == 0
-        except FileNotFoundError:
-            return False
-    
-    def _create_iso_grub(self, iso_dir: Path, output_path: str) -> None:
-        """Create ISO using grub-mkrescue."""
-        cmd = [
-            "grub-mkrescue",
-            "-o", output_path,
-            str(iso_dir),
-        ]
-        
+        return str(out)
+
+    def _run(self, cmd: List[str], where: str, hint: str = "") -> None:
         result = subprocess.run(cmd, capture_output=True, text=True)
-        
-        if result.returncode != 0:
-            raise BuildError(f"grub-mkrescue failed:\n{result.stderr}")
-    
-    def get_asm(self) -> str:
-        """
-        Get the generated Assembly code.
-        
-        Returns:
-            Assembly source code.
-        """
-        from .compiler.codegen import CodeGenerator
-        
-        generator = CodeGenerator(self.kernel)
-        return generator.generate()
-    
-    def save_asm(self, output_path: str) -> str:
-        """
-        Save generated Assembly to file.
-        
-        Args:
-            output_path: Output file path
-        
-        Returns:
-            Path to saved file.
-        """
-        asm = self.get_asm()
-        
-        with open(output_path, "w") as f:
-            f.write(asm)
-        
-        return output_path
+        if result.returncode == 0:
+            return
+        err = (result.stderr or result.stdout or "").strip()
+        raise BuildError(
+            f"Build failed at: {where}\n{err}",
+            hint or "Run `pyos check` to verify gcc/nasm/qemu",
+        )