formats/fs_prodos.cpp: Treat zero master index entries in tree files as sparse - #16103

#!/usr/bin/env python3
# Build a raw ProDOS volume holding tree files, then read them back with floptool.
#   SPARSE: EOF = 128K + 512. Master index entry 0 is 0 (the whole first 128K is a hole),
#           entry 1 -> index block -> one data block of 0x41.
#   DENSE : same EOF, every block allocated (control: must pass before and after).
import os, re, subprocess, sys

MAME = sys.argv[1]
nblocks = int(sys.argv[2]) if len(sys.argv) > 2 else 1600
work = os.path.dirname(os.path.abspath(__file__))
img_path = os.path.join(work, f"vol{nblocks}.po")

src = open(os.path.join(MAME, "src/lib/formats/fs_prodos.cpp")).read()
boot = bytes(int(x, 16) for x in re.findall(r"0x([0-9a-f]{2})", src.split("prodos_impl::boot[512] = {")[1].split("};")[0]))
assert len(boot) == 512

img = bytearray(512 * nblocks)
def blk(n): return memoryview(img)[512*n:512*(n+1)]
def w16(b, o, v): b[o] = v & 0xff; b[o+1] = v >> 8
def idx_set(b, i, v): b[i] = v & 0xff; b[i+256] = v >> 8

blk(0)[:] = boot
for n in range(2, 6):
    w16(blk(n), 0, n-1 if n > 2 else 0); w16(blk(n), 2, n+1 if n < 5 else 0)
k = blk(2)
name = b"TEST"
k[4] = 0xf0 | len(name); k[5:5+len(name)] = name
k[0x20] = 5; k[0x22] = 0xc3; k[0x23] = 0x27; k[0x24] = 0x0d
w16(k, 0x25, 2); w16(k, 0x27, 6); w16(k, 0x29, nblocks)

def entry(slot, fname, key, used, eof):
    e = memoryview(k)[4 + 39*slot: 4 + 39*(slot+1)]
    e[0] = 0x30 | len(fname); e[1:1+len(fname)] = fname
    e[0x10] = 0x06; w16(e, 0x11, key); w16(e, 0x13, used)
    e[0x15] = eof & 0xff; e[0x16] = (eof >> 8) & 0xff; e[0x17] = eof >> 16
    e[0x1c] = 5; e[0x1e] = 0xc3; w16(e, 0x25, 2)

# SPARSE, as ProDOS itself lays it out (TechRef B.3.6: the first data block is always
# allocated, an index block whose 256 data blocks are all unallocated is not allocated):
#   master 10: [0] -> index 11, [1] = 0 (128K hole), [2] -> index 12
#   index 11: [0] -> data 13 ("F"), index 12: [0] -> data 14 ("A")
idx_set(blk(10), 0, 11); idx_set(blk(10), 1, 0); idx_set(blk(10), 2, 12)
idx_set(blk(11), 0, 13); blk(13)[:] = b"F" * 512
idx_set(blk(12), 0, 14); blk(14)[:] = b"A" * 512
entry(1, b"SPARSE", 10, 5, 2*256*512 + 512)
# DENSE: master 15, index 16 -> data 20..275, index 17 -> data 276
idx_set(blk(15), 0, 16); idx_set(blk(15), 1, 17)
for i in range(256):
    idx_set(blk(16), i, 20 + i); blk(20 + i)[:] = bytes([i]) * 512
idx_set(blk(17), 0, 276); blk(276)[:] = b"B" * 512
entry(2, b"DENSE", 15, 259, 256*512 + 512)
open(img_path, "wb").write(img)

expect = {
    "SPARSE": b"F"*512 + bytes(2*256*512 - 512) + b"A"*512,
    "DENSE": b"".join(bytes([i])*512 for i in range(256)) + b"B"*512,
}
floptool = os.path.join(MAME, "floptool")
ok = True
for fname, want in expect.items():
    out = os.path.join(work, fname + ".out")
    if os.path.exists(out):
        os.remove(out)
    r = subprocess.run([floptool, "hdread", "prodos", img_path, fname, out], capture_output=True, text=True)
    got = open(out, "rb").read() if os.path.exists(out) else None
    good = r.returncode == 0 and got == want
    if r.stderr.strip():
        detail = r.stderr.strip()
    elif got is None:
        detail = "no output"
    else:
        diff = next((i for i, (a, b) in enumerate(zip(got, want)) if a != b), None)
        detail = f"{len(got)} bytes, first wrong byte at offset {diff}"
    print(f"hdread   {fname:6}: {'OK  ' if good else 'FAIL'} {detail}")
    ok &= good

# hdblocks: the sparse file owns master 10, index 11-12 and data 13-14, nothing else
r = subprocess.run([floptool, "hdblocks", "prodos", img_path], capture_output=True, text=True)
lines = [l.split() for l in (r.stdout + r.stderr).splitlines() if "SPARSE" in l]
good = r.returncode == 0 and lines == [["file", "SPARSE", "10-12", "13-14"]]
print(f"hdblocks SPARSE: {'OK  ' if good else 'FAIL'} rc={r.returncode} {' '.join(lines[0])[:120] if lines else r.stderr.strip()}")
ok &= good
dense = [l.split() for l in r.stdout.splitlines() if "DENSE" in l]
good = dense == [["file", "DENSE", "15-17", "20-276"]]
print(f"hdblocks DENSE : {'OK  ' if good else 'FAIL'} {' '.join(dense[0]) if dense else ''}")
ok &= good
sys.exit(0 if ok else 1)