pyOS-kernel 0.1.0__py3-none-any.whl

pyos/__init__.py

@@ -0,0 +1,22 @@
+"""
+pyOS - Build Operating Systems with Python
+"""
+
+from .kernel import Kernel
+from .drivers.screen import Screen
+from .drivers.keyboard import Keyboard
+from .memory.manager import Memory
+from .memory.gdt import GDT
+from .interrupts.handler import Interrupts
+from .syscalls.handler import SysCall
+
+__version__ = "0.1.0"
+__all__ = [
+    "Kernel",
+    "Screen", 
+    "Keyboard",
+    "Memory",
+    "GDT",
+    "Interrupts",
+    "SysCall",
+]

pyos/boot/__init__.py

@@ -0,0 +1,3 @@
+"""
+pyOS Boot Components
+"""

pyos/boot/bootloader.asm

@@ -0,0 +1,174 @@
+; pyOS Bootloader
+; Simple bootloader that loads kernel and switches to protected mode
+
+[BITS 16]
+[ORG 0x7C00]
+
+KERNEL_OFFSET equ 0x1000
+
+start:
+    ; Setup segments
+    xor ax, ax
+    mov ds, ax
+    mov es, ax
+    mov ss, ax
+    mov sp, 0x7C00
+
+    ; Save boot drive
+    mov [BOOT_DRIVE], dl
+
+    ; Print message
+    mov si, MSG_BOOT
+    call print
+
+    ; Load kernel
+    call load_kernel
+
+    mov si, MSG_OK
+    call print
+
+    ; Go to protected mode
+    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
+    jmp $
+
+;----------------------------------------
+; GDT
+;----------------------------------------
+gdt_start:
+    dq 0                    ; Null descriptor
+
+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
+
+gdt_data:
+    dw 0xFFFF
+    dw 0x0000
+    db 0x00
+    db 10010010b
+    db 11001111b
+    db 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 ds, ax
+    mov es, ax
+    mov fs, ax
+    mov gs, ax
+    mov ss, ax
+    mov esp, 0x90000
+    
+    ; Jump to kernel
+    call KERNEL_OFFSET
+    
+    ; Halt
+    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
+;----------------------------------------
+times 510 - ($ - $$) db 0
+dw 0xAA55

pyos/builder.py

