exe_reloc.asm

; -----------------------------------------------------------
; Minimal MZ (.EXE) relocator — called from Stage 2
; Expects: DS = LOAD_SEG (0x1010), where file is loaded
;          ES = PSP_SEG  (0x1000)
; Returns: carries out relocation, sets up PSP, far-jumps to CS:IP
; 1000% 8086 compatible (no 386+ instructions, no FS/GS, correct SP)
; -----------------------------------------------------------
do_exe_reloc:
    ; ---- Parse MZ header from DS:0 (0x1010:0) ----
    mov  ax, [ds:0x0E]      ; AX = initial_SS
    mov  dx, [ds:0x10]      ; DX = initial_SP
    mov  bp, [ds:0x14]      ; BP = initial_IP
    mov  di, [ds:0x16]      ; DI = initial_CS

    ; Save program stack/entry values on relocator's stack
    push ax                 ; [sp+6] = initial_SS
    push dx                 ; [sp+4] = initial_SP
    push bp                 ; [sp+2] = initial_IP
    push di                 ; [sp]   = initial_CS

    ; ---- 1. Apply relocations directly to source image BEFORE copying ----
    ; This avoids corruption when the copy loop overlaps and overwrites the source header/reloc table.
    mov  cx, [ds:0x06]      ; CX = count of relocations
    mov  si, [ds:0x18]      ; SI = reloc table offset in DS (0x1010)
    mov  ax, es
    add  ax, 0x10           ; AX = target program segment (0x1010)
    
    mov  bx, [ds:0x08]      ; BX = header size in paragraphs
    mov  bp, ds
    add  bp, bx             ; BP = source program image segment (0x1010 + header_paragraphs)

.reloc_loop:
    jcxz .reloc_done
    mov  bx, [ds:si]        ; BX = offset of word to patch
    mov  dx, [ds:si+2]      ; DX = relative segment of word to patch
    add  si, 4

    add  dx, bp             ; DX = absolute patch segment in source
    push es
    mov  es, dx
    add  [es:bx], ax        ; adjust the segment pointer by target_segment (0x1010)
    pop  es

    loop .reloc_loop
.reloc_done:

    ; ---- 2. Calculate image size in paragraphs from MZ header ----
    mov  ax, [ds:0x04]      ; AX = pages
    mov  bx, [ds:0x02]      ; BX = bytes in last page
    test bx, bx
    jz   .last_page_zero
    
    dec  ax                  ; AX = pages - 1
    shl  ax, 1
    shl  ax, 1
    shl  ax, 1
    shl  ax, 1
    shl  ax, 1              ; AX = AX * 32
    
    add  bx, 15
    shr  bx, 1
    shr  bx, 1
    shr  bx, 1
    shr  bx, 1              ; BX = BX / 16 (paragraphs)
    add  ax, bx             ; AX = total file paragraphs
    jmp  .sub_header

.last_page_zero:
    shl  ax, 1
    shl  ax, 1
    shl  ax, 1
    shl  ax, 1
    shl  ax, 1              ; AX = AX * 32

.sub_header:
    mov  bx, [ds:0x08]      ; BX = header size in paragraphs
    sub  ax, bx             ; AX = image size in paragraphs
    mov  bp, ax             ; BP = image size in paragraphs

    ; ---- Set free_mem_ptr dynamically based on program size + min_alloc ----
    mov  ax, LOAD_SEG
    add  ax, bp             ; AX = program end segment
    mov  dx, [ds:0x0A]      ; DX = min_alloc paragraphs from MZ header
    add  ax, dx             ; AX = program end segment + min_alloc
    mov  [cs:free_mem_ptr], ax

    ; ---- 3. Copy image to 0x1010:0000 ----
    push ds
    push es

    ; DS = 0x1010 + header paragraphs
    mov  ax, ds
    add  ax, [ds:0x08]
    mov  ds, ax
    
    ; ES = 0x1000 + 0x10
    mov  ax, es
    add  ax, 0x10
    mov  es, ax

.copy_loop:
    test bp, bp
    jz   .copy_done

    mov  cx, 512            ; 512 paragraphs = 8192 bytes = 4096 words
    cmp  bp, cx
    jae  .do_copy
    mov  cx, bp             ; Copy remaining paragraphs

.do_copy:
    sub  bp, cx             ; BP = paragraphs left after this copy
    
    ; Save paragraph count to update segment registers later
    push cx
    
    ; Convert paragraphs in CX to words for rep movsw: words = paragraphs * 8
    shl  cx, 1
    shl  cx, 1
    shl  cx, 1              ; CX = CX * 8

    xor  si, si
    xor  di, di
    rep  movsw

    pop  cx                 ; Restore paragraph count
    
    test bp, bp
    jz   .copy_done

    ; Increment segments by CX paragraphs
    mov  ax, ds
    add  ax, cx
    mov  ds, ax
    mov  ax, es
    add  ax, cx
    mov  es, ax
    jmp  .copy_loop

.copy_done:
    pop  es                 ; ES = 0x1000
    pop  ds                 ; DS = 0x1010

    ; ---- 4. Zero PSP area (256 bytes) at ES:0 (0x1000:0) ----
    push es
    pop  di                 ; DI = 0x1000
    push di
    xor  di, di             ; ES:DI = 0x1000:0
    xor  ax, ax
    mov  cx, 128            ; 128 words
    rep  stosw
    pop  di                 ; DI = 0x1000

    ; ---- 5. Build PSP fields at ES:0 ----
    mov  byte [es:0], 0xCD  ; INT 20h
    mov  byte [es:1], 0x20
    mov  word [es:2], 0x9FFF ; Link to top of conventional memory (640KB limit)
    mov  word [es:0x0A], 0
    mov  word [es:0x0C], 0
    mov  word [es:0x0E], 0
    mov  word [es:0x2C], 0  ; Environment segment (0 = none)

    ; ---- Install minimal INT 21h handler ----
    push es
    xor  ax, ax
    mov  es, ax             ; ES = 0x0000
    mov  word [es:0x0084], int21_handler
    mov  word [es:0x0086], cs   ; CS of stage2
    
    ; ---- Save and Install minimal INT 16h handler ----
    mov  ax, [es:0x0058]
    mov  [cs:old_int16_ip], ax
    mov  ax, [es:0x005a]
    mov  [cs:old_int16_cs], ax
    
    mov  word [es:0x0058], int16_handler
    mov  word [es:0x005a], cs

    ; ---- Install minimal INT 20h handler ----
    mov  word [es:0x0080], int20_handler
    mov  word [es:0x0082], cs
    pop  es                 ; Restore ES (0x1000)
    ; ---- 6. Set up registers & jump ----
    cli
    pop  di                 ; DI = initial_CS
    pop  bp                 ; BP = initial_IP
    pop  dx                 ; DX = initial_SP
    pop  bx                 ; BX = initial_SS

    mov  ax, es             ; AX = 0x1000
    add  ax, 0x10           ; AX = 0x1010
    
    add  di, ax             ; DI = absolute CS
    add  bx, ax             ; BX = absolute SS

    mov  ss, bx
    mov  sp, dx             ; SP = initial_SP

    mov  ax, es
    mov  ds, ax
    mov  es, ax

    sti

    ; DBG: about to jump to program ('J')
    push ax
    mov  al, 0x4A
    out  0xE9, al
    pop  ax

    push di                 ; CS  (absolute)
    push bp                 ; IP  (entry offset)

    xor  ax, ax
    xor  bx, bx
    xor  cx, cx
    xor  dx, dx
    xor  si, si
    xor  di, di
    xor  bp, bp

    retf                    ; jump!


int20_handler:
    cld
    jmp  int21_handler.exit

; =============================================================
; Minimal INT 16h (Keyboard API) handler with Debounce
; =============================================================
int16_handler:
    cmp  ah, 0x00
    je   .handle_read
    cmp  ah, 0x10
    je   .handle_read
    cmp  ah, 0x01
    je   .handle_check
    cmp  ah, 0x11
    je   .handle_check
    jmp  far [cs:old_int16_ip]

