DiskDirectory.java

package libsidutils.directory;

import libsidplay.components.c1541.DiskImage;

import java.io.File;
import java.io.IOException;

/**
 * A read-only directory snapshot; extraction remains usable after the image handle is closed.
 */
public class DiskDirectory extends Directory {
    /**
     * Read the directory and free-block count without retaining an open file handle.
     *
     * @param file disk image file
     * @throws IOException image or directory chain is invalid or cannot be read
     */
    public DiskDirectory(File file) throws IOException {
        try (DiskImage image = DiskImage.openReadOnly(file)) {
            boolean d81 = image.getFormat() == DiskImage.Format.D81;
            boolean d71 = image.getFormat() == DiskImage.Format.D71;
            byte[] header = sector(image, d81 ? 40 : 18, 0);
            title = java.util.Arrays.copyOfRange(header, d81 ? 4 : 144, d81 ? 20 : 160);
            id = java.util.Arrays.copyOfRange(header, d81 ? 22 : 162, d81 ? 27 : 167);
            // The directory track is excluded from each format's BAM free-block count.
            int free = 0;
            if (d81) {
                for (int part = 0; part < 2; part++) {
                    byte[] bam = sector(image, 40, part + 1);
                    for (int entry = 0; entry < 40; entry++) {
                        int track = part * 40 + entry + 1;
                        if (track != 40) free += bam[16 + entry * 6] & 255;
                    }
                }
            } else {
                for (int track = 1; track <= 35; track++)
                    if (track != 18) free += header[4 + (track - 1) * 4] & 255;
                if (d71 && (header[3] & 0x80) != 0)
                    for (int track = 36; track <= 70; track++)
                        if (track != 53) free += header[0xdd + track - 36] & 255;
            }
            statusLine = String.format("%-3d BLOCKS FREE.", free);
            boolean[][] seen = new boolean[image.getTracks() + 1][];
            for (int track = 1; track <= image.getTracks(); track++)
                seen[track] = new boolean[image.getSectorsPerTrack(track)];
            int track = header[0] & 255, number = header[1] & 255;
            while (track != 0) {
                if (!image.isValidSector(track, number) || seen[track][number])
                    throw new IOException("Invalid or cyclic directory chain: " + track + "/" + number);
                seen[track][number] = true;
                byte[] data = sector(image, track, number);
                for (int entry = 0; entry < 8; entry++) {
                    int offset = entry * 32;
                    byte type = data[offset + 2];
                    if ((type & DirEntry.BITMASK_FILETYPE) == DirEntry.FILETYPE_DEL) continue;
                    byte firstTrack = data[offset + 3], firstSector = data[offset + 4];
                    byte[] name = java.util.Arrays.copyOfRange(data, offset + 5, offset + 21);
                    int blocks = (data[offset + 30] & 255) | (data[offset + 31] & 255) << 8;
                    dirEntries.add(new DirEntry(blocks, name, type) {
                        @Override
                        public void save(File target) throws IOException {
                            if (isPartition())
                                throw new IOException("A 1581 partition is not a program file");
                            if (!image.save(target, firstTrack, firstSector))
                                throw new IOException("Invalid file sector chain");
                        }
                    });
                }
                track = data[0] & 255;
                number = data[1] & 255;
            }
        }
    }

    /**
     * Read one logical directory or allocation-map sector.
     *
     * @param image  mounted image
     * @param track  logical track (1-based)
     * @param number logical sector (0-based)
     * @return 256-byte sector payload
     * @throws IOException sector is missing or cannot be read
     */
    private static byte[] sector(DiskImage image, int track, int number) throws IOException {
        byte[] bytes = new byte[256];
        if (!image.readSector(track, number, bytes))
            throw new IOException("Cannot read sector " + track + "/" + number);
        return bytes;
    }
}