@@ -0,0 +1,177 @@
+"""
+pyOS Builder - Build OS images
+"""
+
+import subprocess
+import tempfile
+import shutil
+import os
+from pathlib import Path
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from .kernel import Kernel
+
+
+class BuildError(Exception):
+    """Raised when build fails."""
+    pass
+
+
+class OSBuilder:
+    """
+    Builds complete OS images from compiled kernel.
+    """
+    
+    def __init__(self, kernel: 'Kernel'):
+        self.kernel = kernel
+        self.bootloader_path = Path(__file__).parent / "boot" / "bootloader.asm"
+    
+    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
+        from .compiler.codegen import CodeGenerator
+        
+        with tempfile.TemporaryDirectory() as tmpdir:
+            tmpdir = Path(tmpdir)
+            
+            # 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()
+            
+            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
+    
+    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.
+        """
+        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,
+            )
+            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),
+        ]
+        
+        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

pyos/cli.py

@@ -0,0 +1,286 @@
+"""
+pyOS Command Line Interface
+"""
+
+import click
+import sys
+from pathlib import Path
+
+
+@click.group()
+@click.version_option(version="0.1.0", prog_name="pyOS")
+def main():
+    """
+    pyOS - Build Operating Systems with Python
+    
+    Write your OS in Python, compile to Assembly and Machine Code.
+    """
+    pass
+
+
+@main.command()
+@click.argument("source", type=click.Path(exists=True))
+@click.option("-o", "--output", default="os.iso", help="Output file path")
+@click.option("-f", "--format", "fmt", type=click.Choice(["iso", "bin"]), default="iso", help="Output format")
+@click.option("-a", "--arch", type=click.Choice(["x86", "x86_64"]), default="x86", help="Target architecture")
+@click.option("-v", "--verbose", is_flag=True, help="Verbose output")
+def build(source: str, output: str, fmt: str, arch: str, verbose: bool):
+    """
+    Build OS from Python source file.
+    
+    Example:
+        pyos build main.py -o myos.iso
+    """
+    click.echo(f"Building {source} -> {output}")
+    
+    try:
+        # Import and execute the source file
+        source_path = Path(source)
+        
+        if verbose:
+            click.echo(f"  Architecture: {arch}")
+            click.echo(f"  Format: {fmt}")
+        
+        # Read and execute the Python file
+        code = source_path.read_text()
+        
+        # Create a namespace for execution
+        namespace = {}
+        exec(code, namespace)
+        
+        # Find the kernel object
+        kernel = None
+        for name, obj in namespace.items():
+            if hasattr(obj, 'build') and hasattr(obj, '_boot_functions'):
+                kernel = obj
+                break
+        
+        if kernel is None:
+            click.echo("Error: No Kernel object found in source file", err=True)
+            sys.exit(1)
+        
+        # Build
+        result = kernel.build(output, format=fmt)
+        
+        click.echo(f"✓ Built successfully: {result}")
+        
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        if verbose:
+            import traceback
+            traceback.print_exc()
+        sys.exit(1)
+
+
+@main.command()
+@click.argument("image", type=click.Path(exists=True))
+@click.option("-m", "--memory", default=128, help="Memory in MB")
+@click.option("-d", "--debug", is_flag=True, help="Enable debug mode (GDB)")
+def run(image: str, memory: int, debug: bool):
+    """
+    Run OS image in QEMU.
+    
+    Example:
+        pyos run myos.iso
+        pyos run myos.bin --debug
+    """
+    from .emulator import QEMURunner, QEMUError
+    
+    click.echo(f"Running {image} in QEMU...")
+    
+    if debug:
+        click.echo("Debug mode enabled. Connect GDB to localhost:1234")
+    
+    try:
+        runner = QEMURunner()
+        process = runner.run(image, memory=memory, debug=debug)
+        
+        click.echo("QEMU started. Close the window to exit.")
+        process.wait()
+        
+    except QEMUError as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+@main.command()
+@click.argument("image", type=click.Path(exists=True))
+@click.option("-m", "--memory", default=128, help="Memory in MB")
+def debug(image: str, memory: int):
+    """
+    Run OS in debug mode with GDB server.
+    
+    Example:
+        pyos debug myos.iso
+    
+    Then connect with: gdb -ex "target remote localhost:1234"
+    """
+    from .emulator import QEMURunner, QEMUError
+    
+    click.echo(f"Starting {image} in debug mode...")
+    click.echo("GDB server listening on localhost:1234")
+    click.echo("Connect with: gdb -ex 'target remote localhost:1234'")
+    click.echo("")
+    
+    try:
+        runner = QEMURunner()
+        process = runner.run(image, memory=memory, debug=True)
+        process.wait()
+        
+    except QEMUError as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+@main.command()
+@click.argument("source", type=click.Path(exists=True))
+@click.option("-o", "--output", default="output.asm", help="Output file path")
+def asm(source: str, output: str):
+    """
+    Generate Assembly code from Python source.
+    
+    Example:
+        pyos asm main.py -o kernel.asm
+    """
+    click.echo(f"Generating Assembly: {source} -> {output}")
+    
+    try:
+        source_path = Path(source)
+        code = source_path.read_text()
+        
+        namespace = {}
+        exec(code, namespace)
+        
+        kernel = None
+        for name, obj in namespace.items():
+            if hasattr(obj, 'compile') and hasattr(obj, '_boot_functions'):
+                kernel = obj
+                break
+        
+        if kernel is None:
+            click.echo("Error: No Kernel object found", err=True)
+            sys.exit(1)
+        
+        asm_code = kernel.compile()
+        
+        with open(output, "w") as f:
+            f.write(asm_code)
+        
+        click.echo(f"✓ Assembly generated: {output}")
+        
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+@main.command()
+def check():
+    """
+    Check if required tools are installed.
+    
+    Example:
+        pyos check
+    """
+    from .compiler.assembler import Assembler
+    from .emulator import QEMURunner
+    
+    click.echo("Checking required tools...")
+    click.echo("")
+    
+    # Check NASM
+    if Assembler.is_nasm_available():
+        version = Assembler.get_nasm_version()
+        click.echo(f"✓ NASM: {version}")
+    else:
+        click.echo("✗ NASM: Not found")
+        click.echo("  Install: https://www.nasm.us/")
+    
+    # Check QEMU
+    if QEMURunner.is_available():
+        version = QEMURunner.get_version()
+        click.echo(f"✓ QEMU: {version}")
+    else:
+        click.echo("✗ QEMU: Not found")
+        click.echo("  Install: https://www.qemu.org/download/")
+    
+    click.echo("")
+
+
+@main.command()
+@click.argument("name", default="myos")
+def new(name: str):
+    """
+    Create a new pyOS project.
+    
+    Example:
+        pyos new myos
+    """
+    project_dir = Path(name)
+    
+    if project_dir.exists():
+        click.echo(f"Error: Directory '{name}' already exists", err=True)
+        sys.exit(1)
+    
+    project_dir.mkdir()
+    
+    # Create main.py
+    main_py = project_dir / "main.py"
+    main_py.write_text('''"""
+My Operating System built with pyOS
+"""
+
+from pyos import Kernel, Screen
+
+# Create kernel
+kernel = Kernel(arch="x86")
+
+@kernel.on_boot
+def main():
+    """Main boot function."""
+    Screen.clear()
+    Screen.set_color("green", "black")
+    Screen.print("Welcome to My OS!")
+    Screen.print("Built with pyOS", row=2)
+    Screen.set_color("white", "black")
+    Screen.print("Press any key...", row=4)
+
+# Build the OS
+if __name__ == "__main__":
+    kernel.build("myos.iso")
+''')
+    
+    # Create README
+    readme = project_dir / "README.md"
+    readme.write_text(f'''# {name}
+
+An operating system built with pyOS.
+
+## Build
+
+```bash
+pyos build main.py -o {name}.iso
+```
+
+## Run
+
+```bash
+pyos run {name}.iso
+```
+
+## Debug
+
+```bash
+pyos debug {name}.iso
+```
+''')
+    
+    click.echo(f"✓ Created new pyOS project: {name}/")
+    click.echo("")
+    click.echo("Next steps:")
+    click.echo(f"  cd {name}")
+    click.echo(f"  pyos build main.py -o {name}.iso")
+    click.echo(f"  pyos run {name}.iso")
+
+
+if __name__ == "__main__":
+    main()

pyos/compiler/__init__.py

@@ -0,0 +1,8 @@
+"""
+pyOS Compiler - Python to Assembly
+"""
+
+from .codegen import CodeGenerator
+from .assembler import Assembler
+
+__all__ = ["CodeGenerator", "Assembler"]