; ---- Blocking read (AH=00h/10h) ----
; Caller only reads AX on return, not flags. Don't touch FLAGS_caller.
.handle_read:
    push ax             ; [1] Save function code (AH=00h or 10h)
    push di             ; [2] Save DI (will hold tick)
    push ds             ; [3] Save DS (will be set to 0)

    pushf
    call far [cs:old_int16_ip]  ; BIOS returns key in AX

    ; Read BIOS tick into DI without polluting other regs
    push bx
    xor  bx, bx
    mov  ds, bx         ; DS = 0
    mov  di, [0x046C]   ; DI = BIOS tick
    pop  bx             ; BX unchanged
    pop  ds             ; [3] DS restored

    cmp  ah, [cs:last_key_scan]
    jne  .read_pass
    push di
    sub  di, [cs:last_key_tick]
    cmp  di, 1
    pop  di
    jb   .read_drop

.read_pass:
    mov  [cs:last_key_scan], ah
    mov  [cs:last_key_tick], di
    pop  di             ; [2] DI restored
    add  sp, 2          ; [1] Discard saved AX; keep BIOS AX in register
    iret                ; Flags = caller's original flags (IF untouched)

.read_drop:
    pop  di             ; [2] DI restored
    pop  ax             ; [1] Restore function code so BIOS call uses 00h/10h
    jmp  .handle_read   ; Duplicate consumed; wait for next key

; ---- Status check (AH=01h/11h) ----
; Caller checks ZF. Return BIOS ZF but PRESERVE caller's IF/DF/TF (bits 8-10).
.handle_check:
    push ax             ; [1] Save function code

    pushf
    call far [cs:old_int16_ip]  ; BIOS: ZF=0 if key, ZF=1 if none

    pushf               ; [2] Save BIOS flags (has ZF from keyboard status)

    jz   .check_no_key  ; ZF=1 = no key

    ; Key available — check tick for debounce
    push bx             ; [3] Save BX
    push di             ; [4] Save DI
    push ds             ; [5] Save DS
    xor  bx, bx
    mov  ds, bx
    mov  di, [0x046C]   ; DI = tick
    pop  ds             ; [5] Restore DS
    ; DI=tick, DS=restored, stack: [DI_orig, BX_orig, BIOS_flags, AX_orig, IP, CS, FLAGS]

    cmp  ah, [cs:last_key_scan]
    jne  .check_pass
    push di
    sub  di, [cs:last_key_tick]
    cmp  di, 1
    pop  di
    jb   .check_drop

.check_pass:
    pop  di             ; [4] DI restored
    pop  bx             ; [3] BX restored
    ; Stack: [BIOS_flags, AX_orig, IP, CS, FLAGS_caller]
    ; Merge: BIOS_flags but keep caller's IF/DF/TF (mask 0x0700)
    push bp
    mov  bp, sp
    push cx
    push bx
    ; [bp+2]=BIOS_flags  [bp+10]=FLAGS_caller (BP offsets stable despite push cx/bx)
    mov  cx, [bp+2]
    and  cx, 0xF8FF     ; Clear IF/DF/TF from BIOS flags
    mov  bx, [bp+10]
    and  bx, 0x0700     ; Keep IF/DF/TF from caller
    or   cx, bx
    mov  [bp+10], cx    ; Write combined flags (BIOS ZF + caller IF)
    pop  bx
    pop  cx
    pop  bp
    popf                ; Consume BIOS_flags from stack
    add  sp, 2          ; Discard AX_orig; AX = BIOS key
    iret

.check_no_key:
    ; Stack: [BIOS_flags, AX_orig, IP, CS, FLAGS_caller]
    push bp
    mov  bp, sp
    push cx
    push bx
    mov  cx, [bp+2]
    and  cx, 0xF8FF
    mov  bx, [bp+10]
    and  bx, 0x0700
    or   cx, bx
    mov  [bp+10], cx
    pop  bx
    pop  cx
    pop  bp
    popf
    add  sp, 2          ; Discard AX_orig; keep BIOS AX
    iret

.check_drop:
    pop  di             ; [4] DI restored
    pop  bx             ; [3] BX restored
    popf                ; [2] Consume BIOS_flags
    pop  ax             ; [1] Restore function code (01h or 11h)
    ; Consume duplicate key via blocking read
    push ax
    push bx
    push cx
    push dx
    push si
    push di
    push ds
    push es
    dec  ah             ; 01h→00h, 11h→10h
    pushf
    call far [cs:old_int16_ip]
    pop  es
    pop  ds
    pop  di
    pop  si
    pop  dx
    pop  cx
    pop  bx
    pop  ax             ; AX = AX_orig (01h or 11h)
    jmp  .handle_check

; =============================================================
; Minimal INT 21h (DOS API) handler
; =============================================================
int21_handler:
    pushf
    push ax
    mov  al, '['
    out  0xE9, al
    mov  al, ah
    call dbg_print_hex
    mov  al, ']'
    out  0xE9, al
    pop  ax
    cmp  ah, 0x00           ; Terminate program
    je   .exit
    cmp  ah, 0x4C           ; Exit
    je   .exit
    cmp  ah, 0x0E           ; Select Default Drive
    je   .select_default_drive
    cmp  ah, 0x19           ; Get Default Drive
    je   .get_default_drive
    cmp  ah, 0x1A           ; Set DTA
    je   .set_dta
    cmp  ah, 0x47           ; Get Current Directory
    je   .get_current_directory
    cmp  ah, 0x30           ; Get DOS version
    je   .get_ver
    cmp  ah, 0x09           ; Print string
    je   .print_str
    cmp  ah, 0x0B           ; Check input status
    je   .chk_input
    cmp  ah, 0x08           ; Read char without echo
    je   .read_char
    cmp  ah, 0x07           ; Read char without echo
    je   .read_char
    cmp  ah, 0x06           ; Direct console I/O
    je   .direct_io
    cmp  ah, 0x02           ; Character output
    je   .char_out
    cmp  ah, 0x2C           ; Get time
    je   .get_time
    cmp  ah, 0x62           ; Get PSP
    je   .get_psp
    cmp  ah, 0x51           ; Get PSP (same handler)
    je   .get_psp
    cmp  ah, 0x4A           ; Resize block
    je   .resize_mem
    cmp  ah, 0x48           ; Allocate memory
    je   .alloc_mem
    cmp  ah, 0x49           ; Free memory
    je   .free_mem
    cmp  ah, 0x35           ; Get vector
    je   .get_vector
    cmp  ah, 0x25           ; Set vector
    je   .set_vector
    cmp  ah, 0x01           ; Read char with echo
    je   .read_char_echo
    cmp  ah, 0x0C           ; Clear buffer and input
    je   .clear_buffer_and_input
    cmp  ah, 0x3C           ; Create File
    je   create_file_api
    cmp  ah, 0x3D           ; Open File
    je   open_file_api
    cmp  ah, 0x3E           ; Close File
    je   close_file_api
    cmp  ah, 0x3F           ; Read File
    je   read_file_api
    cmp  ah, 0x40           ; Write File
    je   write_file_api
    cmp  ah, 0x41           ; Delete File
    je   delete_file_api
    cmp  ah, 0x42           ; Lseek
    je   lseek_api
    cmp  ah, 0x43           ; Get/Set Attributes
    je   get_set_attributes
 
    ; Unhandled functions return Carry Set
    popf
    push bp
    mov  bp, sp
    or   word [bp+6], 0x0001 ; Set Carry Flag (bit 0) in caller's flags
    pop  bp
    
    cmp  ah, 0x4E           ; Find First
    je   .err_file_not_found
    
    mov  ax, 1              ; Error code 1 (invalid function)
    iret

.err_file_not_found:
    mov  ax, 2              ; Error code 2 (file not found)
    iret

.err_invalid_handle:
    mov  ax, 6              ; Error code 6 (invalid handle)
    iret

.write_file:
    popf
    cmp  bx, 1              ; stdout
    je   .write_stdout
    cmp  bx, 2              ; stderr
    je   .write_stdout
    
    ; Other handles are invalid
    push bp
    mov  bp, sp
    or   word [bp+6], 0x0001 ; Set Carry Flag (bit 0) in caller's flags
    pop  bp
    mov  ax, 6              ; Invalid handle
    iret

.write_stdout:
    push ds
    push si
    push cx
    push bx
    push ax
    
    mov  si, dx             ; DS:SI = buffer
    mov  bx, cx             ; BX = save count
.write_loop:
    jcxz .write_done
    lodsb
    push cx
    mov  ah, 0x0E
    xor  bh, bh
    int  10h
    pop  cx
    dec  cx
    jmp  .write_loop
.write_done:
    pop  ax
    pop  bx
    pop  cx
    pop  si
    pop  ds
    
    ; Return AX = BX (actual count written)
    mov  ax, bx
    jmp  .clear_cf_and_iret

.exit:
    cld
    sti
    push cs
    pop  ds
    
    ; Restore INT 16h vector to original BIOS handler to prevent crash on reboot
    push es
    xor  ax, ax
    mov  es, ax
    mov  ax, [cs:old_int16_ip]
    mov  [es:0x0058], ax
    mov  ax, [cs:old_int16_cs]
    mov  [es:0x005a], ax
    pop  es

    mov  si, exit_msg
.exit_print:
    lodsb
    test al, al
    jz   .exit_wait
    out  0xE9, al
    mov  ah, 0x0E
    xor  bh, bh
    int  10h
    jmp  .exit_print
.exit_wait:
    xor  ah, ah
    int  16h

    ; ---- Soft reboot: manually reload the boot sector ----
    ; js-dos (DOSBox) has no real BIOS: after `boot beautiful.img`,
    ; INT 19h / JMP FFFF:0000 hang the emulator instead of rebooting.
    ; INT 13h is fully emulated for the mounted floppy, so we re-read
    ; LBA 0 to 0000:7C00 ourselves and jump to it (warm boot).
    cli
    xor  ax, ax
    mov  ss, ax
    mov  sp, 0x7C00         ; fresh stack just below the boot sector
    sti

    xor  ax, ax
    mov  dl, [cs:cur_drive]
    int  13h                ; reset disk controller

    mov  cx, 3              ; retry up to 3 times
.exit_read_boot:
    push cx
    xor  ax, ax
    mov  es, ax
    mov  bx, 0x7C00         ; ES:BX = 0000:7C00
    mov  ax, 0x0201         ; AH=02h read, AL=1 sector
    mov  cx, 0x0001         ; cylinder 0, sector 1
    xor  dh, dh             ; head 0
    mov  dl, [cs:cur_drive]
    int  13h
    pop  cx
    jnc  .exit_boot_ok
    loop .exit_read_boot

    ; Fallback: BIOS warm reboot (real hardware / v86 with real BIOS)
    cli
    int  19h
    jmp  0xFFFF:0000

.exit_boot_ok:
    mov  dl, [cs:cur_drive] ; DL = boot drive, as the BIOS would pass it
    jmp  0x0000:0x7C00

.get_ver:
    popf
    mov  ax, 0x0005         ; DOS 5.0
    xor  bx, bx
    xor  cx, cx
    jmp  .clear_cf_and_iret

.print_str:
    push ds
    push si
    push ax
    mov  si, dx
.print_loop:
    lodsb
    cmp  al, '$'
    je   .print_done
    mov  ah, 0x0E
    xor  bh, bh
    int  10h
    jmp  .print_loop
.print_done:
    pop  ax
    pop  si
    pop  ds
    popf
    jmp  .clear_cf_and_iret

.chk_input:
    popf
    push ax
    mov  ah, 0x01
    int  16h
    jz   .chk_no_key
    pop  ax
    mov  al, 0xFF
    iret
.chk_no_key:
    pop  ax
    xor  al, al
    iret

.read_char:
    popf
    push bp
    mov  bp, sp
    push bx
    
    cmp  byte [cs:ext_key_scan], 0
    je   .read_no_cached
    
    mov  al, [cs:ext_key_scan]
    mov  byte [cs:ext_key_scan], 0
    jmp  .read_char_done
    
.read_no_cached:
    xor  ah, ah
    int  16h                 ; AL = character, AH = scan code
    test al, al
    jnz  .read_char_done
    
    mov  [cs:ext_key_scan], ah
    xor  al, al
    
.read_char_done:
    pop  bx
    pop  bp
    jmp  .clear_cf_and_iret

.read_char_echo:
    popf
    push bp
    mov  bp, sp
    push bx
    
    cmp  byte [cs:ext_key_scan], 0
    je   .read_echo_no_cached
    
    mov  al, [cs:ext_key_scan]
    mov  byte [cs:ext_key_scan], 0
    jmp  .read_char_echo_done
    
.read_echo_no_cached:
    xor  ah, ah
    int  16h                 ; AL = character, AH = scan code
    test al, al
    jnz  .read_echo_normal
    
    mov  [cs:ext_key_scan], ah
    xor  al, al
    jmp  .read_char_echo_done
    
.read_echo_normal:
    push ax
    mov  ah, 0x0E            ; TTY echo
    xor  bh, bh
    int  10h
    pop  ax
    
.read_char_echo_done:
    pop  bx
    pop  bp
    jmp  .clear_cf_and_iret

.clear_buffer_and_input:
    popf
    mov  ah, al              ; execute sub-function in AL
    jmp  int21_handler

.direct_io:
    cmp  dl, 0xFF
    je   .direct_in
    push ax
    push bx
    mov  al, dl
    mov  ah, 0x0E
    xor  bh, bh
    int  10h
    pop  bx
    pop  ax
    popf
    jmp  .clear_cf_and_iret

.direct_in:
    popf
    push bp
    mov  bp, sp
    push ax
    
    cmp  byte [cs:ext_key_scan], 0
    je   .direct_no_cached
    
    mov  al, [cs:ext_key_scan]
    mov  byte [cs:ext_key_scan], 0
    pop  bx
    mov  ah, bh
    and  word [bp+6], ~0x0041
    pop  bp
    iret

.direct_no_cached:
    mov  ah, 0x01
    int  16h
    jz   .direct_no_key
    
    xor  ah, ah
    int  16h
    test al, al
    jnz  .direct_normal_key
    
    mov  [cs:ext_key_scan], ah
    xor  al, al
    jmp  .direct_return_key

.direct_normal_key:
.direct_return_key:
    pop  bx
    mov  ah, bh
    and  word [bp+6], ~0x0041
    pop  bp
    iret

.direct_no_key:
    pop  bx
    xor  al, al
    mov  ah, bh
    or   word [bp+6], 0x0040
    and  word [bp+6], ~0x0001
    pop  bp
    iret

.char_out:
    push ax
    push bx
    mov  al, dl
    mov  ah, 0x0E
    xor  bh, bh
    int  10h
    pop  bx
    pop  ax
    popf
    jmp  .clear_cf_and_iret

.get_time:
    popf
    push ax
    push bx
    push si
    push di
    push bp
    push ds
    push es
    
    xor  ax, ax
    int  1Ah                ; CX:DX = ticks (from BIOS)
    
    mov  ax, dx             ; AX = ticks
    xor  dx, dx
    mov  bx, 18
    div  bx                 ; AX = total seconds, DX = ticks remainder (0-17)
    
    ; centiseconds = (remainder * 11) / 2
    push ax
    mov  ax, dx
    mov  bx, 11
    mul  bx
    shr  ax, 1
    mov  bp, ax             ; BP = centiseconds (0-93)
    pop  ax
    
    ; seconds & total minutes
    xor  dx, dx
    mov  bx, 60
    div  bx                 ; AX = total minutes, DX = seconds (0-59)
    push dx
    
    ; minutes & hours
    xor  dx, dx
    mov  bx, 60
    div  bx                 ; AX = total hours, DX = minutes (0-59)
    push dx
    
    ; hours (0-23)
    xor  dx, dx
    mov  bx, 24
    div  bx                 ; DX = hours (0-23)
    mov  ch, dl             ; CH = hours
    
    pop  ax                 ; AX = minutes
    mov  cl, al             ; CL = minutes
    
    pop  ax                 ; AX = seconds
    mov  dh, al             ; DH = seconds
    
    mov  ax, bp             ; AX = centiseconds
    mov  dl, al             ; DL = centiseconds
    
    pop  es
    pop  ds
    pop  bp
    pop  di
    pop  si
    pop  bx
    pop  ax
    jmp  .clear_cf_and_iret

.select_default_drive:
    popf
    mov  [cs:cur_drive], dl
    mov  al, 2              ; Return total number of logical drives (2)
    jmp  .clear_cf_and_iret

.get_default_drive:
    popf
    mov  al, [cs:cur_drive]
    jmp  .clear_cf_and_iret

.set_dta:
    popf
    jmp  .clear_cf_and_iret

.get_current_directory:
    popf
    push ds
    push es
    push si
    push di
    push cx
    push ax
    
    mov  ax, [cs:current_dir_cluster]
    test ax, ax
    jz   .cwd_root
    
    mov  cx, ax             ; CX = target cluster
    mov  word [cs:current_dir_cluster], 0
    call read_root_dir      ; ES = ROOT_DIR_SEG
    jc   .cwd_err
    
    mov  ax, ROOT_DIR_SEG
    mov  ds, ax             ; DS = ROOT_DIR_SEG
    xor  si, si             ; DS:SI points to root dir entries
    mov  dx, 224            ; 224 root dir entries
.cwd_scan_loop:
    cmp  byte [ds:si], 0
    je   .cwd_err
    cmp  byte [ds:si], 0xE5
    je   .cwd_next_entry
    
    mov  al, [ds:si+11]     ; attribute
    test al, 0x08           ; volume label?
    jnz  .cwd_next_entry
    test al, 0x10           ; subdirectory?
    jz   .cwd_next_entry
    
    mov  ax, [ds:si+26]     ; starting cluster
    cmp  ax, cx
    je   .cwd_found
    
.cwd_next_entry:
    add  si, 32
    dec  dx
    jnz  .cwd_scan_loop
    jmp  .cwd_err
    
.cwd_found:
    ; DS:SI points to the directory entry in ROOT_DIR_SEG.
    ; Destination is caller's DS:SI.
    ; Set ES = caller's DS (at sp+10), DI = caller's SI (at sp+6).
    mov  bp, sp
    mov  ax, [bp+10]        ; AX = caller's DS
    mov  es, ax
    mov  di, [bp+6]         ; DI = caller's SI
    
    ; Copy name (up to 8 characters, removing trailing spaces)
    mov  cx, 8
.cwd_copy:
    lodsb
    cmp  al, ' '
    je   .cwd_copy_end
    stosb
    loop .cwd_copy
.cwd_copy_end:
    ; Null terminate
    xor  al, al
    stosb
    
    pop  ax
    pop  cx
    pop  di
    pop  si
    pop  es
    pop  ds
    jmp  .clear_cf_and_iret

.cwd_root:
    ; Root directory is just empty string
    mov  bp, sp
    mov  ax, [bp+10]
    mov  es, ax
    mov  di, [bp+6]
    xor  al, al
    stosb
    
    pop  ax
    pop  cx
    pop  di
    pop  si
    pop  es
    pop  ds
    jmp  .clear_cf_and_iret

.cwd_err:
    pop  ax
    pop  cx
    pop  di
    pop  si
    pop  es
    pop  ds
    mov  ax, 15             ; Invalid drive
    jmp  .set_cf_and_iret

.get_psp:
    popf
    mov  bx, PSP_SEG
    jmp  .clear_cf_and_iret

.resize_mem:
    popf
    ; ES = block segment to resize, BX = new size in paragraphs
    mov  ax, es
    add  ax, bx             ; AX = new free memory segment pointer
    mov  [cs:free_mem_ptr], ax
    jmp  .clear_cf_and_iret

.alloc_mem:
    popf
    push cx
    mov  ax, [cs:free_mem_ptr]
    mov  cx, 0x9FFF
    sub  cx, ax             ; CX = available paragraphs
    cmp  bx, cx
    ja   .alloc_failed
    
    ; Success: allocate BX paragraphs
    add  bx, ax             ; BX = new free_mem_ptr
    mov  [cs:free_mem_ptr], bx
    pop  cx
    jmp  .clear_cf_and_iret

.alloc_failed:
    mov  bx, cx             ; BX = max available paragraphs
    pop  cx
    
    push bp
    mov  bp, sp
    or   word [bp+6], 0x0001 ; Set Carry Flag (bit 0) in caller's flags
    pop  bp
    mov  ax, 8              ; Error 8: Insufficient memory
    iret

.free_mem:
    popf
    jmp  .clear_cf_and_iret

.get_vector:
    push ds
    push si
    xor  si, si
    mov  ds, si
    mov  si, ax
    and  si, 0x00FF
    shl  si, 1
    shl  si, 1
    mov  es, [ds:si+2]      ; ES = segment
    mov  bx, [ds:si]        ; BX = offset
    pop  si                 ; Pop in correct order
    pop  ds
    popf
    jmp  .clear_cf_and_iret

.set_vector:
    push es
    push si
    push ds
    xor  si, si
    mov  es, si
    mov  si, ax
    and  si, 0x00FF
    shl  si, 1
    shl  si, 1
    pop  ds
    mov  [es:si], dx
    mov  [es:si+2], ds
    pop  si
    pop  es
    popf
    jmp  .clear_cf_and_iret

.clear_cf_and_iret:
    push ax
    mov  ax, [cs:active_dir_cluster]
    mov  [cs:current_dir_cluster], ax
    pop  ax
    push bp
    mov  bp, sp
    and  word [bp+6], ~0x0001 ; Clear Carry Flag (bit 0)
    pop  bp
    iret

.set_cf_and_iret:
    push ax
    mov  ax, [cs:active_dir_cluster]
    mov  [cs:current_dir_cluster], ax
    pop  ax
    push bp
    mov  bp, sp
    or   word [bp+6], 0x0001  ; Set Carry Flag (bit 0)
    pop  bp
    iret

free_mem_ptr dw 0x1010  ; default: LOAD_SEG; overwritten dynamically at load time

; =============================================================
; FILE OPERATIONS SUBSYSTEM FOR INT 21H
; =============================================================

; Input: DS:DX points to ASCIIZ path
; Output: cs:temp_sfn has 11-byte padded SFN
;         current_dir_cluster is updated to the parent directory containing the file.
parse_path_to_sfn:
    pusha
    push ds
    push es
    
    mov  ax, [cs:active_dir_cluster]
    mov  [cs:temp_search_cluster], ax
    
    mov  si, dx             ; SI = start of component
    
    ; Check drive prefix (e.g. A:)
    cmp  byte [si], 0
    jz   .last_comp
    cmp  byte [si+1], ':'
    jne  .check_root
    add  si, 2
    
.check_root:
    ; Check if path starts with '\' or '/'
    cmp  byte [si], '\'
    je   .set_root
    cmp  byte [si], '/'
    jne  .parse_component
.set_root:
    mov  word [cs:temp_search_cluster], 0
    inc  si
    
.parse_component:
    mov  di, si
.find_sep:
    mov  al, [di]
    test al, al
    jz   .last_comp
    cmp  al, '\'
    je   .found_sep
    cmp  al, '/'
    je   .found_sep
    inc  di
    jmp  .find_sep
    
.found_sep:
    cmp  di, si
    je   .skip_sep
    
    mov  ax, di
    sub  ax, si             ; AX = length of component
    
    ; Check if component is "."
    cmp  ax, 1
    jne  .check_dotdot
    cmp  byte [si], '.'
    je   .skip_sep
    
.check_dotdot:
    cmp  ax, 2
    jne  .not_dotdot
    cmp  word [si], 0x2E2E   ; ".."
    je   .handle_dotdot
    
.not_dotdot:
    push di
    push cx
    call format_component_to_sfn
    pop  cx
    pop  di
    
    push es
    push di
    push si
    push dx
    
    mov  ax, [cs:temp_search_cluster]
    mov  [cs:current_dir_cluster], ax
    call find_file_in_root
    jc   .search_failed
    
    mov  al, [es:di+11]
    test al, 0x10           ; subdirectory?
    jz   .search_failed
    
    mov  ax, [es:di+26]
    mov  [cs:temp_search_cluster], ax
    
    pop  dx
    pop  si
    pop  di
    pop  es
    
.skip_sep:
    lea  si, [di+1]
    jmp  .parse_component
    
.handle_dotdot:
    push es
    push di
    push si
    push dx
    
    mov  ax, [cs:temp_search_cluster]
    test ax, ax
    jz   .search_failed      ; root directory has no parent ".."
    
    sub  ax, 2
    add  ax, DATA_LBA
    mov  bx, ROOT_DIR_SEG
    mov  es, bx
    xor  bx, bx
    call read_one_sector
    jc   .search_failed
    
    cmp  word [es:32], 0x2E2E ; ".."
    jne  .search_failed
    
    mov  ax, [es:32+26]
    mov  [cs:temp_search_cluster], ax
    
    pop  dx
    pop  si
    pop  di
    pop  es
    jmp  .skip_sep

.search_failed:
    pop  dx
    pop  si
    pop  di
    pop  es
    pop  ds
    popa
    stc
    ret

.last_comp:
    ; Format final filename to temp_sfn
    push cs
    pop  es
    mov  di, temp_sfn
    mov  al, ' '
    mov  cx, 11
    rep  stosb
    
    mov  di, temp_sfn
    xor  dx, dx             ; count of name chars
.name_loop:
    lodsb
    test al, al
    jz   .parse_done
    cmp  al, '.'
    je   .ext_part
    cmp  dx, 8
    jae  .name_loop
    
    cmp  al, 'a'
    jb   .ok1
    cmp  al, 'z'
    ja   .ok1
    sub  al, 0x20
.ok1:
    stosb
    inc  dx
    jmp  .name_loop
    
.ext_part:
    mov  di, temp_sfn + 8
    xor  dx, dx
.ext_loop:
    lodsb
    test al, al
    jz   .parse_done
    cmp  dx, 3
    jae  .ext_loop
    
    cmp  al, 'a'
    jb   .ok2
    cmp  al, 'z'
    ja   .ok2
    sub  al, 0x20
.ok2:
    stosb
    inc  dx
    jmp  .ext_loop
    
.parse_done:
    ; Update current_dir_cluster to the resolved directory cluster
    mov  ax, [cs:temp_search_cluster]
    mov  [cs:current_dir_cluster], ax
    
    pop  es
    pop  ds
    popa
    clc
    ret

; Helper: format component at DS:SI of length AX to SFN in cs:temp_sfn
format_component_to_sfn:
    pusha
    push ds
    push es
    
    push cs
    pop  es
    mov  di, temp_sfn
    mov  al, ' '
    mov  cx, 11
    rep  stosb
    
    mov  cx, ax                 ; CX = length
    mov  di, temp_sfn
    xor  dx, dx                 ; dx = count of name chars
.comp_loop:
    jcxz .comp_done
    lodsb
    dec  cx
    cmp  al, '.'
    je   .comp_ext
    cmp  dx, 8
    jae  .comp_loop
    
    cmp  al, 'a'
    jb   .comp_ok1
    cmp  al, 'z'
    ja   .comp_ok1
    sub  al, 0x20
.comp_ok1:
    stosb
    inc  dx
    jmp  .comp_loop
    
.comp_ext:
    mov  di, temp_sfn + 8
    xor  dx, dx
.comp_ext_loop:
    jcxz .comp_done
    lodsb
    dec  cx
    cmp  dx, 3
    jae  .comp_ext_loop
    
    cmp  al, 'a'
    jb   .comp_ok2
    cmp  al, 'z'
    ja   .comp_ok2
    sub  al, 0x20
.comp_ok2:
    stosb
    inc  dx
    jmp  .comp_ext_loop
    
.comp_done:
    pop  es
    pop  ds
    popa
    ret

read_root_dir:
    pusha
    
    ; Zero out ROOT_DIR_SEG buffer (7168 bytes) first
    push es
    push di
    push ax
    push cx
    mov  ax, ROOT_DIR_SEG
    mov  es, ax
    xor  di, di
    xor  ax, ax
    mov  cx, 3584
    rep  stosw
    pop  cx
    pop  ax
    pop  di
    pop  es

    mov  ax, [cs:current_dir_cluster]
    test ax, ax
    jnz  .read_sub

    ; Read root dir
    mov  ax, ROOT_DIR_SEG
    mov  es, ax
    xor  bx, bx
    mov  ax, ROOT_LBA
    mov  cx, ROOT_SECTS
.loop:
    push ax
    push cx
    call read_one_sector
    pop  cx
    pop  ax
    jc   .err
    add  bx, 512
    inc  ax
    loop .loop
    clc
    jmp  .done

.read_sub:
    ; Read subdirectory cluster chain into ROOT_DIR_SEG:0000
    mov  bx, ROOT_DIR_SEG
    mov  es, bx
    xor  bx, bx
    call load_fat12_chain
    jmp  .done

.err:
    stc
.done:
    popa
    ret

write_root_dir:
    pusha
    
    mov  ax, [cs:current_dir_cluster]
    test ax, ax
    jnz  .write_sub

    ; Write root dir
    mov  ax, ROOT_DIR_SEG
    mov  es, ax
    xor  bx, bx
    mov  ax, ROOT_LBA
    mov  cx, ROOT_SECTS
.loop:
    push ax
    push cx
    call write_one_sector
    pop  cx
    pop  ax
    jc   .err
    add  bx, 512
    inc  ax
    loop .loop
    clc
    jmp  .done

.write_sub:
    push es
    push ds
    
    ; Load FAT into FAT_SEG:0
    mov  ax, FAT_SEG
    mov  es, ax
    xor  bx, bx
    mov  ax, FAT_LBA
    mov  cx, FAT_SECTS
.fat_rd_loop:
    push ax
    push cx
    call read_one_sector
    pop  cx
    pop  ax
    jc   .write_err_pop
    add  bx, 512
    inc  ax
    loop .fat_rd_loop
    
    ; Set DS = FAT_SEG
    mov  ax, FAT_SEG
    mov  ds, ax
    
    ; Traverse and write sectors
    mov  si, [cs:current_dir_cluster]
    mov  ax, ROOT_DIR_SEG
    mov  es, ax
    xor  bp, bp             ; byte offset in ROOT_DIR_SEG
.walk:
    push si
    mov  ax, si
    sub  ax, 2
    add  ax, DATA_LBA
    
    mov  bx, bp
    ; write_one_sector restores DS from caller's stack frame (DS at entry).
    ; DS is currently FAT_SEG, but the source is ROOT_DIR_SEG:bp.
    ; We must set DS = ROOT_DIR_SEG so the copy inside write_one_sector is correct.
    push ds                 ; save FAT_SEG
    push cs
    pop  ds                 ; DS = CS  (so write_one_sector sees ROOT_DIR_SEG:bx via ES)
    call write_one_sector
    pop  ds                 ; restore DS = FAT_SEG for FAT lookup below
    pop  si
    jc   .write_err_pop
    
    add  bp, 512
    
    ; FAT12 next-cluster lookup (DS = FAT_SEG)
    mov  ax, si
    mov  di, ax
    shr  di, 1
    add  di, ax
    mov  ax, [ds:di]
    test si, 1
    jz   .even
    mov  cl, 4
    shr  ax, cl
    jmp  .chk
.even:
    and  ax, 0x0FFF
.chk:
    cmp  ax, 0x0FF8
    jae  .write_ok
    mov  si, ax
    jmp  .walk

.write_err_pop:
    pop  ds
    pop  es
.err:
    stc
    jmp  .done
    
.write_ok:
    pop  ds
    pop  es
    clc
.done:
    popa
    ret

find_file_in_root:
    pusha
    call read_root_dir
    jc   .err
    
    mov  ax, ROOT_DIR_SEG
    mov  es, ax
    xor  di, di
    mov  cx, 224
.loop:
    cmp  byte [es:di], 0
    je   .not_found
    cmp  byte [es:di], 0xE5
    je   .next
    
    push cx
    push di
    push ds
    push cs
    pop  ds
    mov  si, temp_sfn
    mov  cx, 11
    repe cmpsb
    pop  ds
    pop  di
    pop  cx
    je   .found
    
.next:
    add  di, 32
    loop .loop
    
.not_found:
.err:
    popa
    stc
    ret
    
.found:
    mov  bp, sp
    mov  [bp], di
    popa
    clc
    ret

read_fat:
    cmp  byte [cs:fat_loaded], 1
    je   .fast_done
    pusha
    mov  ax, FAT_SEG
    mov  es, ax
    xor  bx, bx
    mov  ax, FAT_LBA
    mov  cx, FAT_SECTS
.loop:
    push ax
    push cx
    call read_one_sector
    pop  cx
    pop  ax
    jc   .err
    add  bx, 512
    inc  ax
    loop .loop
    mov  byte [cs:fat_loaded], 1
    clc
    jmp  .done
.err:
    stc
.done:
    popa
.fast_done:
    ret

write_fat:
    pusha
    mov  ax, FAT_SEG
    mov  es, ax
    xor  bx, bx
    mov  ax, FAT_LBA
    mov  cx, FAT_SECTS
.loop:
    push ax
    push cx
    call write_one_sector
    pop  cx
    pop  ax
    jc   .err
    add  bx, 512
    inc  ax
    loop .loop
    clc
    jmp  .done
.err:
    stc
.done:
    popa
    ret

get_fat_entry:
    push ds
    push di
    push cx
    
    mov  cx, ax
    
    push ax
    mov  ax, FAT_SEG
    mov  ds, ax
    pop  ax
    
    mov  di, cx
    shr  di, 1
    add  di, cx
    mov  ax, [ds:di]
    test cx, 1
    jz   .even
    mov  cl, 4
    shr  ax, cl
    jmp  .done
.even:
    and  ax, 0x0FFF
.done:
    pop  cx
    pop  di
    pop  ds
    ret

set_fat_entry:
    push ds
    push di
    push cx
    push bx
    
    mov  cx, ax
    
    push ax
    mov  ax, FAT_SEG
    mov  ds, ax
    pop  ax
    
    mov  di, cx
    shr  di, 1
    add  di, cx
    
    mov  bx, [ds:di]
    test cx, 1
    jz   .even
    and  bx, 0x000F
    mov  cl, 4
    shl  dx, cl
    or   bx, dx
    jmp  .save
.even:
    and  bx, 0xF000
    and  dx, 0x0FFF
    or   bx, dx
.save:
    mov  [ds:di], bx
    
    pop  bx
    pop  cx
    pop  di
    pop  ds
    ret

find_free_cluster:
    push ds
    push di
    push cx
    
    call read_fat
    jc   .err
    
    mov  cx, 2
.loop:
    mov  ax, cx
    call get_fat_entry
    test ax, ax
    jz   .found
    inc  cx
    cmp  cx, 2840
    jb   .loop
    
.err:
    pop  cx
    pop  di
    pop  ds
    stc
    ret
    
.found:
    mov  ax, cx
    pop  cx
    pop  di
    pop  ds
    clc
    ret

free_cluster_chain:
    pusha
    test ax, ax
    jz   .done
    
    mov  si, ax
    call read_fat
    jc   .done
    
.loop:
    cmp  si, 2
    jb   .done
    cmp  si, 0x0FF0
    jae  .done
    
    mov  ax, si
    call get_fat_entry
    push ax
    
    mov  ax, si
    xor  dx, dx
    call set_fat_entry
    
    pop  si
    jmp  .loop
    
.done:
    call write_fat
    popa
    ret

allocate_and_append_cluster:
    push dx
    push cx
    push bx
    push si
    
    call find_free_cluster
    jc   .err
    mov  bx, ax
    
    mov  ax, bx
    mov  dx, 0x0FFF
    call set_fat_entry
    
    pop  si
    push si
    
    mov  cx, [cs:open_files + si + 12]
    test cx, cx
    jz   .set_start
    
    call read_fat
    jc   .err
    mov  ax, cx
.trace:
    mov  cx, ax
    call get_fat_entry
    cmp  ax, 2
    jb   .append
    cmp  ax, 0x0FF0
    jae  .append
    jmp  .trace
    
.append:
    mov  ax, cx
    mov  dx, bx
    call set_fat_entry
    jmp  .done
    
.set_start:
    mov  [cs:open_files + si + 12], bx
    
.done:
    call write_fat
    mov  ax, bx
    pop  si
    pop  bx
    pop  cx
    pop  dx
    clc
    ret
    
.err:
    pop  si
    pop  bx
    pop  cx
    pop  dx
    stc
    ret

find_target_cluster:
    push dx
    push cx
    push si
    
    mov  dx, ax             ; DX = cluster_index
    mov  ax, [cs:open_files + si + 12]
    
    test ax, ax
    jz   .err
    
    call read_fat
    jc   .err
    
    xor  cx, cx
.loop:
    cmp  cx, dx
    je   .found
    
    call get_fat_entry
    cmp  ax, 2
    jb   .err
    cmp  ax, 0x0FF0
    jae  .err
    
    inc  cx
    jmp  .loop
    
.found:
    pop  si
    pop  cx
    pop  dx
    clc
    ret
    
.err:
    pop  si
    pop  cx
    pop  dx
    stc
    ret

flush_dirty_sector:
    pusha
    cmp  word [cs:loaded_sector_lba], 0xFFFF
    je   .done
    cmp  byte [cs:sector_is_dirty], 1
    jne  .done
    
    mov  ax, [cs:loaded_sector_lba]
    mov  bx, ROOT_DIR_SEG
    mov  es, bx
    xor  bx, bx
    call write_one_sector
    
    mov  byte [cs:sector_is_dirty], 0
.done:
    popa
    ret

update_root_dir_entry:
    pusha
    
    push ds
    push es
    push cs
    pop  ds
    push cs
    pop  es
    mov  si, open_files
    add  si, bx
    add  si, 1
    mov  di, temp_sfn
    mov  cx, 11
    rep  movsb
    pop  es
    pop  ds
    
    call find_file_in_root
    jc   .done
    
    mov  ax, [cs:open_files + bx + 12]
    mov  [es:di+26], ax
    mov  ax, [cs:open_files + bx + 14]
    mov  [es:di+28], ax
    mov  word [es:di+30], 0
    
    call write_root_dir
    
.done:
    popa
    ret

; =============================================================
; INT 21H API IMPLEMENTATIONS
; =============================================================

open_file_api:
    popf
    push ds
    push es
    push si
    push di
    push cx
    push dx
    
    call parse_path_to_sfn
    jc   .open_not_found_pop
    push ax
    push si
    push cx
    mov  si, temp_sfn
    mov  cx, 11
.print_sfn_loop:
    mov  al, [cs:si]
    call dbg_char
    inc  si
    loop .print_sfn_loop
    pop  cx
    pop  si
    pop  ax
    call find_file_in_root
    jc   .open_not_found_pop
    
    push cs
    pop  ds
    xor  si, si
.find_slot:
    cmp  byte [open_files + si], 0
    jz   .slot_ok
    add  si, 18
    cmp  si, 4*18
    jb   .find_slot
    
    pop  dx
    pop  cx
    pop  di
    pop  si
    pop  es
    pop  ds
    mov  ax, 4
    jmp  int21_handler.set_cf_and_iret
    
.slot_ok:
    mov  byte [open_files + si], 1
    
    push es
    push ds
    push si
    
    mov  ax, ROOT_DIR_SEG
    mov  ds, ax
    mov  ax, cs
    mov  es, ax
    mov  si, di
    
    pop  di
    push di
    
    add  di, open_files
    inc  di
    mov  cx, 11
    rep  movsb
    
    mov  ax, [ds:si+15]
    mov  dx, [ds:si+17]
    
    pop  di
    
    mov  [es:open_files + di + 12], ax
    mov  [es:open_files + di + 14], dx
    mov  word [es:open_files + di + 16], 0
    
    pop  ds
    pop  es
    
    mov  ax, di
    mov  cl, 18
    div  cl
    xor  ah, ah
    add  ax, 5
    
    pop  dx
    pop  cx
    pop  di
    pop  si
    pop  es
    pop  ds
    
    push ax
    mov  al, 'O'
    call dbg_char
    pop  ax
    push ax
    call dbg_print_hex
    pop  ax
    jmp  int21_handler.clear_cf_and_iret
    
.open_not_found_pop:
    pop  dx
    pop  cx
    pop  di
    pop  si
    pop  es
    pop  ds
    
    push ax
    mov  al, 'o'
    call dbg_char
    pop  ax
    mov  ax, 2
    jmp  int21_handler.set_cf_and_iret

create_file_api:
    popf
    push ds
    push es
    push si
    push di
    push cx
    push dx
    
    call parse_path_to_sfn
    jc   .create_err_pop
    
    call find_file_in_root
    jc   .create_new
    
    mov  ax, [es:di+26]
    test ax, ax
    jz   .truncated
    
    push es
    push di
    call free_cluster_chain
    pop  di
    pop  es
    
.truncated:
    mov  word [es:di+26], 0
    mov  word [es:di+28], 0
    mov  word [es:di+30], 0
    call write_root_dir
    jmp  .open_created_file
    
.create_new:
    call read_root_dir
    jc   .create_err_pop
    
    mov  ax, ROOT_DIR_SEG
    mov  es, ax
    xor  di, di
    mov  cx, 224
.find_free_ent:
    mov  al, [es:di]
    test al, al
    jz   .found_free
    cmp  al, 0xE5
    je   .found_free
    add  di, 32
    loop .find_free_ent
    
.create_err_pop:
    pop  dx
    pop  cx
    pop  di
    pop  si
    pop  es
    pop  ds
    mov  ax, 4
    jmp  int21_handler.set_cf_and_iret
    
.found_free:
    push ds
    push es
    push di
    push cs
    pop  ds
    mov  si, temp_sfn
    mov  cx, 11
    rep  movsb
    pop  di
    pop  es
    pop  ds
    
    push di
    add  di, 11
    xor  al, al
    mov  cx, 21
    rep  stosb
    pop  di
    
    call write_root_dir
    
.open_created_file:
    call find_file_in_root
    jc   .create_err_pop
    
    push cs
    pop  ds
    xor  si, si
.find_slot2:
    cmp  byte [open_files + si], 0
    jz   .slot_ok2
    add  si, 18
    cmp  si, 4*18
    jb   .find_slot2
    jmp  .create_err_pop
    
.slot_ok2:
    mov  byte [open_files + si], 1
    
    push es
    push ds
    push si
    mov  ax, ROOT_DIR_SEG
    mov  ds, ax
    mov  ax, cs
    mov  es, ax
    mov  si, di
    pop  di
    push di
    add  di, open_files
    inc  di
    mov  cx, 11
    rep  movsb
    pop  si
    pop  ds
    pop  es
    
    mov  word [cs:open_files + si + 12], 0
    mov  word [cs:open_files + si + 14], 0
    mov  word [cs:open_files + si + 16], 0
    
    mov  ax, si
    mov  cl, 18
    div  cl
    xor  ah, ah
    add  ax, 5
    
    pop  dx
    pop  cx
    pop  di
    pop  si
    pop  es
    pop  ds
    push ax
    mov  al, 'C'
    call dbg_char
    pop  ax
    push ax
    call dbg_print_hex
    pop  ax
    jmp  int21_handler.clear_cf_and_iret

close_file_api:
    popf
    cmp  bx, 5
    jb   .err_invalid_handle_pop
    cmp  bx, 8
    ja   .err_invalid_handle_pop
    
    push bx
    push cx
    push ax
    
    sub  bx, 5
    mov  ax, bx
    mov  cl, 18
    mul  cl
    mov  bx, ax
    
    cmp  byte [cs:open_files + bx], 1
    jne  .err_invalid_handle_pop2
    
    mov  byte [cs:open_files + bx], 0
    
    pop  ax
    pop  cx
    pop  bx
    jmp  int21_handler.clear_cf_and_iret
    
.err_invalid_handle_pop2:
    pop  ax
    pop  cx
    pop  bx
.err_invalid_handle_pop:
    mov  ax, 6
    jmp  int21_handler.set_cf_and_iret

read_file_api:
    popf

    cmp  bx, 5
    jb   .err_invalid
    cmp  bx, 8
    ja   .err_invalid
    
    push ds
    push es
    push si
    push di
    push cx
    push dx
    push bx
    push bp
    
    ; Save transfer buffer pointers immediately before registers are modified
    mov  [cs:read_dst_ptr], dx
    mov  [cs:read_dst_seg], ds

    sub  bx, 5
    mov  ax, bx
    mov  dl, 18
    mul  dl
    mov  si, ax
    
    cmp  byte [cs:open_files + si], 1
    jne  .read_err_invalid
    
    mov  word [cs:loaded_sector_lba], 0xFFFF
    xor  bp, bp
    
.read_loop:
    cmp  bp, cx
    jae  .read_done
    
    mov  ax, [cs:open_files + si + 16]
    cmp  ax, [cs:open_files + si + 14]
    jae  .read_done
    
    push cx
    mov  cx, 512
    xor  dx, dx
    div  cx
    pop  cx
    
    push dx
    call find_target_cluster
    pop  dx
    jc   .read_done
    
    add  ax, 31
    cmp  ax, [cs:loaded_sector_lba]
    je   .copy_byte
    
    mov  [cs:loaded_sector_lba], ax
    push es
    push bx
    mov  bx, ROOT_DIR_SEG
    mov  es, bx
    xor  bx, bx
    call read_one_sector
    pop  bx
    pop  es
    jc   .read_done
    
.copy_byte:
    push ds
    push es
    push si
    push di
    push bx
    mov  ax, ROOT_DIR_SEG
    mov  ds, ax
    mov  si, dx
    lodsb
    mov  bx, [cs:read_dst_seg]
    mov  es, bx
    mov  di, [cs:read_dst_ptr]
    stosb
    mov  [cs:read_dst_ptr], di
    pop  bx
    pop  di
    pop  si
    pop  es
    pop  ds
    
    inc  word [cs:open_files + si + 16]
    inc  bp
    jmp  .read_loop
    
.read_done:
    mov  ax, bp
    pop  bp
    pop  bx
    pop  dx
    pop  cx
    pop  di
    pop  si
    pop  es
    pop  ds
    
    jmp  int21_handler.clear_cf_and_iret
    
.read_err_invalid:
    pop  bp
    pop  bx
    pop  dx
    pop  cx
    pop  di
    pop  si
    pop  es
    pop  ds
    push ax
    mov  al, 'r'
    call dbg_char
    pop  ax
    mov  ax, 6
    jmp  int21_handler.set_cf_and_iret
    
.err_invalid:
    mov  ax, 6
    jmp  int21_handler.set_cf_and_iret

write_file_api:
    popf
    cmp  bx, 1
    je   int21_handler.write_stdout
    cmp  bx, 2
    je   int21_handler.write_stdout
    
    cmp  bx, 5
    jb   .err_invalid
    cmp  bx, 8
    ja   .err_invalid
    
    push ds
    push es
    push si
    push di
    push cx
    push dx
    push bx
    push bp
    
    ; Save transfer buffer pointers immediately before registers are modified
    mov  [cs:write_src_ptr], dx
    mov  [cs:write_src_seg], ds

    sub  bx, 5
    mov  ax, bx
    mov  dl, 18
    mul  dl
    mov  bx, ax
    
    cmp  byte [cs:open_files + bx], 1
    jne  .write_err_invalid
    
    mov  word [cs:loaded_sector_lba], 0xFFFF
    mov  byte [cs:sector_is_dirty], 0
    xor  bp, bp
    
.write_loop:
    cmp  bp, cx
    jae  .write_done
    
    mov  ax, [cs:open_files + bx + 16]
    push cx
    mov  cx, 512
    xor  dx, dx
    div  cx
    pop  cx
    
    push dx
    push bx
    mov  si, bx
    call find_target_cluster
    pop  bx
    pop  dx
    jnc  .have_cluster
    
    push dx
    push bx
    mov  si, bx
    call allocate_and_append_cluster
    pop  bx
    pop  dx
    jc   .write_done
    
.have_cluster:
    add  ax, 31
    cmp  ax, [cs:loaded_sector_lba]
    je   .write_byte
    
    call flush_dirty_sector
    
    mov  [cs:loaded_sector_lba], ax
    mov  byte [cs:sector_is_dirty], 0
    
    push es
    push bx
    mov  bx, ROOT_DIR_SEG
    mov  es, bx
    xor  bx, bx
    call read_one_sector
    pop  bx
    pop  es
    
.write_byte:
    push es
    push di
    push ax
    push si
    push ds
    mov  ax, ROOT_DIR_SEG
    mov  es, ax
    mov  di, dx
    mov  ax, [cs:write_src_seg]
    mov  ds, ax
    mov  si, [cs:write_src_ptr]
    lodsb
    mov  [cs:write_src_ptr], si
    stosb
    pop  ds
    pop  si
    pop  ax
    pop  di
    pop  es
    
    mov  byte [cs:sector_is_dirty], 1
    
    inc  word [cs:open_files + bx + 16]
    mov  ax, [cs:open_files + bx + 16]
    cmp  ax, [cs:open_files + bx + 14]
    jbe  .no_grow
    mov  [cs:open_files + bx + 14], ax
.no_grow:
    inc  bp
    jmp  .write_loop
    
.write_done:
    call flush_dirty_sector
    
    push ds
    push es
    call update_root_dir_entry
    pop  es
    pop  ds
    
    mov  ax, bp
    pop  bp
    pop  bx
    pop  dx
    pop  cx
    pop  di
    pop  si
    pop  es
    pop  ds
    jmp  int21_handler.clear_cf_and_iret
    
.write_err_invalid:
    pop  bp
    pop  bx
    pop  dx
    pop  cx
    pop  di
    pop  si
    pop  es
    pop  ds
    mov  ax, 6
    jmp  int21_handler.set_cf_and_iret
    
.err_invalid:
    mov  ax, 6
    jmp  int21_handler.set_cf_and_iret

delete_file_api:
    popf
    push ds
    push es
    push si
    push di
    push cx
    push dx
    
    call parse_path_to_sfn
    jc   .del_not_found_pop
    call find_file_in_root
    jc   .del_not_found_pop
    
    mov  ax, [es:di+26]
    test ax, ax
    jz   .del_entry
    
    push es
    push di
    call free_cluster_chain
    pop  di
    pop  es
    
.del_entry:
    mov  byte [es:di], 0xE5
    call write_root_dir
    
    pop  dx
    pop  cx
    pop  di
    pop  si
    pop  es
    pop  ds
    jmp  int21_handler.clear_cf_and_iret
    
.del_not_found_pop:
    pop  dx
    pop  cx
    pop  di
    pop  si
    pop  es
    pop  ds
    mov  ax, 2
    jmp  int21_handler.set_cf_and_iret

lseek_api:
    popf
    cmp  bx, 5
    jb   .lseek_err_direct
    cmp  bx, 8
    ja   .lseek_err_direct
    
    push ds
    push si
    push cx
    push bx
    
    push ax
    sub  bx, 5
    mov  cl, 18
    mov  ax, bx
    mul  cl
    mov  si, ax
    pop  ax
    
    cmp  byte [cs:open_files + si], 1
    jne  .lseek_err_pop
    
    cmp  al, 0
    je   .seek_start
    cmp  al, 1
    je   .seek_current
    cmp  al, 2
    je   .seek_end
    
.lseek_err_pop:
    pop  bx
    pop  cx
    pop  si
    pop  ds
.lseek_err_direct:
    mov  ax, 6
    jmp  int21_handler.set_cf_and_iret
    
.seek_start:
    mov  [cs:open_files + si + 16], dx
    jmp  .seek_done
    
.seek_current:
    add  [cs:open_files + si + 16], dx
    jmp  .seek_done
    
.seek_end:
    mov  ax, [cs:open_files + si + 14]
    add  ax, dx
    mov  [cs:open_files + si + 16], ax
    
.seek_done:
    mov  ax, [cs:open_files + si + 16]
    xor  dx, dx
    
    pop  bx
    pop  cx
    pop  si
    pop  ds
    jmp  int21_handler.clear_cf_and_iret

get_set_attributes:
    popf
    cmp  al, 0
    jne  int21_handler.clear_cf_and_iret
    
    push ds
    push es
    push si
    push di
    push cx
    push dx
    
    call parse_path_to_sfn
    jc   .attr_not_found_pop
    call find_file_in_root
    jc   .attr_not_found_pop
    
    mov  cl, [es:di+11]
    xor  ch, ch
    
    push bp
    mov  bp, sp
    mov  [bp+4], cx
    pop  bp
    
    pop  dx
    pop  cx
    pop  di
    pop  si
    pop  es
    pop  ds
    jmp  int21_handler.clear_cf_and_iret
    
.attr_not_found_pop:
    pop  dx
    pop  cx
    pop  di
    pop  si
    pop  es
    pop  ds
    mov  ax, 2
    jmp  int21_handler.set_cf_and_iret

dbg_print_hex:
    push ax
    push cx
    mov  cl, 4
    shr  al, cl
    call dbg_print_nibble
    pop  cx
    pop  ax
    push ax
    and  al, 0x0F
    call dbg_print_nibble
    pop  ax
    ret

dbg_print_nibble:
    cmp  al, 10
    jb   .digit
    add  al, 'A' - 10
    jmp  .out
.digit:
    add  al, '0'
.out:
    call dbg_char
    ret

dbg_char:
    out  0xE9, al
    push dx
    mov  dx, 0x3F8
    out  dx, al
    pop  dx
    ret

fat_loaded:        db 0
ext_key_scan:      db 0
old_int16_ip:      dw 0
old_int16_cs:      dw 0
last_key_scan:     db 0
last_key_tick:     dw 0
exit_msg:          db 0x0D, 0x0A, 'Program Terminated. Press any key to Beautiful Boot.', 0x0D, 0x0A, 0

open_files:        times 4 * 18 db 0
temp_sfn:          times 11 db ' '
loaded_sector_lba: dw 0xFFFF
sector_is_dirty:   db 0
write_src_ptr:     dw 0
write_src_seg:     dw 0
read_dst_ptr:      dw 0
read_dst_seg:      dw 0
active_dir_cluster: dw 0
temp_search_cluster: dw 0