/*
 * CiderPress
 * Copyright (C) 2007 by faddenSoft, LLC.  All Rights Reserved.
 * See the file LICENSE for distribution terms.
 */
/*
 * Implementation of DiskFSDOS33 and A2FileDOS classes.
 *
 * Works for DOS 3.2 and "wide DOS" as well.
 *
 * BUG: does not keep VolumeUsage up to date.
 */
#include "StdAfx.h"
#include "DiskImgPriv.h"


/*
 * ===========================================================================
 *      DiskFSDOS33
 * ===========================================================================
 */

const int kMaxSectors = 32;

const int kSctSize = 256;
/* do we need a way to override these? */
const int kVTOCTrack = 17;
const int kVTOCSector = 0;
const int kCatalogEntryOffset = 0x0b;   // first entry in cat sect starts here
const int kCatalogEntrySize = 0x23;     // length in bytes of catalog entries
const int kCatalogEntriesPerSect = 7;   // #of entries per catalog sector
const int kEntryDeleted = 0xff;     // this is used for track# of deleted files
const int kEntryUnused = 0x00;      // this is track# in never-used entries
const int kMaxTSPairs = 0x7a;           // 122 entries for 256-byte sectors
const int kTSOffset = 0x0c;             // first T/S entry in a T/S list

const int kMaxTSIterations = 32;

/*
 * Get a pointer to the Nth entry in a catalog sector.
 */
static inline uint8_t* GetCatalogEntryPtr(uint8_t* basePtr, int entryNum)
{
    assert(entryNum >= 0 && entryNum < kCatalogEntriesPerSect);
    return basePtr + kCatalogEntryOffset + entryNum * kCatalogEntrySize;
}


/*
 * Test this image for DOS3.3-ness.
 *
 * Some notes on tricky disks...
 *
 * DISK019B (Ultima II player master) has a copy of the VTOC in track 11
 * sector 1, which causes a loop back to track 11 sector f.  We may want
 * to be clever here and allow it, but we have to be careful because
 * we must be similarly clever in the VTOC read routines.  (Need a more
 * sophisticated loop detector, since a loop will crank our "foundGood" up.)
 *
 * DISK038B (Congo Bongo) has some "crack" titles and a valid VTOC, but not
 * much else.  Could allow it if the user explicitly told us to use DOS33,
 * but it's a little thin.
 *
 * DISK112B.X (Ultima I player master) has a catalog that jumps around a lot.
 * It's perfectly valid, but we don't really detect it properly.  Forcing
 * DOS interpretation should be acceptable.
 *
 * DISK175A (Standing Stones) has an extremely short but valid catalog track.
 *
 * DISK198B (Aliens+docs) gets 3 and bails with a self-reference.
 */
static DIError TestImage(DiskImg* pImg, DiskImg::SectorOrder imageOrder,
    int* pGoodCount)
{
    DIError dierr = kDIErrNone;
    uint8_t sctBuf[kSctSize];
    int numTracks, numSectors;
    int catTrack, catSect;
    int foundGood = 0;
    int iterations = 0;

    *pGoodCount = 0;

    dierr = pImg->ReadTrackSectorSwapped(kVTOCTrack, kVTOCSector,
                sctBuf, imageOrder, DiskImg::kSectorOrderDOS);
    if (dierr != kDIErrNone)
        goto bail;

    catTrack = sctBuf[0x01];
    catSect = sctBuf[0x02];
    numTracks = sctBuf[0x34];
    numSectors = sctBuf[0x35];

    if (!(sctBuf[0x27] == kMaxTSPairs) ||
        /*!(sctBuf[0x36] == 0 && sctBuf[0x37] == 1) ||*/    // bytes per sect
        !(numTracks <= DiskFSDOS33::kMaxTracks) ||
        !(numSectors == 13 || numSectors == 16 || numSectors == 32) ||
        !(catTrack < numTracks && catSect < numSectors) ||
        0)
    {
        LOGI("  DOS header test failed (order=%d)", imageOrder);
        dierr = kDIErrFilesystemNotFound;
        goto bail;
    }

    foundGood++;        // score one for a valid-looking VTOC

    /*
     * Walk through the catalog track to try to figure out ordering.
     */
    while (catTrack != 0 && catSect != 0 &&
        iterations < DiskFSDOS33::kMaxCatalogSectors)
    {
        dierr = pImg->ReadTrackSectorSwapped(catTrack, catSect, sctBuf,
                    imageOrder, DiskImg::kSectorOrderDOS);
        if (dierr != kDIErrNone) {
            dierr = kDIErrNone;
            break;      /* allow it if earlier stuff was okay */
        }

        if (catTrack == sctBuf[1] && catSect == sctBuf[2] +1)
            foundGood++;
        else if (catTrack == sctBuf[1] && catSect == sctBuf[2]) {
            LOGI(" DOS detected self-reference on cat (%d,%d)",
                catTrack, catSect);
            break;
        }
        catTrack = sctBuf[1];
        catSect = sctBuf[2];
        iterations++;       // watch for infinite loops
    }
    if (iterations >= DiskFSDOS33::kMaxCatalogSectors) {
        /* possible cause: LF->CR conversion screws up link to sector $0a */
        dierr = kDIErrDirectoryLoop;
        LOGI("  DOS directory links cause a loop (order=%d)", imageOrder);
        goto bail;
    }

    LOGI(" DOS    foundGood=%d order=%d", foundGood, imageOrder);
    *pGoodCount = foundGood;

bail:
    return dierr;
}

/*
 * Test to see if the image is a DOS 3.2 or DOS 3.3 disk.
 */
/*static*/ DIError DiskFSDOS33::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder,
    DiskImg::FSFormat* pFormat, FSLeniency leniency)
{
    if (pImg->GetNumTracks() > kMaxInterestingTracks)
        return kDIErrFilesystemNotFound;

    DiskImg::SectorOrder ordering[DiskImg::kSectorOrderMax];
    
    DiskImg::GetSectorOrderArray(ordering, *pOrder);

    DiskImg::SectorOrder bestOrder = DiskImg::kSectorOrderUnknown;
    int bestCount = 0;

    for (int i = 0; i < DiskImg::kSectorOrderMax; i++) {
        int goodCount = 0;

        if (ordering[i] == DiskImg::kSectorOrderUnknown)
            continue;
        if (TestImage(pImg, ordering[i], &goodCount) == kDIErrNone) {
            if (goodCount > bestCount) {
                bestCount = goodCount;
                bestOrder = ordering[i];
            }
        }
    }

    if (bestCount >= 4 ||
        (leniency == kLeniencyVery && bestCount >= 2))
    {
        LOGI(" DOS test: bestCount=%d for order=%d", bestCount, bestOrder);
        assert(bestOrder != DiskImg::kSectorOrderUnknown);
        *pOrder = bestOrder;
        *pFormat = DiskImg::kFormatDOS33;
        if (pImg->GetNumSectPerTrack() == 13)
            *pFormat = DiskImg::kFormatDOS32;
        return kDIErrNone;
    }

    LOGI(" DOS33 didn't find valid DOS3.2 or DOS3.3");
    return kDIErrFilesystemNotFound;
}


/*
 * Get things rolling.
 *
 * Since we're assured that this is a valid disk, errors encountered from here
 * on out must be handled somehow, possibly by claiming that the disk is
 * completely full and has no files on it.
 */
DIError DiskFSDOS33::Initialize(InitMode initMode)
{
    DIError dierr = kDIErrNone;

    fVolumeUsage.Create(fpImg->GetNumTracks(), fpImg->GetNumSectPerTrack());

    dierr = ReadVTOC();
    if (dierr != kDIErrNone)
        goto bail;
    //DumpVTOC();

    dierr = ScanVolBitmap();
    if (dierr != kDIErrNone)
        goto bail;

    if (initMode == kInitHeaderOnly) {
        LOGI(" DOS - headerOnly set, skipping file load");
        goto bail;
    }

    /* read the contents of the catalog, creating our A2File list */
    dierr = ReadCatalog();
    if (dierr != kDIErrNone)
        goto bail;

    /* run through and get file lengths and data offsets */
    dierr = GetFileLengths();
    if (dierr != kDIErrNone)
        goto bail;

    /* mark DOS tracks appropriately */
    FixVolumeUsageMap();

    fDiskIsGood = CheckDiskIsGood();

    fVolumeUsage.Dump();

//  A2File* pFile;
//  pFile = GetNextFile(NULL);
//  while (pFile != NULL) {
//      pFile->Dump();
//      pFile = GetNextFile(pFile);
//  }

bail:
    return dierr;
}

/*
 * Read some fields from the disk Volume Table of Contents.
 */
DIError DiskFSDOS33::ReadVTOC(void)
{
    DIError dierr;

    dierr = LoadVolBitmap();
    if (dierr != kDIErrNone)
        goto bail;

    fFirstCatTrack = fVTOC[0x01];
    fFirstCatSector = fVTOC[0x02];
    fVTOCVolumeNumber = fVTOC[0x06];
    fVTOCNumTracks = fVTOC[0x34];
    fVTOCNumSectors = fVTOC[0x35];

    if (fFirstCatTrack >= fpImg->GetNumTracks())
        return kDIErrBadDiskImage;
    if (fFirstCatSector >= fpImg->GetNumSectPerTrack())
        return kDIErrBadDiskImage;

    if (fVTOCNumTracks != fpImg->GetNumTracks()) {
        LOGI(" DOS33 warning: VTOC numtracks %d vs %ld",
            fVTOCNumTracks, fpImg->GetNumTracks());
    }
    if (fVTOCNumSectors != fpImg->GetNumSectPerTrack()) {
        LOGI(" DOS33 warning: VTOC numsect %d vs %d",
            fVTOCNumSectors, fpImg->GetNumSectPerTrack());
    }

    // call SetDiskVolumeNum with the appropriate thing
    UpdateVolumeNum();

bail:
    FreeVolBitmap();
    return dierr;
}

/*
 * Call this if fpImg's volume num (derived from nibble formats) or
 * the VTOC's volume number changes.
 */
void DiskFSDOS33::UpdateVolumeNum(void)
{
    /* use the sector-embedded volume number, if available */
    if (fpImg->GetDOSVolumeNum() == DiskImg::kVolumeNumNotSet)
        SetDiskVolumeNum(fVTOCVolumeNumber);
    else
        SetDiskVolumeNum(fpImg->GetDOSVolumeNum());
    if (fDiskVolumeNum != fVTOCVolumeNumber) {
        LOGI("  NOTE: ignoring VTOC vol (%d) in favor of embedded (%d)",
            fVTOCVolumeNumber, fDiskVolumeNum);
    }
}

/*
 * Set the disk volume number (fDiskVolumeNum) and derived fields.
 */
void DiskFSDOS33::SetDiskVolumeNum(int val)
{
    if (val < 0 || val > 255) {
        // Actual valid range should be 1-254, but it's possible for a
        // sector edit to put invalid stuff here.  It's just one byte
        // though, so 0-255 should be guaranteed.
        assert(false);
        return;
    }
    fDiskVolumeNum = val;
    sprintf(fDiskVolumeName, "DOS%03d", fDiskVolumeNum);
    if (fpImg->GetFSFormat() == DiskImg::kFormatDOS32)
        sprintf(fDiskVolumeID, "DOS 3.2 Volume %03d", fDiskVolumeNum);
    else
        sprintf(fDiskVolumeID, "DOS 3.3 Volume %03d", fDiskVolumeNum);
}


/*
 * Dump some VTOC fields.
 */
void DiskFSDOS33::DumpVTOC(void)
{

    LOGI("VTOC catalog: track=%d sector=%d",
        fFirstCatTrack, fFirstCatSector);
    LOGI("  volnum=%d numTracks=%d numSects=%d",
        fVTOCVolumeNumber, fVTOCNumTracks, fVTOCNumSectors);
}

/*
 * Update an entry in the VolumeUsage map, watching for conflicts.
 */
void DiskFSDOS33::SetSectorUsage(long track, long sector,
    VolumeUsage::ChunkPurpose purpose)
{
    VolumeUsage::ChunkState cstate;

    //LOGI(" DOS setting usage %d,%d to %d", track, sector, purpose);

    fVolumeUsage.GetChunkState(track, sector, &cstate);
    if (cstate.isUsed) {
        cstate.purpose = VolumeUsage::kChunkPurposeConflict;
//      LOGI(" DOS conflicting uses for t=%d s=%d", track, sector);
    } else {
        cstate.isUsed = true;
        cstate.purpose = purpose;
    }
    fVolumeUsage.SetChunkState(track, sector, &cstate);
}

/*
 * Examine the volume bitmap, setting fields in the VolumeUsage map
 * as appropriate.  We mark "isMarkedUsed", but leave "isUsed" clear.  The
 * "isUsed" flag gets set by the DOS catalog track processor and the file
 * scanners.
 *
 * We can't mark the DOS tracks, because there's no reliable way to tell by
 * looking at a DOS disk whether it has a bootable DOS image.  It's possible
 * the tracks are marked in-use because files are stored there.  Some
 * tweaked versions of DOS freed up a few sectors on track 2, so partial
 * allocation isn't a good indicator.
 *
 * What we have to do is wait until we have all the information for the
 * various files, and mark the tracks as owned by DOS if nobody else
 * claims them.
 */
DIError DiskFSDOS33::ScanVolBitmap(void)
{
    DIError dierr;
    VolumeUsage::ChunkState cstate;
    char freemap[32+1] = "--------------------------------";

    cstate.isUsed = false;
    cstate.isMarkedUsed = true;
    cstate.purpose = (VolumeUsage::ChunkPurpose) 0;

    dierr = LoadVolBitmap();
    if (dierr != kDIErrNone)
        goto bail;

    LOGI("  map 0123456789abcdef");

    for (int i = 0; i < kMaxTracks; i++) {
        uint32_t val, origVal;
        int bit;

        val = (uint32_t) fVTOC[0x38 + i*4] << 24;
        val |= (uint32_t) fVTOC[0x39 + i*4] << 16;
        val |= (uint32_t) fVTOC[0x3a + i*4] << 8;
        val |= (uint32_t) fVTOC[0x3b + i*4];
        origVal = val;

        /* init the VolumeUsage stuff */
        for (bit = fpImg->GetNumSectPerTrack()-1; bit >= 0; bit--) {
            freemap[bit] = val & 0x80000000 ? '.' : 'X';

            if (i < fpImg->GetNumTracks() && !(val & 0x80000000)) {
                /* mark the sector as in-use */
                if (fVolumeUsage.SetChunkState(i, bit, &cstate) != kDIErrNone) {
                    assert(false);
                }
            }
            val <<= 1;
        }
        LOGI("  %2d: %s (0x%08x)", i, freemap, origVal);
    }

    /* we know the VTOC is used, so mark it now */
    SetSectorUsage(kVTOCTrack, kVTOCSector, VolumeUsage::kChunkPurposeVolumeDir);

bail:
    FreeVolBitmap();
    return dierr;
}


/*
 * Load the VTOC into the buffer.
 */
DIError DiskFSDOS33::LoadVolBitmap(void)
{
    DIError dierr;

    assert(!fVTOCLoaded);

    dierr = fpImg->ReadTrackSector(kVTOCTrack, kVTOCSector, fVTOC);
    if (dierr != kDIErrNone)
        return dierr;

    fVTOCLoaded = true;
    return kDIErrNone;
}

/*
 * Save our copy of the volume bitmap.
 */
DIError DiskFSDOS33::SaveVolBitmap(void)
{
    if (!fVTOCLoaded) {
        assert(false);
        return kDIErrNotReady;
    }

    return fpImg->WriteTrackSector(kVTOCTrack, kVTOCSector, fVTOC);
}

/*
 * Throw away the volume bitmap, discarding any unsaved changes.
 *
 * It's okay to call this if the bitmap isn't loaded.
 */
void DiskFSDOS33::FreeVolBitmap(void)
{
    fVTOCLoaded = false;

#ifdef _DEBUG
    memset(fVTOC, 0x99, sizeof(fVTOC));
#endif
}

/*
 * Return entry N from the VTOC.
 */
inline uint32_t DiskFSDOS33::GetVTOCEntry(const uint8_t* pVTOC, long track) const
{
    uint32_t val;
    val = (uint32_t) pVTOC[0x38 + track*4] << 24;
    val |= (uint32_t) pVTOC[0x39 + track*4] << 16;
    val |= (uint32_t) pVTOC[0x3a + track*4] << 8;
    val |= (uint32_t) pVTOC[0x3b + track*4];

    return val;
}

/*
 * Allocate a new sector from the unused pool.
 *
 * Only touches the in-memory copy.
 */
DIError DiskFSDOS33::AllocSector(TrackSector* pTS)
{
    uint32_t val;
    uint32_t mask;
    long track, numSectPerTrack;

    /* we could compute "mask", but it's faster and easier to do this */
    numSectPerTrack = GetDiskImg()->GetNumSectPerTrack();
    if (numSectPerTrack == 13)
        mask = 0xfff80000;
    else if (numSectPerTrack == 16)
        mask = 0xffff0000;
    else if (numSectPerTrack == 32)
        mask = 0xffffffff;
    else {
        assert(false);
        return kDIErrInternal;
    }

    /*
     * Start by finding a track with a free sector.  We know it's free
     * because the bits aren't all zero.
     *
     * In theory we don't need "mask", because the DOS format routine is
     * good about leaving the unused bits clear, and nobody else disturbs
     * them.  However, it's best not to rely on it.
     */
    for (track = kVTOCTrack; track > 0; track--) {
        val = GetVTOCEntry(fVTOC, track);
        if ((val & mask) != 0)
            break;
    }
    if (track == 0) {
        long numTracks = GetDiskImg()->GetNumTracks();
        for (track = kVTOCTrack; track < numTracks; track++)
        {
            val = GetVTOCEntry(fVTOC, track);
            if ((val & mask) != 0)
                break;
        }
        if (track == numTracks) {
            LOGI("DOS33 AllocSector unable to find empty sector");
            return kDIErrDiskFull;
        }
    }

    /*
     * We've got the track.  Now find the first free sector.
     */
    int sector;
    sector = numSectPerTrack-1;
    while (sector >= 0) {
        if (val & 0x80000000) {
            //LOGI("+++ allocating T=%d S=%d", track, sector);
            SetSectorUseEntry(track, sector, true);
            break;
        }

        val <<= 1;
        sector--;
    }
    if (sector < 0) {
        assert(false);
        return kDIErrInternal;  // should not have failed
    }

    /*
     * Mostly for fun, update the VTOC allocation thingy.
     */
    fVTOC[0x30] = (uint8_t) track; // last track where alloc happened
    if (track < kVTOCTrack)
        fVTOC[0x31] = 0xff;     // descending
    else
        fVTOC[0x31] = 0x01;     // ascending

    pTS->track = (char) track;
    pTS->sector = (char) sector;

    return kDIErrNone;
}

/*
 * Create an in-use map for an empty disk.  Sets up the VTOC map only.
 *
 * If "withDOS" is set, mark the first 3 tracks as in-use.
 */
DIError DiskFSDOS33::CreateEmptyBlockMap(bool withDOS)
{
    DIError dierr;
    long track, sector, maxTrack;

    dierr = LoadVolBitmap();
    if (dierr != kDIErrNone)
        return dierr;

    if (withDOS)
        maxTrack = 3;
    else
        maxTrack = 1;

    /*
     * Set each bit individually.  Slower, but exercises standard functions.
     *
     * Clear all "in use" flags, except for track 0, track 17, and (if
     * withDOS is set) tracks 1 and 2.
     */
    for (track = fpImg->GetNumTracks()-1; track >= 0; track--) {
        for (sector = fpImg->GetNumSectPerTrack()-1; sector >= 0; sector--) {
            if (track < maxTrack || track == kVTOCTrack)
                SetSectorUseEntry(track, sector, true);
            else
                SetSectorUseEntry(track, sector, false);
        }
    }

    dierr = SaveVolBitmap();
    FreeVolBitmap();
    if (dierr != kDIErrNone)
        return dierr;

    return kDIErrNone;
}

/*
 * Get the state of an entry in the VTOC sector use map.
 *
 * Returns "true" if it's in use, "false" otherwise.
 */
bool DiskFSDOS33::GetSectorUseEntry(long track, int sector) const
{
    assert(fVTOCLoaded);
    assert(track >= 0 && track < fpImg->GetNumTracks());
    assert(sector >= 0 && sector < fpImg->GetNumSectPerTrack());

    uint32_t val, mask;

    val = GetVTOCEntry(fVTOC, track);
    //val = (uint32_t) fVTOC[0x38 + track*4] << 24;
    //val |= (uint32_t) fVTOC[0x39 + track*4] << 16;
    //val |= (uint32_t) fVTOC[0x3a + track*4] << 8;
    //val |= (uint32_t) fVTOC[0x3b + track*4];

    /*
     * The highest-numbered sector is now in the high bit.  If this is a
     * 16-sector disk, the high bit holds the state of sector 15.
     *
     * A '1' indicates the sector is free, '0' indicates it's in use.
     */
    mask = 1L << (32 - fpImg->GetNumSectPerTrack() + sector);
    return (val & mask) == 0;
}

/*
 * Change the state of an entry in the VTOC sector use map.
 */
void DiskFSDOS33::SetSectorUseEntry(long track, int sector, bool inUse)
{
    assert(fVTOCLoaded);
    assert(track >= 0 && track < fpImg->GetNumTracks());
    assert(sector >= 0 && sector < fpImg->GetNumSectPerTrack());

    uint32_t val, mask;

    val = GetVTOCEntry(fVTOC, track);

    /* highest sector is always in the high bit */
    mask = 1L << (32 - fpImg->GetNumSectPerTrack() + sector);
    if (inUse)
        val &= ~mask;
    else
        val |= mask;

    fVTOC[0x38 + track*4] = (uint8_t) (val >> 24);
    fVTOC[0x39 + track*4] = (uint8_t) (val >> 16);
    fVTOC[0x3a + track*4] = (uint8_t) (val >> 8);
    fVTOC[0x3b + track*4] = (uint8_t) val;
}


/*
 * Get the amount of free space remaining.
 */
DIError DiskFSDOS33::GetFreeSpaceCount(long* pTotalUnits, long* pFreeUnits,
    int* pUnitSize) const
{
    DIError dierr;
    long track, sector, freeSectors;

    dierr = const_cast<DiskFSDOS33*>(this)->LoadVolBitmap();
    if (dierr != kDIErrNone)
        return dierr;

    freeSectors = 0;
    for (track = GetDiskImg()->GetNumTracks()-1; track >= 0; track--) {
        for (sector = GetDiskImg()->GetNumSectPerTrack()-1; sector >= 0; sector--)
        {
            if (!GetSectorUseEntry(track, sector))
                freeSectors++;
        }
    }

    *pTotalUnits = fpImg->GetNumTracks() * fpImg->GetNumSectPerTrack();
    *pFreeUnits = freeSectors;
    *pUnitSize = kSectorSize;

    const_cast<DiskFSDOS33*>(this)->FreeVolBitmap();
    return kDIErrNone;
}


/*
 * Fix up the DOS tracks.
 *
 * Any sectors marked used but not actually in use by a file are marked as
 * in use by the system.  We have to be somewhat careful here because some
 * disks had DOS removed to add space, un-set the last few sectors of track 2
 * that weren't actually used by DOS, or did some other funky thing.
 */
void DiskFSDOS33::FixVolumeUsageMap(void)
{
    VolumeUsage::ChunkState cstate;
    int track, sector;

    for (track = 0; track < 3; track++) {
        for (sector = 0; sector < fpImg->GetNumSectPerTrack(); sector++) {
            fVolumeUsage.GetChunkState(track, sector, &cstate);
            if (cstate.isMarkedUsed && !cstate.isUsed) {
                cstate.isUsed = true;
                cstate.purpose = VolumeUsage::kChunkPurposeSystem;
                fVolumeUsage.SetChunkState(track, sector, &cstate);
            }
        }
    }
}


/*
 * Read the disk's catalog.
 *
 * NOTE: supposedly DOS stops reading the catalog track when it finds the
 * first entry with a 00 byte, which is why deleted files use ff.  If so,
 * it *might* make sense to mimic this behavior, though on a health disk
 * we shouldn't be finding garbage anyway.
 *
 * Fills out "fCatalogSectors" as it works.
 */
DIError DiskFSDOS33::ReadCatalog(void)
{
    DIError dierr = kDIErrNone;
    uint8_t sctBuf[kSctSize];
    int catTrack, catSect;
    int iterations;

    catTrack = fFirstCatTrack;
    catSect = fFirstCatSector;
    iterations = 0;

    memset(fCatalogSectors, 0, sizeof(fCatalogSectors));

    while (catTrack != 0 && catSect != 0 && iterations < kMaxCatalogSectors)
    {
        SetSectorUsage(catTrack, catSect, VolumeUsage::kChunkPurposeVolumeDir);

        LOGI(" DOS33 reading catalog sector T=%d S=%d", catTrack, catSect);
        dierr = fpImg->ReadTrackSector(catTrack, catSect, sctBuf);
        if (dierr != kDIErrNone)
            goto bail;

        /*
         * Watch for flaws that the DOS detector allows.
         */
        if (catTrack == sctBuf[0x01] && catSect == sctBuf[0x02]) {
            LOGI(" DOS detected self-reference on cat (%d,%d)",
                catTrack, catSect);
            break;
        }

        /*
         * Check the next track/sector in the chain.  If the pointer is
         * broken, there's a very good chance that this isn't really a
         * catalog sector, so we want to bail out now.
         */
        if (sctBuf[0x01] >= fpImg->GetNumTracks() ||
            sctBuf[0x02] >= fpImg->GetNumSectPerTrack())
        {
            LOGI(" DOS bailing out early on catalog read due to funky T/S");
            break;
        }

        dierr = ProcessCatalogSector(catTrack, catSect, sctBuf);
        if (dierr != kDIErrNone)
            goto bail;

        fCatalogSectors[iterations].track = catTrack;
        fCatalogSectors[iterations].sector = catSect;

        catTrack = sctBuf[0x01];
        catSect = sctBuf[0x02];

        iterations++;       // watch for infinite loops

    }
    if (iterations >= kMaxCatalogSectors) {
        dierr = kDIErrDirectoryLoop;
        goto bail;
    }

bail:
    return dierr;
}

/*
 * Process the list of files in one sector of the catalog.
 *
 * Pass in the track, sector, and the contents of that track and sector.
 * (We only use "catTrack" and "catSect" to fill out some fields.)
 */
DIError DiskFSDOS33::ProcessCatalogSector(int catTrack, int catSect,
    const uint8_t* sctBuf)
{
    A2FileDOS* pFile;
    const uint8_t* pEntry;
    int i;

    pEntry = &sctBuf[kCatalogEntryOffset];

    for (i = 0; i < kCatalogEntriesPerSect; i++) {
        if (pEntry[0x00] != kEntryUnused && pEntry[0x00] != kEntryDeleted) {
            pFile = new A2FileDOS(this);

            pFile->SetQuality(A2File::kQualityGood);

            pFile->fTSListTrack = pEntry[0x00];
            pFile->fTSListSector = pEntry[0x01];
            pFile->fLocked = (pEntry[0x02] & 0x80) != 0;
            switch (pEntry[0x02] & 0x7f) {
            case 0x00:  pFile->fFileType = A2FileDOS::kTypeText;        break;
            case 0x01:  pFile->fFileType = A2FileDOS::kTypeInteger;     break;
            case 0x02:  pFile->fFileType = A2FileDOS::kTypeApplesoft;   break;
            case 0x04:  pFile->fFileType = A2FileDOS::kTypeBinary;      break;
            case 0x08:  pFile->fFileType = A2FileDOS::kTypeS;           break;
            case 0x10:  pFile->fFileType = A2FileDOS::kTypeReloc;       break;
            case 0x20:  pFile->fFileType = A2FileDOS::kTypeA;           break;
            case 0x40:  pFile->fFileType = A2FileDOS::kTypeB;           break;
            default:
                /* some odd arrangement of bit flags? */
                LOGI(" DOS33 peculiar filetype byte 0x%02x", pEntry[0x02]);
                pFile->fFileType = A2FileDOS::kTypeUnknown;
                pFile->SetQuality(A2File::kQualitySuspicious);
                break;
            }

            memcpy(pFile->fRawFileName, &pEntry[0x03], A2FileDOS::kMaxFileName);
            pFile->fRawFileName[A2FileDOS::kMaxFileName] = '\0';

            memcpy(pFile->fFileName, &pEntry[0x03], A2FileDOS::kMaxFileName);
            pFile->fFileName[A2FileDOS::kMaxFileName] = '\0';
            pFile->FixFilename();

            pFile->fLengthInSectors = pEntry[0x21];
            pFile->fLengthInSectors |= (uint16_t) pEntry[0x22] << 8;

            pFile->fCatTS.track = catTrack;
            pFile->fCatTS.sector = catSect;
            pFile->fCatEntryNum = i;

            /* can't do these yet, so just set to defaults */
            pFile->fLength = 0;
            pFile->fSparseLength = 0;
            pFile->fDataOffset = 0;

            AddFileToList(pFile);
        }

        pEntry += kCatalogEntrySize;
    }

    return kDIErrNone;
}

/*
 * Perform consistency checks on the filesystem.
 *
 * Returns "true" if disk appears to be perfect, "false" otherwise.
 */
bool DiskFSDOS33::CheckDiskIsGood(void)
{
    DIError dierr;
    const DiskImg* pDiskImg = GetDiskImg();
    bool result = true;
    int i;

    dierr = LoadVolBitmap();
    if (dierr != kDIErrNone)
        goto bail;

    /*
     * Make sure the VTOC is marked in use, or things could go badly.
     * Ditto for the catalog tracks.
     */
    if (!GetSectorUseEntry(kVTOCTrack, kVTOCSector)) {
        fpImg->AddNote(DiskImg::kNoteWarning, "VTOC sector marked as free.");
        result = false;
    }
    for (i = 0; i < kMaxCatalogSectors; i++) {
        if (!GetSectorUseEntry(fCatalogSectors[i].track,
            fCatalogSectors[i].sector))
        {
            fpImg->AddNote(DiskImg::kNoteWarning,
                "Catalog sector %d,%d is marked as free.",
                fCatalogSectors[i].track, fCatalogSectors[i].sector);
            result = false;
        }
    }

    /*
     * Check for used blocks that aren't marked in-use.
     *
     * This requires that VolumeUsage be accurate.  Since this function is
     * only run during initial startup, any later deviation between VU and
     * the block use map is irrelevant.
     */
    VolumeUsage::ChunkState cstate;
    long track, sector;
    long notMarked, extraUsed, conflicts;
    notMarked = extraUsed = conflicts = 0;
    for (track = 0; track < pDiskImg->GetNumTracks(); track++) {
        for (sector = 0; sector < pDiskImg->GetNumSectPerTrack(); sector++) {
            dierr = fVolumeUsage.GetChunkState(track, sector, &cstate);
            if (dierr != kDIErrNone) {
                fpImg->AddNote(DiskImg::kNoteWarning,
                    "Internal volume usage error on t=%ld s=%ld.",
                    track, sector);
                result = false;
                goto bail;
            }

            if (cstate.isUsed && !cstate.isMarkedUsed)
                notMarked++;
            if (!cstate.isUsed && cstate.isMarkedUsed)
                extraUsed++;
            if (cstate.purpose == VolumeUsage::kChunkPurposeConflict)
                conflicts++;
        }
    }
    if (extraUsed > 0) {
        fpImg->AddNote(DiskImg::kNoteInfo,
            "%ld sector%s marked used but not part of any file.",
            extraUsed, extraUsed == 1 ? " is" : "s are");
        // not a problem, really
    }
    if (notMarked > 0) {
        fpImg->AddNote(DiskImg::kNoteWarning,
            "%ld sector%s used by files but not marked used.",
            notMarked, notMarked == 1 ? " is" : "s are");
        result = false;
    }
    if (conflicts > 0) {
        fpImg->AddNote(DiskImg::kNoteWarning,
            "%ld sector%s used by more than one file.",
            conflicts, conflicts == 1 ? " is" : "s are");
        result = false;
    }

    /*
     * Scan for "damaged" files or "suspicious" files diagnosed earlier.
     */
    bool damaged, suspicious;
    ScanForDamagedFiles(&damaged, &suspicious);

    if (damaged) {
        fpImg->AddNote(DiskImg::kNoteWarning,
            "One or more files are damaged.");
        result = false;
    } else if (suspicious) {
        fpImg->AddNote(DiskImg::kNoteWarning,
            "One or more files look suspicious.");
        result = false;
    }

bail:
    FreeVolBitmap();
    return result;
}


/*
 * Run through our list of files, computing the lengths and marking file
 * usage in the VolumeUsage object.
 */
DIError DiskFSDOS33::GetFileLengths(void)
{
    A2FileDOS* pFile;
    TrackSector* tsList = NULL;
    TrackSector* indexList = NULL;
    int tsCount;
    int indexCount;

    pFile = (A2FileDOS*) GetNextFile(NULL);
    while (pFile != NULL) {
        DIError dierr;
        dierr = pFile->LoadTSList(&tsList, &tsCount, &indexList, &indexCount);
        if (dierr != kDIErrNone) {
            LOGI("DOS failed loading TS list for '%s'",
                pFile->GetPathName());
            pFile->SetQuality(A2File::kQualityDamaged);
        } else {
            MarkFileUsage(pFile, tsList, tsCount, indexList, indexCount);
            dierr = ComputeLength(pFile, tsList, tsCount);
            if (dierr != kDIErrNone) {
                LOGI("DOS unable to get length for '%s'",
                    pFile->GetPathName());
                pFile->SetQuality(A2File::kQualityDamaged);
            }
        }

        if (pFile->fLengthInSectors != indexCount + tsCount) {
            LOGI("DOS NOTE: file '%s' has len-in-sect=%d but actual=%d",
                pFile->GetPathName(), pFile->fLengthInSectors,
                indexCount + tsCount);
            // expected on sparse random-access text files
        }

        delete[] tsList;
        delete[] indexList;
        tsList = indexList = NULL;

        pFile = (A2FileDOS*) GetNextFile(pFile);
    }

    return kDIErrNone;
}

/*
 * Compute the length and starting data offset of the file.
 *
 * For Text, there are two situations: sequential and random.  For
 * sequential text files, we just need to find the first 00 byte.  For
 * random, there can be 00s everywhere, and in fact there can be holes
 * in the T/S list.  The plan: since DOS doesn't let you "truncate" a
 * text file, just scan the last sector for 00.  The length is the
 * number of previous T/S entries * 256 plus the sector offset.
 * --> This does the wrong thing for random-access text files, which
 * need to retain their full length, and doesn't work right for sequential
 * text files that (somehow) had their last block over-allocated.  It does
 * the right thing most of the time, but we either need to be more clever
 * here or provide a way to override the default (bool fTrimTextFiles?).
 *
 * For Applesoft and Integer, the file length is stored as the first two
 * bytes of the file.
 *
 * For Binary, the file length is stored in the second two bytes (after
 * the two-byte address).  Some files (with low-memory loaders) used a
 * fake length, and DDD 2.x sets both address and length to zero.
 *
 * For Reloc, S, A2, B2, and "unknown", we just multiply the sector count.
 * We get an accurate sector count from the T/S list (the value in the
 * directory entry might have been tampered with).
 *
 * To handle DDD 2.x files correctly, we need to identify them as such by
 * looking for 'B' with address=0 and length=0, a T/S count of at least 8
 * (the smallest possible compression of a 35-track disk is 2385 bytes),
 * and a '<' in the filename.  If found, we start from offset=0
 * (because DDD Pro 1.x includes the 4 leading bytes) and include all
 * sectors, we'll get the actual file plus at most 256 garbage bytes.
 *
 * On success, we set the following:
 *  pFile->fLength
 *  pFile->fSparseLength
 *  pFile->fDataOffset
 */
DIError DiskFSDOS33::ComputeLength(A2FileDOS* pFile, const TrackSector* tsList,
    int tsCount)
{
    DIError dierr = kDIErrNone;
    uint8_t sctBuf[kSctSize];

    assert(pFile != NULL);
    assert(tsList != NULL);
    assert(tsCount >= 0);

    pFile->fDataOffset = 0;

    pFile->fAuxType = 0;
    if (pFile->fFileType == A2FileDOS::kTypeApplesoft)
        pFile->fAuxType = 0x0801;
    /* for text files it's default record length; assume zero */

    if (tsCount == 0) {
        /* no data at all */
        pFile->fLength = 0;
    } else if (pFile->fFileType == A2FileDOS::kTypeApplesoft ||
        pFile->fFileType == A2FileDOS::kTypeInteger ||
        pFile->fFileType == A2FileDOS::kTypeBinary)
    {
        /* read first sector and analyze it */
        //LOGI(" DOS reading first file sector");
        dierr = fpImg->ReadTrackSector(tsList[0].track, tsList[0].sector,
                    sctBuf);
        if (dierr != kDIErrNone)
            goto bail;

        if (pFile->fFileType == A2FileDOS::kTypeBinary) {
            pFile->fAuxType =
                sctBuf[0x00] | (uint16_t) sctBuf[0x01] << 8;
            pFile->fLength =
                sctBuf[0x02] | (uint16_t) sctBuf[0x03] << 8;
            pFile->fDataOffset = 4; // take the above into account
        } else {
            pFile->fLength =
                sctBuf[0x00] | (uint16_t) sctBuf[0x01] << 8;
            pFile->fDataOffset = 2; // take the above into account
        }

        if (pFile->fFileType == A2FileDOS::kTypeBinary &&
            pFile->fLength == 0 && pFile->fAuxType == 0 &&
            tsCount >= 8 &&
            strchr(pFile->fFileName, '<') != NULL &&
            strchr(pFile->fFileName, '>') != NULL)
        {
            LOGI(" DOS found probable DDD archive, tweaking '%s' (lis=%u)",
                pFile->GetPathName(), pFile->fLengthInSectors);
            //dierr = TrimLastSectorDown(pFile, tsBuf, WrapperDDD::kMaxDDDZeroCount);
            //if (dierr != kDIErrNone)
            //  goto bail;
            //LOGI(" DOS scanned DDD file '%s' to length %ld (tsCount=%d)",
            //  pFile->fFileName, pFile->fLength, pFile->fTSListCount);
            pFile->fLength = tsCount * kSctSize;
            pFile->fDataOffset = 0;
        }

        /* catch bogus lengths in damaged A/I/B files */
        if (pFile->fLength > tsCount * kSctSize) {
            LOGI(" DOS33 capping max len from %ld to %d in '%s'",
                (long) pFile->fLength, tsCount * kSctSize,
                pFile->fFileName);
            pFile->fLength = tsCount * kSctSize - pFile->fDataOffset;
            if (pFile->fLength < 0)     // can't happen here?
                pFile->fLength = 0;

            /*
             * This could cause a problem, because if the user changes a 'T'
             * file to 'B', the bogus file length will mark the file as
             * "suspicious" and we won't allow writing to the disk (which
             * makes it hard to switch the file type back).  We really don't
             * want to weaken this test though.
             */
            pFile->SetQuality(A2File::kQualitySuspicious);
        }

    } else if (pFile->fFileType == A2FileDOS::kTypeText) {
        /* scan text file */
        pFile->fLength = tsCount * kSctSize;
        dierr = TrimLastSectorUp(pFile, tsList[tsCount-1]);
        if (dierr != kDIErrNone)
            goto bail;

        LOGI(" DOS scanned text file '%s' down to %d+%ld = %ld",
            pFile->fFileName,
            (tsCount-1) * kSctSize,
            (long)pFile->fLength - (tsCount-1) * kSctSize,
            (long)pFile->fLength);

        /* TO DO: something clever to discern random access record length? */
    } else {
        /* S/R/A/B: just use the TS count */
        pFile->fLength = tsCount * kSctSize;
    }

    /*
     * Compute the sparse length for random-access text files.
     */
    int i, sparseCount;
    sparseCount = 0;
    for (i = 0; i < tsCount; i++) {
        if (tsList[i].track == 0 && tsList[i].sector == 0)
            sparseCount++;
    }
    pFile->fSparseLength = pFile->fLength - sparseCount * kSctSize;
    if (pFile->fSparseLength == -pFile->fDataOffset) {
        /*
         * This can happen for a completely sparse file.  Looks sort of
         * stupid to have a length of "-4", so force it to zero.
         */
        pFile->fSparseLength = 0;
    }

bail:
    return dierr;
}

/*
 * Trim the zeroes off the end of the last sector.  We begin at the start
 * of the sector and stop at the first zero found.
 *
 * Modifies pFile->fLength, which should be set to a roughly accurate
 * value on entry.
 *
 * The caller should endeavor to strip out T=0 S=0 entries that come after
 * the body of the file.  They're valid in the middle for random-access
 * text files.
 */
DIError DiskFSDOS33::TrimLastSectorUp(A2FileDOS* pFile, TrackSector lastTS)
{
    DIError dierr;
    uint8_t sctBuf[kSctSize];
    int i;

    if (lastTS.track == 0) {
        /* happens on files with lots of "sparse" space at the end */
        return kDIErrNone;
    }

    //LOGI(" DOS reading LAST file sector");
    dierr = fpImg->ReadTrackSector(lastTS.track, lastTS.sector, sctBuf);
    if (dierr != kDIErrNone)
        goto bail;

    /* start with EOF equal to previous sectors */
    pFile->fLength -= kSctSize;
    for (i = 0; i < kSctSize; i++) {
        if (sctBuf[i] == 0x00)
            break;
        else
            pFile->fLength++;
    }

bail:
    return dierr;
}

/*
 * Given lists of tracks and sector for data and TS index sectors, set the
 * entries in the volume usage map.
 */
void DiskFSDOS33::MarkFileUsage(A2FileDOS* pFile, TrackSector* tsList, int tsCount,
    TrackSector* indexList, int indexCount)
{
    int i;

    for (i = 0; i < tsCount; i++) {
        /* mark all sectors as in-use by file */
        if (tsList[i].track == 0 && tsList[i].sector == 0) {
            /* sparse sector in random-access text file */
        } else {
            SetSectorUsage(tsList[i].track, tsList[i].sector,
                VolumeUsage::kChunkPurposeUserData);
        }
    }

    for (i = 0; i < indexCount; i++) {
        /* mark the T/S sectors as in-use by file structures */
        SetSectorUsage(indexList[i].track, indexList[i].sector,
            VolumeUsage::kChunkPurposeFileStruct);
    }
}



#if 0
/*
 * Trim the zeroes off the end of the last sector.  We begin at the end
 * of the sector and back up.
 *
 * It is possible (one out of between 128 and 256 times) that we have just
 * the trailing zero in this sector, and we need to back up to the previous
 * sector to find the actual end.  We know a file can end with three zeroes
 * and we suspect it might be possible to end with four, which means we could
 * have between 0 and 3 zeroes in the previous sector, and between 1 and 4
 * in this sector.  If we just tack on three more zeroes, we weaken our
 * length test slightly, because we must allow a "slop" of up to seven bytes.
 * It's a little more work, but scanning the next-to-last sector is probably
 * worthwhile given the otherwise flaky nature of DDD storage.
 */
DIError
DiskFSDOS33::TrimLastSectorDown(A2FileDOS* pFile, uint16_t* tsBuf,
    int maxZeroCount)
{
    DIError dierr;
    uint8_t sctBuf[kSctSize];
    int i;

    //LOGI(" DOS reading LAST file sector");
    dierr = fpImg->ReadTrackSector(
                pFile->TSTrack(tsBuf[pFile->fTSListCount-1]),
                pFile->TSSector(tsBuf[pFile->fTSListCount-1]),
                sctBuf);
    if (dierr != kDIErrNone)
        goto bail;

    /* find the first trailing zero by finding the last non-zero */
    for (i = kSctSize-1; i >= 0; i--) {
        if (sctBuf[i] != 0x00)
            break;
    }
    if (i < 0) {
        /* sector was nothing but zeroes */
        DebugBreak();
    } else {
        /* peg it at 256; if it went over that, DDD would've added a sector */
        i += maxZeroCount;
        if (i > kSctSize)
            i = kSctSize;
        pFile->fLength = (pFile->fTSListCount-1) * kSctSize + i;
    }

bail:
    return dierr;
}
#endif


/*
 * Convert high ASCII to low ASCII.
 *
 * Some people put inverse and flashing text into filenames, not to mention
 * control characters, so we have to cope with those too.
 *
 * We modify the first "len" bytes of "buf" in place.
 */
/*static*/ void DiskFSDOS33::LowerASCII(uint8_t* buf, long len)
{
    while (len--) {
        if (*buf & 0x80) {
            if (*buf >= 0xa0)
                *buf &= 0x7f;
            else
                *buf = (*buf & 0x7f) + 0x20;
        } else
            *buf = ((*buf & 0x3f) ^ 0x20) + 0x20;

        buf++;
    }
}


/*
 * Determine whether or not "name" is a valid DOS 3.3 filename.
 *
 * Names can be up to 30 characters and can contain absolutely anything.
 * To make life easier on DOS users, we ban the use of the comma, block
 * control characters and high ASCII, and don't allow completely blank
 * names.  Later on we will later convert to upper case, so we allow lower
 * case letters here.
 *
 * Filenames simply pad out to 30 characters with spaces, so the only
 * "invalid" character is a trailing space.  Because we're using C-style
 * strings, we implicitly ban the use of '\0' in the name.
 */
/*static*/ bool DiskFSDOS33::IsValidFileName(const char* name)
{
    bool nonSpace = false;
    int len = 0;

    /* count letters, skipping control chars */
    while (*name != '\0') {
        char ch = *name++;

        if (ch < 0x20 || ch >= 0x7f || ch == ',')
            return false;
        if (ch != 0x20)
            nonSpace = true;
        len++;
    }
    if (len == 0 || len > A2FileDOS::kMaxFileName)
        return false;       // can't be empty, can't be huge
    if (!nonSpace)
        return false;       // must have one non-ctrl non-space char
    if (*(name-1) == ' ')
        return false;       // no trailing spaces

    return true;
}

/*
 * Determine whether "name" is a valid volume number.
 */
/*static*/ bool DiskFSDOS33::IsValidVolumeName(const char* name)
{
    long val;
    char* endp;

    val = strtol(name, &endp, 10);
    if (*endp != '\0' || val < 1 || val > 254)
        return false;

    return true;
}


/*
 * Put a DOS 3.2/3.3 filesystem image on the specified DiskImg.
 *
 * If "volName" is "DOS", a basic DOS image will be written to the first three
 * tracks of the disk, and the in-use map will be updated appropriately.
 *
 * It would seem at first glance that putting the volume number into the
 * volume name string would make the interface more consistent with the
 * rest of the filesystems.  The first glance is substantially correct, but
 * the DOS stuff has a separate "set volume number" interface already, used
 * to deal with the various locations where volume numbers can be stored
 * (2MG header, VTOC, sector address headers) in the various formats.
 *
 * So, instead of stuffing the volume number into "volName" and creating
 * some other path for specifying "add DOS image", I continue to use the
 * defined ways of setting the volume number and abuse "volName" slightly.
 */
DIError DiskFSDOS33::Format(DiskImg* pDiskImg, const char* volName)
{
    DIError dierr = kDIErrNone;
    uint8_t sctBuf[256];
    bool addDOS = false;

    if (pDiskImg->GetNumTracks() < kMinTracks ||
        pDiskImg->GetNumTracks() > kMaxTracks)
    {
        LOGI(" DOS33 can't format numTracks=%ld", pDiskImg->GetNumTracks());
        return kDIErrInvalidArg;
    }
    if (pDiskImg->GetNumSectPerTrack() != 13 &&
        pDiskImg->GetNumSectPerTrack() != 16 &&
        pDiskImg->GetNumSectPerTrack() != 32)
    {
        LOGI(" DOS33 can't format sectors=%d",
            pDiskImg->GetNumSectPerTrack());
        return kDIErrInvalidArg;
    }

    if (volName != NULL && strcmp(volName, "DOS") == 0) {
        if (pDiskImg->GetNumSectPerTrack() != 16 &&
            pDiskImg->GetNumSectPerTrack() != 13)
        {
            LOGI("NOTE: numSectPerTrack = %d, can't write DOS tracks",
                pDiskImg->GetNumSectPerTrack());
            return kDIErrInvalidArg;
        }
        addDOS = true;
    }

    /* set fpImg so calls that rely on it will work; we un-set it later */
    assert(fpImg == NULL);
    SetDiskImg(pDiskImg);

    LOGI(" DOS33 formatting disk image (sectorOrder=%d)",
        fpImg->GetSectorOrder());

    /* write DOS sectors */
    dierr = fpImg->OverrideFormat(fpImg->GetPhysicalFormat(),
                DiskImg::kFormatGenericDOSOrd, fpImg->GetSectorOrder());
    if (dierr != kDIErrNone)
        goto bail;

    /*
     * We should now zero out the disk blocks, but on a 32MB volume that can
     * take a little while.  The blocks are zeroed for us when a disk is
     * created, so this is really only needed if we're re-formatting an
     * existing disk.  CiderPress currently doesn't do that, so we're going
     * to skip it here.
     */
//  dierr = fpImg->ZeroImage();
    LOGI(" DOS33  (not zeroing blocks)");

    if (addDOS) {
        dierr = WriteDOSTracks(pDiskImg->GetNumSectPerTrack());
        if (dierr != kDIErrNone)
            goto bail;
    }

    /*
     * Set up the static fields in the VTOC.
     */
    dierr = LoadVolBitmap();
    if (dierr != kDIErrNone)
        goto bail;
    fVTOC[0x00] = 0x04;                             // (no reason)
    fVTOC[0x01] = kVTOCTrack;                       // first cat track
    fVTOC[0x02] = fpImg->GetNumSectPerTrack()-1;    // first cat sector
    fVTOC[0x03] = 3;                                // version
    if (fpImg->GetDOSVolumeNum() == DiskImg::kVolumeNumNotSet)
        fVTOC[0x06] = kDefaultVolumeNum;            // VTOC volume number
    else
        fVTOC[0x06] = (uint8_t) fpImg->GetDOSVolumeNum();
    fVTOC[0x27] = 122;                              // max T/S pairs
    fVTOC[0x30] = kVTOCTrack+1;                     // last alloc
    fVTOC[0x31] = 1;                                // ascending
    fVTOC[0x34] = (uint8_t)fpImg->GetNumTracks(); // #of tracks
    fVTOC[0x35] = fpImg->GetNumSectPerTrack();      // #of sectors
    fVTOC[0x36] = 0x00;                             // bytes/sector (lo)
    fVTOC[0x37] = 0x01;                             // bytes/sector (hi)
    if (pDiskImg->GetNumSectPerTrack() == 13) {
        // minor changes for DOS 3.2
        fVTOC[0x00] = 0x02;
        fVTOC[0x03] = 2;
    }

    dierr = SaveVolBitmap();
    FreeVolBitmap();
    if (dierr != kDIErrNone)
        goto bail;

    /*
     * Fill the sectors in the catalog track.
     */
    int sect;
    memset(sctBuf, 0, sizeof(sctBuf));
    sctBuf[0x01] = kVTOCTrack;
    for (sect = fpImg->GetNumSectPerTrack()-1; sect > 1; sect--) {
        sctBuf[0x02] = sect-1;

        dierr = fpImg->WriteTrackSector(kVTOCTrack, sect, sctBuf);
        if (dierr != kDIErrNone)
            goto bail;
    }

    /*
     * Generate the initial block usage map.  The only entries in use are
     * right at the start of the disk.
     */
    CreateEmptyBlockMap(addDOS);

    /* check our work, and set some object fields, by reading what we wrote */
    dierr = ReadVTOC();
    if (dierr != kDIErrNone) {
        LOGI(" GLITCH: couldn't read header we just wrote (err=%d)", dierr);
        goto bail;
    }

    /* don't do this -- assume they're going to call Initialize() later */
    //ScanVolBitmap();

bail:
    SetDiskImg(NULL);    // shouldn't really be set by us
    return dierr;
}

/*
 * Write a DOS image into tracks 0-2.
 *
 * This takes the number of sectors per track as an argument so we can figure
 * out which version of DOS to write.  This probably ought to be an enum so
 * we can specify various versions of DOS.
 */
DIError DiskFSDOS33::WriteDOSTracks(int sectPerTrack)
{
    DIError dierr = kDIErrNone;
    long track, sector;
    const uint8_t* buf = gDOS33Tracks;

    if (sectPerTrack == 13) {
        LOGI("  DOS33 writing DOS 3.3 tracks");
        buf = gDOS32Tracks;

        for (track = 0; track < 3; track++) {
            for (sector = 0; sector < 13; sector++) {
                dierr = fpImg->WriteTrackSector(track, sector, buf);
                if (dierr != kDIErrNone)
                    goto bail;
                buf += kSctSize;
            }
        }
    } else if (sectPerTrack == 16) {
        LOGI("  DOS33 writing DOS 3.3 tracks");
        buf = gDOS33Tracks;

        // this should be used for 32-sector disks

        for (track = 0; track < 3; track++) {
            for (sector = 0; sector < 16; sector++) {
                dierr = fpImg->WriteTrackSector(track, sector, buf);
                if (dierr != kDIErrNone)
                    goto bail;
                buf += kSctSize;
            }
        }
    } else {
        LOGI("  DOS33 *not* writing DOS tracks to %d-sector disk",
            sectPerTrack);
        assert(false);
    }

bail:
    return dierr;
}

/*
 * Normalize a DOS 3.3 path.  Used when adding files from DiskArchive.
 * The path may contain subdirectory components, which we need to strip away.
 *
 * "*pNormalizedBufLen" is used to pass in the length of the buffer and
 * pass out the length of the string (should the buffer prove inadequate).
 */
DIError DiskFSDOS33::NormalizePath(const char* path, char fssep,
    char* normalizedBuf, int* pNormalizedBufLen)
{
    DIError dierr = kDIErrNone;
    char tmpBuf[A2FileDOS::kMaxFileName+1];
    int len;

    DoNormalizePath(path, fssep, tmpBuf);
    len = strlen(tmpBuf)+1;

    if (*pNormalizedBufLen < len)
        dierr = kDIErrDataOverrun;
    else
        strcpy(normalizedBuf, tmpBuf);
    *pNormalizedBufLen = len;

    return dierr;
}

/*
 * Normalize a DOS 3.3 pathname.  Lower case becomes upper case, control
 * characters and high ASCII get stripped, and ',' becomes '_'.
 *
 * "outBuf" must be able to hold kMaxFileName+1 characters.
 */
void DiskFSDOS33::DoNormalizePath(const char* name, char fssep, char* outBuf)
{
    char* outp = outBuf;
    const char* cp;

    /* throw out leading pathname, if any */
    if (fssep != '\0') {
        cp = strrchr(name, fssep);
        if (cp != NULL)
            name = cp+1;
    }

    while (*name != '\0' && (outp - outBuf) <= A2FileDOS::kMaxFileName) {
        if (*name >= 0x20 && *name < 0x7f) {
            if (*name == ',')
                *outp = '_';
            else
                *outp = toupper(*name);

            outp++;
        }
        name++;
    }
    *outp = '\0';

    if (*outBuf == '\0') {
        /* nothing left */
        strcpy(outBuf, "BLANK");
    }
}

/*
 * Create a file on a DOS 3.2/3.3 disk.
 *
 * The file will be created with an empty T/S list.
 *
 * It is not possible to set the aux type here.  Aux types only apply to 'B'
 * files, and since they're stored in the first data sector (which we don't
 * create), there's nowhere to put it.  We stuff it into the aux type value
 * in the linear file list, on the assumption that somebody will come along
 * and politely Write to the file, even if it's zero bytes long.
 *
 * (Technically speaking, setting the file type here is bogus, because a
 * 'B' file with no data sectors is invalid.  However, we don't want to
 * handle arbitrary changes later -- switching from 'T' to 'B' requires
 * either rewriting the entire file, or confusing the user by changing the
 * type without adjusting the first 4 bytes -- so we set it now.  It's also
 * helpful to set it now because the Write routine needs to know how many
 * bytes offset from the start of the file it needs to be.  We could avoid
 * most of this weirdness by just going ahead and allocating the first
 * sector of the file now, and modifying the Write() function to understand
 * that the first block is already there.  Need to do that someday.)
 */
DIError DiskFSDOS33::CreateFile(const CreateParms* pParms,  A2File** ppNewFile)
{
    DIError dierr = kDIErrNone;
    const bool createUnique = (GetParameter(kParm_CreateUnique) != 0);
    char normalName[A2FileDOS::kMaxFileName+1];
//  char storageName[A2FileDOS::kMaxFileName+1];
    A2FileDOS::FileType fileType;
    A2FileDOS* pNewFile = NULL;

    if (fpImg->GetReadOnly())
        return kDIErrAccessDenied;
    if (!fDiskIsGood)
        return kDIErrBadDiskImage;

    assert(pParms != NULL);
    assert(pParms->pathName != NULL);
    assert(pParms->storageType == A2FileProDOS::kStorageSeedling);
    LOGI(" DOS33 ---v--- CreateFile '%s'", pParms->pathName);

    *ppNewFile = NULL;

    DoNormalizePath(pParms->pathName, pParms->fssep, normalName);

    /*
     * See if the file already exists.
     *
     * If "create unique" is set, we append digits until the name doesn't
     * match any others.  The name will be modified in place.
     */
    if (createUnique) {
        MakeFileNameUnique(normalName);
    } else {
        if (GetFileByName(normalName) != NULL) {
            LOGI(" DOS33 create: normalized name '%s' already exists",
                normalName);
            dierr = kDIErrFileExists;
            goto bail;
        }
    }

    fileType = A2FileDOS::ConvertFileType(pParms->fileType, 0);

    /*
     * Allocate a directory entry and T/S list.
     */
    uint8_t sctBuf[kSctSize];
    TrackSector catSect;
    TrackSector tsSect;
    int catEntry;
    A2FileDOS* pPrevEntry;

    dierr = LoadVolBitmap();
    if (dierr != kDIErrNone)
        goto bail;

    /* allocate a sector for the T/S list, and zero it out */
    dierr = AllocSector(&tsSect);
    if (dierr != kDIErrNone)
        goto bail;

    memset(sctBuf, 0, kSctSize);
    dierr = fpImg->WriteTrackSector(tsSect.track, tsSect.sector, sctBuf);
    if (dierr != kDIErrNone)
        goto bail;

    /*
     * Find the first free catalog entry.  Also returns a pointer to the
     * previous entry.
     */
    dierr = GetFreeCatalogEntry(&catSect, &catEntry, sctBuf, &pPrevEntry);
    if (dierr != kDIErrNone) {
        LOGI("DOS unable to find an empty entry in the catalog");
        goto bail;
    }
    LOGI(" DOS found free catalog entry T=%d S=%d ent=%d prev=0x%08lx",
        catSect.track, catSect.sector, catEntry, (long) pPrevEntry);

    /* create the new dir entry at the specified location */
    CreateDirEntry(sctBuf, catEntry, normalName, &tsSect,
        (uint8_t) fileType, pParms->access);

    /*
     * Flush everything to disk.
     */
    dierr = fpImg->WriteTrackSector(catSect.track, catSect.sector, sctBuf);
    if (dierr != kDIErrNone)
        goto bail;

    dierr = SaveVolBitmap();
    if (dierr != kDIErrNone)
        goto bail;

    /*
     * Create a new entry for our file list.
     */
    pNewFile = new A2FileDOS(this);
    if (pNewFile == NULL) {
        dierr = kDIErrMalloc;
        goto bail;
    }
    pNewFile->fTSListTrack = tsSect.track;
    pNewFile->fTSListSector = tsSect.sector;
    pNewFile->fLengthInSectors = 1;
    pNewFile->fLocked = false;
    strcpy(pNewFile->fFileName, normalName);
    pNewFile->fFileType = fileType;

    pNewFile->fCatTS.track = catSect.track;
    pNewFile->fCatTS.sector = catSect.sector;
    pNewFile->fCatEntryNum = catEntry;

    pNewFile->fAuxType = (uint16_t) pParms->auxType;
    pNewFile->fDataOffset = 0;
    switch (pNewFile->fFileType) {
    case A2FileDOS::kTypeInteger:
        pNewFile->fDataOffset = 2;
        break;
    case A2FileDOS::kTypeApplesoft:
        pNewFile->fDataOffset = 2;
        pNewFile->fAuxType = 0x0801;
        break;
    case A2FileDOS::kTypeBinary:
        pNewFile->fDataOffset = 4;
        break;
    default:
        break;
    }
    pNewFile->fLength = 0;
    pNewFile->fSparseLength = 0;

    /*
     * Insert it in the proper place, so that the order of the files matches
     * the order of entries in the catalog.
     */
    InsertFileInList(pNewFile, pPrevEntry);

    *ppNewFile = pNewFile;
    pNewFile = NULL;

bail:
    delete pNewFile;
    FreeVolBitmap();
    return dierr;
}

/*
 * Make the name pointed to by "fileName" unique.  The name should already
 * be FS-normalized, and be in a buffer that can hold at least kMaxFileName+1
 * bytes.
 *
 * (This is nearly identical to the code in the ProDOS implementation.  I'd
 * like to make it a general DiskFS function, but making the loop condition
 * work requires setting up callbacks, which isn't hard here but is a little
 * annoying in ProDOS because of the subdir buffer.  So it's cut & paste
 * for now.)
 *
 * Returns an error on failure, which should be impossible.
 */
DIError DiskFSDOS33::MakeFileNameUnique(char* fileName)
{
    assert(fileName != NULL);
    assert(strlen(fileName) <= A2FileDOS::kMaxFileName);

    if (GetFileByName(fileName) == NULL)
        return kDIErrNone;

    LOGI(" DOS   found duplicate of '%s', making unique", fileName);

    int nameLen = strlen(fileName);
    int dotOffset=0, dotLen=0;
    char dotBuf[kMaxExtensionLen+1];

    /* ensure the result will be null-terminated */
    memset(fileName + nameLen, 0, (A2FileDOS::kMaxFileName - nameLen) +1);

    /*
     * If this has what looks like a filename extension, grab it.  We want
     * to preserve ".gif", ".c", etc.
     */
    const char* cp = strrchr(fileName, '.');
    if (cp != NULL) {
        int tmpOffset = cp - fileName;
        if (tmpOffset > 0 && nameLen - tmpOffset <= kMaxExtensionLen) {
            LOGI("  DOS   (keeping extension '%s')", cp);
            assert(strlen(cp) <= kMaxExtensionLen);
            strcpy(dotBuf, cp);
            dotOffset = tmpOffset;
            dotLen = nameLen - dotOffset;
        }
    }

    const int kMaxDigits = 999;
    int digits = 0;
    int digitLen;
    int copyOffset;
    char digitBuf[4];
    do {
        if (digits == kMaxDigits)
            return kDIErrFileExists;
        digits++;

        /* not the most efficient way to do this, but it'll do */
        sprintf(digitBuf, "%d", digits);
        digitLen = strlen(digitBuf);
        if (nameLen + digitLen > A2FileDOS::kMaxFileName)
            copyOffset = A2FileDOS::kMaxFileName - dotLen - digitLen;
        else
            copyOffset = nameLen - dotLen;
        memcpy(fileName + copyOffset, digitBuf, digitLen);
        if (dotLen != 0)
            memcpy(fileName + copyOffset + digitLen, dotBuf, dotLen);
    } while (GetFileByName(fileName) != NULL);

    LOGI(" DOS  converted to unique name: %s", fileName);

    return kDIErrNone;
}

/*
 * Find the first free entry in the catalog.
 *
 * Also returns an A2File pointer for the previous entry in the catalog.
 *
 * The contents of the catalog sector will be in "sctBuf".
 */
DIError DiskFSDOS33::GetFreeCatalogEntry(TrackSector* pCatSect, int* pCatEntry,
    uint8_t* sctBuf, A2FileDOS** ppPrevEntry)
{
    DIError dierr = kDIErrNone;
    uint8_t* pEntry;
    int sct, ent;
    bool found = false;

    for (sct = 0; sct < kMaxCatalogSectors; sct++) {
        if (fCatalogSectors[sct].track == 0 &&
            fCatalogSectors[sct].sector == 0)
        {
            /* end of list reached */
            LOGI("DOS catalog is full");
            dierr = kDIErrVolumeDirFull;
            goto bail;
        }
        dierr = fpImg->ReadTrackSector(fCatalogSectors[sct].track,
                    fCatalogSectors[sct].sector, sctBuf);
        if (dierr != kDIErrNone)
            goto bail;

        pEntry = &sctBuf[kCatalogEntryOffset];
        for (ent = 0; ent < kCatalogEntriesPerSect; ent++) {
            if (pEntry[0x00] == 0x00 || pEntry[0x00] == kEntryDeleted) {
                /* winner! */
                *pCatSect = fCatalogSectors[sct];
                *pCatEntry = ent;
                found = true;
                break;
            }

            pEntry += kCatalogEntrySize;
        }

        if (found)
            break;
    }

    if (sct == kMaxCatalogSectors) {
        /* didn't find anything, assume the disk is full */
        dierr = kDIErrVolumeDirFull;
        // fall through to "bail"
    } else {
        /* figure out what the previous entry is */
        TrackSector prevTS;
        int prevEntry;

        if (*pCatEntry != 0) {
            prevTS = *pCatSect;
            prevEntry = *pCatEntry -1;
        } else if (sct != 0) {
            prevTS = fCatalogSectors[sct-1];
            prevEntry = kCatalogEntriesPerSect-1;
        } else {
            /* disk was empty; there's no previous entry */
            prevTS.track = 0;
            prevTS.sector = 0;
            prevEntry = -1;
        }

        /* now find it in the linear file list */
        *ppPrevEntry = NULL;
        if (prevEntry >= 0) {
            A2FileDOS* pFile = (A2FileDOS*) GetNextFile(NULL);
            while (pFile != NULL) {
                if (pFile->fCatTS.track == prevTS.track &&
                    pFile->fCatTS.sector == prevTS.sector &&
                    pFile->fCatEntryNum == prevEntry)
                {
                    *ppPrevEntry = pFile;
                    break;
                }
                pFile = (A2FileDOS*) GetNextFile(pFile);
            }
            assert(*ppPrevEntry != NULL);
        }
    }

bail:
    return dierr;
}

/*
 * Fill out the catalog entry in the location specified.
 */
void DiskFSDOS33::CreateDirEntry(uint8_t* sctBuf, int catEntry,
    const char* fileName, TrackSector* pTSSect, uint8_t fileType,
    int access)
{
    char highName[A2FileDOS::kMaxFileName+1];
    uint8_t* pEntry;

    pEntry = GetCatalogEntryPtr(sctBuf, catEntry);
    if (pEntry[0x00] != 0x00 && pEntry[0x00] != kEntryDeleted) {
        /* somebody screwed up */
        assert(false);
        return;
    }

    A2FileDOS::MakeDOSName(highName, fileName);

    pEntry[0x00] = pTSSect->track;
    pEntry[0x01] = pTSSect->sector;
    pEntry[0x02] = fileType;
    if ((access & A2FileProDOS::kAccessWrite) == 0)
        pEntry[0x02] |= (uint8_t) A2FileDOS::kTypeLocked;
    memcpy(&pEntry[0x03], highName, A2FileDOS::kMaxFileName);
    PutShortLE(&pEntry[0x21], 1);       // assume file is 1 sector long
}

/*
 * Delete a file.
 *
 * This entails freeing up the allocated sectors and changing a byte in
 * the directory entry.  We then remove it from the DiskFS file list.
 */
DIError DiskFSDOS33::DeleteFile(A2File* pGenericFile)
{
    DIError dierr = kDIErrNone;
    A2FileDOS* pFile = (A2FileDOS*) pGenericFile;
    TrackSector* tsList = NULL;
    TrackSector* indexList = NULL;
    int tsCount, indexCount;
    uint8_t sctBuf[kSctSize];
    uint8_t* pEntry;

    if (pGenericFile == NULL) {
        assert(false);
        return kDIErrInvalidArg;
    }

    if (fpImg->GetReadOnly())
        return kDIErrAccessDenied;
    if (!fDiskIsGood)
        return kDIErrBadDiskImage;
    if (pGenericFile->IsFileOpen())
        return kDIErrFileOpen;

    LOGI("    Deleting '%s'", pFile->GetPathName());

    /*
     * Update the block usage map.  Nothing is permanent until we flush
     * the data to disk.
     */
    dierr = LoadVolBitmap();
    if (dierr != kDIErrNone)
        goto bail;

    dierr = pFile->LoadTSList(&tsList, &tsCount, &indexList, &indexCount);
    if (dierr != kDIErrNone) {
        LOGI("Failed loading TS lists while deleting '%s'",
            pFile->GetPathName());
        goto bail;
    }

    FreeTrackSectors(tsList, tsCount);
    FreeTrackSectors(indexList, indexCount);

    /*
     * Mark the entry as deleted.
     */
    dierr = fpImg->ReadTrackSector(pFile->fCatTS.track, pFile->fCatTS.sector,
                sctBuf);
    if (dierr != kDIErrNone)
        goto bail;
    pEntry = GetCatalogEntryPtr(sctBuf, pFile->fCatEntryNum);
    assert(pEntry[0x00] != 0x00 && pEntry[0x00] != kEntryDeleted);
    pEntry[0x00] = kEntryDeleted;
    dierr = fpImg->WriteTrackSector(pFile->fCatTS.track, pFile->fCatTS.sector,
                sctBuf);
    if (dierr != kDIErrNone)
        goto bail;

    /*
     * Save our updated copy of the volume bitmap to disk.
     */
    dierr = SaveVolBitmap();
    if (dierr != kDIErrNone)
        goto bail;

    /*
     * Remove the A2File* from the list.
     */
    DeleteFileFromList(pFile);

bail:
    FreeVolBitmap();
    delete[] tsList;
    delete[] indexList;
    return dierr;
}

/*
 * Mark all of the track/sector entries in "pList" as free.
 */
void DiskFSDOS33::FreeTrackSectors(TrackSector* pList, int count)
{
    VolumeUsage::ChunkState cstate;
    int i;

    cstate.isUsed = false;
    cstate.isMarkedUsed = false;
    cstate.purpose = VolumeUsage::kChunkPurposeUnknown;

    for (i = 0; i < count; i++) {
        if (pList[i].track == 0 && pList[i].sector == 0)
            continue;       // sparse file

        if (!GetSectorUseEntry(pList[i].track, pList[i].sector)) {
            LOGI("WARNING: freeing unallocated sector T=%d S=%d",
                pList[i].track, pList[i].sector);
            assert(false);  // impossible unless disk is "damaged"
        }
        SetSectorUseEntry(pList[i].track, pList[i].sector, false);

        fVolumeUsage.SetChunkState(pList[i].track, pList[i].sector, &cstate);
    }
}

/*
 * Rename a file.
 *
 * "newName" must already be normalized.
 */
DIError DiskFSDOS33::RenameFile(A2File* pGenericFile, const char* newName)
{
    DIError dierr = kDIErrNone;
    A2FileDOS* pFile = (A2FileDOS*) pGenericFile;
    char normalName[A2FileDOS::kMaxFileName+1];
    char dosName[A2FileDOS::kMaxFileName+1];
    uint8_t sctBuf[kSctSize];
    uint8_t* pEntry;

    if (pFile == NULL || newName == NULL)
        return kDIErrInvalidArg;
    if (!IsValidFileName(newName))
        return kDIErrInvalidArg;
    if (fpImg->GetReadOnly())
        return kDIErrAccessDenied;
    if (!fDiskIsGood)
        return kDIErrBadDiskImage;

    LOGI(" DOS renaming '%s' to '%s'", pFile->GetPathName(), newName);

    /*
     * Update the disk catalog entry.
     */
    dierr = fpImg->ReadTrackSector(pFile->fCatTS.track, pFile->fCatTS.sector,
                sctBuf);
    if (dierr != kDIErrNone)
        goto bail;

    pEntry = GetCatalogEntryPtr(sctBuf, pFile->fCatEntryNum);

    DoNormalizePath(newName, '\0', normalName);
    A2FileDOS::MakeDOSName(dosName, normalName);
    memcpy(&pEntry[0x03], dosName, A2FileDOS::kMaxFileName);

    dierr = fpImg->WriteTrackSector(pFile->fCatTS.track, pFile->fCatTS.sector,
                sctBuf);
    if (dierr != kDIErrNone)
        goto bail;

    /*
     * Update our internal copy.
     */
    char storedName[A2FileDOS::kMaxFileName+1];
    strcpy(storedName, dosName);
    LowerASCII((uint8_t*)storedName, A2FileDOS::kMaxFileName);
    A2FileDOS::TrimTrailingSpaces(storedName);

    strcpy(pFile->fFileName, storedName);

bail:
    return dierr;
}

/*
 * Set the file's attributes.
 *
 * We allow the file to be locked or unlocked, and we allow the file type
 * to be changed.  We don't try to rewrite the file if they're changing to or
 * from a format with embedded data (e.g. BAS or BIN); instead, we just
 * change the type letter.  We do need to re-evaluate the end-of-file
 * value afterward.
 *
 * Changing the aux type is only allowed for BIN files.
 */
DIError DiskFSDOS33::SetFileInfo(A2File* pGenericFile, uint32_t fileType,
    uint32_t auxType, uint32_t accessFlags)
{
    DIError dierr = kDIErrNone;
    A2FileDOS* pFile = (A2FileDOS*) pGenericFile;
    TrackSector* tsList = NULL;
    int tsCount;
    bool nowLocked;
    bool typeChanged;

    if (pFile == NULL)
        return kDIErrInvalidArg;
    if (fpImg->GetReadOnly())
        return kDIErrAccessDenied;

    LOGI("DOS SetFileInfo '%s' type=0x%02x aux=0x%04x access=0x%02x",
        pFile->GetPathName(), fileType, auxType, accessFlags);

    /*
     * We can ignore the file/aux type, or we can verify that they're not
     * trying to change it.  The latter is a little more work but makes
     * the API a little more communicative.
     */
    if (!A2FileDOS::IsValidType(fileType)) {
        LOGI("DOS SetFileInfo invalid file type");
        dierr = kDIErrInvalidArg;
        goto bail;
    }
    if (auxType != pFile->GetAuxType() && fileType != 0x06) {
        /* this only makes sense for BIN files */
        LOGI("DOS SetFileInfo aux type mismatch; ignoring");
        //dierr = kDIErrNotSupported;
        //goto bail;
    }

    nowLocked = (accessFlags & A2FileProDOS::kAccessWrite) == 0;
    typeChanged = (fileType != pFile->GetFileType());

    /*
     * Update the file type and locked status, if necessary.
     */
    if (nowLocked != pFile->fLocked || typeChanged) {
        A2FileDOS::FileType newFileType;
        uint8_t sctBuf[kSctSize];
        uint8_t* pEntry;

        LOGI("Updating file '%s'", pFile->GetPathName());

        dierr = fpImg->ReadTrackSector(pFile->fCatTS.track, pFile->fCatTS.sector,
                    sctBuf);
        if (dierr != kDIErrNone)
            goto bail;

        pEntry = GetCatalogEntryPtr(sctBuf, pFile->fCatEntryNum);

        newFileType = A2FileDOS::ConvertFileType(fileType, 0);
        pEntry[0x02] = (uint8_t) newFileType;
        if (nowLocked)
            pEntry[0x02] |= 0x80;

        dierr = fpImg->WriteTrackSector(pFile->fCatTS.track, pFile->fCatTS.sector,
                    sctBuf);
        if (dierr != kDIErrNone)
            goto bail;

        /* update our local copy */
        pFile->fLocked = nowLocked;
    }

    if (!typeChanged && auxType == pFile->GetAuxType()) {
        /* only the locked status has changed; skip the rest */
        goto bail;
    }

    /*
     * If the file has type BIN (either because it was before and we left it
     * alone, or we changed it to BIN), we need to figure out what the aux
     * type should be.  There are two situations:
     *
     * (1) User specified an aux type.  If the aux type passed in doesn't match
     *  what's in the A2FileDOS structure, we assume they meant to change it.
     * (2) User didn't specify an aux type change.  If the file was BIN before,
     *  we don't need to do anything, but if it was just changed to BIN then
     *  we need to extract the aux type from the first sector of the file.
     *
     * There's also a 3rd situation: they changed the aux type for a non-BIN
     * file.  This should have been blocked earlier.
     *
     * On top of all this, if we changed the file type at all then we need to
     * re-scan the file length and "data offset" value.
     */
    uint16_t newAuxType;
    newAuxType = (uint16_t) auxType;

    dierr = pFile->LoadTSList(&tsList, &tsCount);
    if (dierr != kDIErrNone) {
        LOGI(" DOS SFI: unable to load TS list (err=%d)", dierr);
        goto bail;
    }

    if (fileType == 0x06 && tsCount > 0) {
        uint8_t sctBuf[kSctSize];

        dierr = fpImg->ReadTrackSector(tsList[0].track,
                    tsList[0].sector, sctBuf);
        if (dierr != kDIErrNone) {
            LOGI("DOS SFI: unable to get first sector of file");
            goto bail;
        }

        if (auxType == pFile->GetAuxType()) {
            newAuxType = GetShortLE(&sctBuf[0x00]);
            LOGI("  Aux type not changed, extracting from file (0x%04x)",
                newAuxType);
        } else {
            LOGI("  Aux type changed (to 0x%04x), changing file",
                newAuxType);

            PutShortLE(&sctBuf[0x00], newAuxType);
            dierr = fpImg->WriteTrackSector(tsList[0].track,
                        tsList[0].sector, sctBuf);
            if (dierr != kDIErrNone) {
                LOGI("DOS SFI: unable to write first sector of file");
                goto bail;
            }
        }
    } else {
        /* not BIN or file has no sectors */
        if (pFile->fFileType == A2FileDOS::kTypeApplesoft)
            newAuxType = 0x0801;
        else
            newAuxType = 0x0000;
    }

    /* update our local copy */
    pFile->fFileType = A2FileDOS::ConvertFileType(fileType, 0);
    pFile->fAuxType = newAuxType;

    /*
     * Recalculate the file's length and "data offset".  This may also mark
     * the file as "suspicious".  We wouldn't be here if the file was
     * suspicious when we opened the disk image -- the image would have
     * been marked read-only -- so if it's suspicious now, it's probably
     * from a previous file type change attempt in the current session.
     * Clear the flag so it doesn't "stick".
     */
    pFile->ResetQuality();
    (void) ComputeLength(pFile, tsList, tsCount);

bail:
    delete[] tsList;
    return dierr;
}

/*
 * Change the disk volume name (number).
 *
 * We can't change the 2MG header, and we can't change the values embedded
 * in the sector headers, so all we do is change the VTOC entry.
 */
DIError DiskFSDOS33::RenameVolume(const char* newName)
{
    DIError dierr = kDIErrNone;
    uint8_t sctBuf[kSctSize];
    long newNumber;
    char* endp;

    if (!IsValidVolumeName(newName))
        return kDIErrInvalidArg;
    if (fpImg->GetReadOnly())
        return kDIErrAccessDenied;

    // convert the number; we already ascertained that it's valid
    newNumber = strtol(newName, &endp, 10);

    dierr = fpImg->ReadTrackSector(kVTOCTrack, kVTOCSector, sctBuf);
    if (dierr != kDIErrNone)
        goto bail;

    sctBuf[0x06] = (uint8_t) newNumber;

    dierr = fpImg->WriteTrackSector(kVTOCTrack, kVTOCSector, sctBuf);
    if (dierr != kDIErrNone)
        goto bail;

    fVTOCVolumeNumber = newNumber;
    UpdateVolumeNum();

bail:
    return dierr;
}


/*
 * ===========================================================================
 *      A2FileDOS
 * ===========================================================================
 */

/*
 * Constructor.
 */
A2FileDOS::A2FileDOS(DiskFS* pDiskFS) : A2File(pDiskFS)
{
    fTSListTrack = -1;
    fTSListSector = -1;
    fLengthInSectors = 0;
    fLocked = false;
    fFileName[0] = '\0';
    fFileType = kTypeUnknown;

    fCatTS.track = fCatTS.sector = 0;
    fCatEntryNum = -1;

    fAuxType = 0;
    fDataOffset = 0;
    fLength = -1;
    fSparseLength = -1;

    fpOpenFile = NULL;
}

/*
 * Destructor.  Make sure an "open" file gets "closed".
 */
A2FileDOS::~A2FileDOS(void)
{
    delete fpOpenFile;
}


/*
 * Convert the filetype enum to a ProDOS type.
 *
 * Remember that the DOS filetype field is actually a bit field, so we need
 * to handle situations where more than one bit is set.
 *
 * Ideally this is a reversible transformation, so files copied to ProDOS
 * volumes can be copied back to DOS with no loss of information.  The reverse
 * is *not* true, because of file type reduction and the potential loss of
 * accurate file length info.
 *
 * I'm not entirely certain about the conversion of 'R' to REL, largely
 * because I can't find any information on the REL format.  However, Copy ][+
 * does convert to REL, and the Binary ][ standard says I should as well.
 */
uint32_t A2FileDOS::GetFileType(void) const
{
    long retval;

    switch (fFileType) {
    case kTypeText:         retval = 0x04;  break;  // TXT
    case kTypeInteger:      retval = 0xfa;  break;  // INT
    case kTypeApplesoft:    retval = 0xfc;  break;  // BAS
    case kTypeBinary:       retval = 0x06;  break;  // BIN
    case kTypeS:            retval = 0xf2;  break;  // $f2
    case kTypeReloc:        retval = 0xfe;  break;  // REL
    case kTypeA:            retval = 0xf3;  break;  // $f3
    case kTypeB:            retval = 0xf4;  break;  // $f4
    case kTypeUnknown:
    default:
        retval = 0x00;      // NON
        break;
    }

    return retval;
}

/*
 * Convert a ProDOS 8 file type to its DOS equivalent.
 *
 * We need to know the file length because files over 64K can't fit into
 * DOS A/I/B files.  Text files can be as long as they want, and the
 * other types don't have a length word defined, so they're fine.
 *
 * We can't just convert them later, because by that point they've already
 * got a 2-byte or 4-byte header reserved.
 *
 * Because we don't generally know the eventual length of the file at
 * the time we're creating it, this doesn't work nearly as well as could
 * be hoped.  We can make life a little less confusing for the caller by
 * using type 'S' for any unknown type.
 */
/*static*/ A2FileDOS::FileType A2FileDOS::ConvertFileType(long prodosType,
    di_off_t fileLen)
{
    const long kMaxBinary = 65535;
    FileType newType;

    switch (prodosType) {
    case 0xb0:      newType = kTypeText;        break;  // SRC
    case 0x04:      newType = kTypeText;        break;  // TXT
    case 0xfa:      newType = kTypeInteger;     break;  // INT
    case 0xfc:      newType = kTypeApplesoft;   break;  // BAS
    case 0x06:      newType = kTypeBinary;      break;  // BIN
    case 0xf2:      newType = kTypeS;           break;  // $f2
    case 0xfe:      newType = kTypeReloc;       break;  // REL
    case 0xf3:      newType = kTypeA;           break;  // $f3
    case 0xf4:      newType = kTypeB;           break;  // $f4
    default:        newType = kTypeS;           break;
    }

    if (fileLen > kMaxBinary &&
        (newType == kTypeInteger || newType == kTypeApplesoft ||
        newType == kTypeBinary))
    {
        LOGI("  DOS setting type for large A/I/B file to S");
        newType = kTypeS;
    }

    return newType;
}

/*
 * Determine whether the specified type has a valid DOS mapping.
 */
/*static*/ bool A2FileDOS::IsValidType(long prodosType)
{
    switch (prodosType) {
    case 0xb0:  // SRC
    case 0x04:  // TXT
    case 0xfa:  // INT
    case 0xfc:  // BAS
    case 0x06:  // BIN
    case 0xf2:  // $f2
    case 0xfe:  // REL
    case 0xf3:  // $f3
    case 0xf4:  // $f4
        return true;
    default:
        return false;
    }
}

/*
 * Match the ProDOS equivalents of "locked" and "unlocked".
 */
uint32_t A2FileDOS::GetAccess(void) const
{
    if (fLocked)
        return DiskFS::kFileAccessLocked;   // 0x01 read
    else
        return DiskFS::kFileAccessUnlocked; // 0xc3 read/write/rename/destroy
}

/*
 * "Fix" a DOS3.3 filename.  Convert DOS-ASCII to normal ASCII, and strip
 * trailing spaces.
 */
void A2FileDOS::FixFilename(void)
{
    DiskFSDOS33::LowerASCII((uint8_t*)fFileName, kMaxFileName);
    TrimTrailingSpaces(fFileName);
}

/*
 * Trim the spaces off the end of a filename.
 *
 * Assumes the filename has already been converted to low ASCII.
 */
/*static*/ void A2FileDOS::TrimTrailingSpaces(char* filename)
{
    char* lastspc = filename + strlen(filename);

    assert(*lastspc == '\0');

    while (--lastspc) {
        if (*lastspc != ' ')
            break;
    }

    *(lastspc+1) = '\0';
}

/*
 * Encode a filename into high ASCII, padded out with spaces to
 * kMaxFileName chars.  Lower case is converted to upper case.  This
 * does not filter out control characters or other chunk.
 *
 * "buf" must be able to hold kMaxFileName+1 chars.
 */
/*static*/ void A2FileDOS::MakeDOSName(char* buf, const char* name)
{
    for (int i = 0; i < kMaxFileName; i++) {
        if (*name == '\0')
            *buf++ = (char) 0xa0;
        else
            *buf++ = toupper(*name++) | 0x80;
    }
    *buf = '\0';
}


/*
 * Set up state for this file.
 */
DIError A2FileDOS::Open(A2FileDescr** ppOpenFile, bool readOnly,
    bool rsrcFork /*=false*/)
{
    DIError dierr = kDIErrNone;
    A2FDDOS* pOpenFile = NULL;

    if (!readOnly) {
        if (fpDiskFS->GetDiskImg()->GetReadOnly())
            return kDIErrAccessDenied;
        if (fpDiskFS->GetFSDamaged())
            return kDIErrBadDiskImage;
    }

    if (fpOpenFile != NULL) {
        dierr = kDIErrAlreadyOpen;
        goto bail;
    }

    if (rsrcFork)
        return kDIErrForkNotFound;

    pOpenFile = new A2FDDOS(this);

    dierr = LoadTSList(&pOpenFile->fTSList, &pOpenFile->fTSCount,
                &pOpenFile->fIndexList, &pOpenFile->fIndexCount);
    if (dierr != kDIErrNone) {
        LOGI("DOS33 unable to load TS for '%s' open", GetPathName());
        goto bail;
    }

    pOpenFile->fOffset = 0;
    pOpenFile->fOpenEOF = fLength;
    pOpenFile->fOpenSectorsUsed = fLengthInSectors;

    fpOpenFile = pOpenFile;     // add it to our single-member "open file set"
    *ppOpenFile = pOpenFile;
    pOpenFile = NULL;

bail:
    delete pOpenFile;
    return dierr;
}

/*
 * Dump the contents of an A2FileDOS.
 */
void A2FileDOS::Dump(void) const
{
    LOGI("A2FileDOS '%s'", fFileName);
    LOGI("  TS T=%-2d S=%-2d", fTSListTrack, fTSListSector);
    LOGI("  Cat T=%-2d S=%-2d", fCatTS.track, fCatTS.sector);
    LOGI("  type=%d lck=%d slen=%d", fFileType, fLocked, fLengthInSectors);
    LOGI("  auxtype=0x%04x length=%ld",
        fAuxType, (long) fLength);
}


/*
 * Load the T/S list for this file.
 *
 * A single T/S sector holds 122 entries, enough to store a 30.5K file.
 * It's very unlikely that a file will need more than two, although it's
 * possible for a random-access text file to have a very large number of
 * entries.
 *
 * If "pIndexList" and "pIndexCount" are non-NULL, the list of index blocks is
 * also loaded.
 *
 * It's entirely possible to get a large T/S list back that is filled
 * entirely with zeroes.  This can happen if we have a large set of T/S
 * index sectors that are all zero.  We have to leave space for them so
 * that the Write function can use the existing allocated index blocks.
 *
 * THOUGHT: we may want to use the file type to tighten this up a bit.
 * For example, we're currently very careful around random-access text
 * files, but if the file doesn't have type 'T' then random access is
 * impossible.  Currently this isn't a problem, but for e.g. T/S lists
 * with garbage at the end would could deal with the problem more generally.
 */
DIError A2FileDOS::LoadTSList(TrackSector** pTSList, int* pTSCount,
    TrackSector** pIndexList, int* pIndexCount)
{
    DIError dierr = kDIErrNone;
    DiskImg* pDiskImg;
    const int kDefaultTSAlloc = 2;
    const int kDefaultIndexAlloc = 8;
    TrackSector* tsList = NULL;
    TrackSector* indexList = NULL;
    int tsCount, tsAlloc;
    int indexCount, indexAlloc;
    uint8_t sctBuf[kSctSize];
    int track, sector, iterations;

    LOGI("--- DOS loading T/S list for '%s'", GetPathName());

    /* over-alloc for small files to reduce reallocs */
    tsAlloc = kMaxTSPairs * kDefaultTSAlloc;
    tsList = new TrackSector[tsAlloc];
    tsCount = 0;

    indexAlloc = kDefaultIndexAlloc;
    indexList = new TrackSector[indexAlloc];
    indexCount = 0;

    if (tsList == NULL || indexList == NULL) {
        dierr = kDIErrMalloc;
        goto bail;
    }

    assert(fpDiskFS != NULL);
    pDiskImg = fpDiskFS->GetDiskImg();
    assert(pDiskImg != NULL);

    /* get the first T/S sector for this file */
    track = fTSListTrack;
    sector = fTSListSector;
    if (track >= pDiskImg->GetNumTracks() ||
        sector >= pDiskImg->GetNumSectPerTrack())
    {
        LOGI(" DOS33 invalid initial T/S %d,%d in '%s'", track, sector,
            fFileName);
        dierr = kDIErrBadFile;
        goto bail;
    }

    /*
     * Run through the set of t/s pairs.
     */
    iterations = 0;
    do {
        uint16_t sectorOffset;
        int lastNonZero;

        /*
         * Add the current T/S sector to the index list.
         */
        if (indexCount == indexAlloc) {
            LOGI("+++ expanding index list");
            TrackSector* newList;
            indexAlloc += kDefaultIndexAlloc;
            newList = new TrackSector[indexAlloc];
            if (newList == NULL) {
                dierr = kDIErrMalloc;
                goto bail;
            }
            memcpy(newList, indexList, indexCount * sizeof(TrackSector));
            delete[] indexList;
            indexList = newList;
        }
        indexList[indexCount].track = track;
        indexList[indexCount].sector = sector;
        indexCount++;


        //LOGI("+++ scanning T/S at T=%d S=%d", track, sector);
        dierr = pDiskImg->ReadTrackSector(track, sector, sctBuf);
        if (dierr != kDIErrNone)
            goto bail;

        /* grab next track/sector */
        track = sctBuf[0x01];
        sector = sctBuf[0x02];
        sectorOffset = GetShortLE(&sctBuf[0x05]);

        /* if T/S link is bogus, whole sector is probably bad */
        if (track >= pDiskImg->GetNumTracks() ||
            sector >= pDiskImg->GetNumSectPerTrack())
        {
            // bogus T/S, mark file as damaged and stop
            LOGI(" DOS33 invalid T/S link %d,%d in '%s'", track, sector,
                GetPathName());
            dierr = kDIErrBadFile;
            goto bail;
        }
        if ((sectorOffset % kMaxTSPairs) != 0) {
            LOGI(" DOS33 invalid T/S header sector offset %u in '%s'",
                sectorOffset, GetPathName());
            // not fatal, just weird
        }

        /*
         * Make sure we have enough room to hold an entire sector full of
         * T/S pairs in the list.
         */
        if (tsCount + kMaxTSPairs > tsAlloc) {
            LOGI("+++ expanding ts list");
            TrackSector* newList;
            tsAlloc += kMaxTSPairs * kDefaultTSAlloc;
            newList = new TrackSector[tsAlloc];
            if (newList == NULL) {
                dierr = kDIErrMalloc;
                goto bail;
            }
            memcpy(newList, tsList, tsCount * sizeof(TrackSector));
            delete[] tsList;
            tsList = newList;
        }

        /*
         * Add the entries.  If there's another T/S list linked, we just
         * grab the entire sector.  If not, we grab every entry until the
         * last 0,0.  (Can't stop at the first (0,0), or we'll drop a
         * piece of a random access text file.)
         */
        dierr = ExtractTSPairs(sctBuf, &tsList[tsCount], &lastNonZero);
        if (dierr != kDIErrNone)
            goto bail;

        if (track != 0) {
            /* more T/S lists to come, so we keep all entries */
            tsCount += kMaxTSPairs;
        } else {
            /* this was the last one */
            if (lastNonZero == -1) {
                /* this is ALWAYS the case for a newly-created file */
                //LOGI(" DOS33 odd -- last T/S sector of '%s' was empty",
                //  GetPathName());
            }
            tsCount += lastNonZero +1;
        }

        iterations++;       // watch for infinite loops
    } while (!(track == 0 && sector == 0) && iterations < kMaxTSIterations);

    if (iterations == kMaxTSIterations) {
        dierr = kDIErrFileLoop;
        goto bail;
    }

    *pTSList = tsList;
    *pTSCount = tsCount;
    tsList = NULL;

    if (pIndexList != NULL) {
        *pIndexList = indexList;
        *pIndexCount = indexCount;
        indexList = NULL;
    }

bail:
    delete[] tsList;
    delete[] indexList;
    return dierr;
}

/*
 * Extract the track/sector pairs from the TS list in "sctBuf".  The entries
 * are copied to "tsList", which is assumed to have enough space to hold
 * at least kMaxTSPairs entries.
 *
 * The last non-zero entry will be identified and stored in "*pLastNonZero".
 * If all entries are zero, it will be set to -1.
 *
 * Sometimes files will have junk at the tail end of an otherwise valid
 * T/S list.  We can't just stop when we hit the first (0,0) entry because
 * that'll screw up random-access text file handling.  What we can do is
 * try to detect the situation, and mark the file as "suspicious" without
 * returning an error if we see it.
 *
 * If a TS entry appears to be invalid, this returns an error after all
 * entries have been copied.  If it looks to be partially valid, only the
 * valid parts are copied out, with the rest zeroed.
 */
DIError A2FileDOS::ExtractTSPairs(const uint8_t* sctBuf, TrackSector* tsList,
    int* pLastNonZero)
{
    DIError dierr = kDIErrNone;
    const DiskImg* pDiskImg = fpDiskFS->GetDiskImg();
    const uint8_t* ptr;
    int i, track, sector;

    *pLastNonZero = -1;
    memset(tsList, 0, sizeof(TrackSector) * kMaxTSPairs);

    ptr = &sctBuf[kTSOffset];       // offset of first T/S entry (0x0c)

    for (i = 0; i < kMaxTSPairs; i++) {
        track = *ptr++;
        sector = *ptr++;

        if (dierr == kDIErrNone &&
            (track >= pDiskImg->GetNumTracks() ||
             sector >= pDiskImg->GetNumSectPerTrack() ||
             (track == 0 && sector != 0)))
        {
            LOGI(" DOS33 invalid T/S %d,%d in '%s'", track, sector,
                fFileName);

            if (i > 0 && tsList[i-1].track == 0 && tsList[i-1].sector == 0) {
                LOGI("  T/S list looks partially valid");
                SetQuality(kQualitySuspicious);
                goto bail;  // quit immediately
            } else {
                dierr = kDIErrBadFile;
                // keep going, just so caller has the full set to stare at
            }
        }

        if (track != 0 || sector != 0)
            *pLastNonZero = i;

        tsList[i].track = track;
        tsList[i].sector = sector;
    }

bail:
    return dierr;
}

/*
 * Returns the raw filename.
 *
 * If a pointer to a size_t is passed in, it will be filled with the
 * raw filename length.
 */
const char* A2FileDOS::GetRawFileName(size_t* size) const {
    if (size) {
        *size = strlen(fRawFileName);
    }
    return fRawFileName;
}


/*
 * ===========================================================================
 *      A2FDDOS
 * ===========================================================================
 */

/*
 * Read data from the current offset.
 *
 * Files read back as they would from ProDOS, i.e. if you read a binary
 * file you won't see the 4 bytes of length and address.
 */
DIError A2FDDOS::Read(void* buf, size_t len, size_t* pActual)
{
    LOGD(" DOS reading %lu bytes from '%s' (offset=%ld)",
        (unsigned long) len, fpFile->GetPathName(), (long) fOffset);

    A2FileDOS* pFile = (A2FileDOS*) fpFile;

    /*
     * Don't allow them to read past the end of the file.  The length value
     * stored in pFile->fLength already has pFile->fDataOffset subtracted
     * from the actual data length, so don't factor it in again.
     */
    if (fOffset + (long)len > fOpenEOF) {
        if (pActual == NULL)
            return kDIErrDataUnderrun;
        len = (size_t) (fOpenEOF - fOffset);
    }
    if (pActual != NULL)
        *pActual = len;
    long incrLen = len;

    DIError dierr = kDIErrNone;
    uint8_t sctBuf[kSctSize];
    di_off_t actualOffset = fOffset + pFile->fDataOffset;   // adjust for embedded len
    int tsIndex = (int) (actualOffset / kSctSize);
    int bufOffset = (int) (actualOffset % kSctSize);        // (& 0xff)
    size_t thisCount;

    if (len == 0)
        return kDIErrNone;
    assert(fOpenEOF != 0);

    assert(tsIndex >= 0 && tsIndex < fTSCount);

    /* could be more clever in here and avoid double-buffering */
    while (len) {
        if (tsIndex >= fTSCount) {
            /* should've caught this earlier */
            assert(false);
            LOGI(" DOS ran off the end (fTSCount=%d)", fTSCount);
            return kDIErrDataUnderrun;
        }

        if (fTSList[tsIndex].track == 0 && fTSList[tsIndex].sector == 0) {
            //LOGI(" DOS sparse sector T=%d S=%d",
            //  TSTrack(fTSList[tsIndex]), TSSector(fTSList[tsIndex]));
            memset(sctBuf, 0, sizeof(sctBuf));
        } else {
            dierr = pFile->GetDiskFS()->GetDiskImg()->ReadTrackSector(
                        fTSList[tsIndex].track,
                        fTSList[tsIndex].sector,
                        sctBuf);
            if (dierr != kDIErrNone) {
                LOGI(" DOS error reading file '%s'", pFile->GetPathName());
                return dierr;
            }
        }
        thisCount = kSctSize - bufOffset;
        if (thisCount > len)
            thisCount = len;
        memcpy(buf, sctBuf + bufOffset, thisCount);
        len -= thisCount;
        buf = (char*)buf + thisCount;

        bufOffset = 0;
        tsIndex++;
    }

    fOffset += incrLen;

    return dierr;
}

/*
 * Write data at the current offset.
 *
 * For simplicity, we assume that we're writing a brand-new file in one
 * shot.  As it happens, that's all we're currently required to do, so even
 * if we wrote a more sophisticated function it wouldn't get exercised.
 * Because of the way we write, there's no way to mimic the behavior of
 * random-access text file allocation, so that isn't supported.
 *
 * The data in "buf" should *not* include the 2-4 bytes of header present
 * on A/I/B files.  That's already factored in.
 *
 * Modifies fOpenEOF, fOpenSectorsUsed, and sets fModified.
 */
DIError A2FDDOS::Write(const void* buf, size_t len, size_t* pActual)
{
    DIError dierr = kDIErrNone;
    A2FileDOS* pFile = (A2FileDOS*) fpFile;
    DiskFSDOS33* pDiskFS = (DiskFSDOS33*) fpFile->GetDiskFS();
    uint8_t sctBuf[kSctSize];

    LOGD("   DOS Write len=%lu %s", (unsigned long) len, pFile->GetPathName());

    if (len >= 0x01000000) {    // 16MB
        assert(false);
        return kDIErrInvalidArg;
    }
    assert(fOffset == 0);       // big simplifying assumption
    assert(fOpenEOF == 0);      // another one
    assert(fTSCount == 0);      // must hold for our newly-created files
    assert(fIndexCount == 1);   // must hold for our newly-created files
    assert(fOpenSectorsUsed == fTSCount + fIndexCount);
    assert(buf != NULL);

    long actualLen = (long) len + pFile->fDataOffset;
    long numSectors = (actualLen + kSctSize -1) / kSctSize;
    TrackSector firstIndex;
    int i;

    /*
     * Nothing to do for zero-length write; don't even set fModified.  Note,
     * however, that a zero-length 'B' file is actually 4 bytes long, and
     * must have a data block allocated.
     */
    if (actualLen == 0)
        goto bail;
    assert(numSectors > 0);

    dierr = pDiskFS->LoadVolBitmap();
    if (dierr != kDIErrNone)
        goto bail;

    /*
     * Start by allocating a full T/S list.  The existing T/S list is
     * empty, but we do have one T/S index sector to fill before we
     * allocate any others.
     *
     * Since we determined above that there was nothing interesting in
     * our T/S list, we just grab the one allocated block, throw out
     * the lists, and reallocate them.
     */
    firstIndex = fIndexList[0];
    delete[] fTSList;
    delete[] fIndexList;
    fTSList = fIndexList = NULL;

    fTSCount = numSectors;
    fTSList = new TrackSector[fTSCount];
    fIndexCount = (numSectors + kMaxTSPairs -1) / kMaxTSPairs;
    assert(fIndexCount > 0);
    fIndexList = new TrackSector[fIndexCount];
    if (fTSList == NULL || fIndexList == NULL) {
        dierr = kDIErrMalloc;
        goto bail;
    }

    /*
     * Allocate all of the index sectors.  In theory we should to this along
     * with the file sectors, so that the index and file sectors are
     * interspersed with the data, but in practice 99% of the file have
     * only one or two index blocks.  By grouping them together we improve
     * the performance for emulators and CiderPress.
     */
    fIndexList[0] = firstIndex;
    for (i = 1; i < fIndexCount; i++) {
        TrackSector allocTS;

        dierr = pDiskFS->AllocSector(&allocTS);
        if (dierr != kDIErrNone)
            goto bail;
        fIndexList[i] = allocTS;
    }
    /*
     * Allocate the data sectors.
     */
    for (i = 0; i < fTSCount; i++) {
        TrackSector allocTS;

        dierr = pDiskFS->AllocSector(&allocTS);
        if (dierr != kDIErrNone)
            goto bail;
        fTSList[i] = allocTS;
    }

    /*
     * Write the sectors into the T/S list.
     */
    const uint8_t* curPtr;
    int sectorIdx;

    curPtr = (const uint8_t*) buf;
    sectorIdx = 0;

    if (pFile->fDataOffset > 0) {
        /* handle first sector specially */
        assert(pFile->fDataOffset < kSctSize);
        int dataInFirstSct = kSctSize - pFile->fDataOffset;
        if (dataInFirstSct > actualLen - pFile->fDataOffset)
            dataInFirstSct = actualLen - pFile->fDataOffset;

        // dataInFirstSct could be zero (== len)
        memset(sctBuf, 0, sizeof(sctBuf));
        memcpy(sctBuf + pFile->fDataOffset, curPtr,
            dataInFirstSct);
        dierr = pDiskFS->GetDiskImg()->WriteTrackSector(fTSList[sectorIdx].track,
                    fTSList[sectorIdx].sector, sctBuf);
        if (dierr != kDIErrNone)
            goto bail;

        sectorIdx++;
        actualLen -= dataInFirstSct + pFile->fDataOffset;
        curPtr += dataInFirstSct;
    }
    while (actualLen > 0) {
        if (actualLen >= kSctSize) {
            /* write directly from input */
            dierr = pDiskFS->GetDiskImg()->WriteTrackSector(fTSList[sectorIdx].track,
                fTSList[sectorIdx].sector, curPtr);
            if (dierr != kDIErrNone)
                goto bail;
        } else {
            /* make a copy of the partial buffer */
            memset(sctBuf, 0, sizeof(sctBuf));
            memcpy(sctBuf, curPtr, actualLen);
            dierr = pDiskFS->GetDiskImg()->WriteTrackSector(fTSList[sectorIdx].track,
                fTSList[sectorIdx].sector, sctBuf);
            if (dierr != kDIErrNone)
                goto bail;
        }

        sectorIdx++;
        actualLen -= kSctSize;  // goes negative; that's fine
        curPtr += kSctSize;
    }
    assert(sectorIdx == fTSCount);

    /*
     * Fill out the T/S list sectors.  Failure here presents a potential
     * problem because, once we've written the first T/S entry, the file
     * appears to have storage that it actually doesn't.  The easiest way
     * to handle this safely is to start by writing the last index block
     * first.
     */
    for (i = fIndexCount-1; i >= 0; i--) {
        int tsOffset = i * kMaxTSPairs;
        assert(tsOffset < fTSCount);

        memset(sctBuf, 0, kSctSize);
        if (i != fIndexCount-1) {
            sctBuf[0x01] = fIndexList[i+1].track;
            sctBuf[0x02] = fIndexList[i+1].sector;
        }
        PutShortLE(&sctBuf[0x05], kMaxTSPairs * i);

        int ent = i * kMaxTSPairs;      // start here
        for (int j = 0; j < kMaxTSPairs; j++) {
            if (ent == fTSCount)
                break;
            sctBuf[kTSOffset + j*2] = fTSList[ent].track;
            sctBuf[kTSOffset + j*2 +1] = fTSList[ent].sector;
            ent++;
        }

        dierr = pDiskFS->GetDiskImg()->WriteTrackSector(fIndexList[i].track,
                    fIndexList[i].sector, sctBuf);
        if (dierr != kDIErrNone)
            goto bail;
    }

    dierr = pDiskFS->SaveVolBitmap();
    if (dierr != kDIErrNone) {
        /*
         * This is awkward -- we wrote the first T/S list, so the file
         * now appears to have content, but the blocks aren't marked used.
         * We read the VTOC successfully though, so it's VERY unlikely
         * that this will fail.  If it does, it's likely that any attempt
         * to mitigate the problem will also fail.  (Maybe we could force
         * the object into read-only mode?)
         */
        goto bail;
    }

    /* finish up */
    fOpenSectorsUsed = fIndexCount + fTSCount;
    fOpenEOF = len;
    fOffset += len;
    fModified = true;

    if (!UpdateProgress(fOffset))
        dierr = kDIErrCancelled;

bail:
    pDiskFS->FreeVolBitmap();
    return dierr;
}

/*
 * Seek to the specified offset.
 */
DIError A2FDDOS::Seek(di_off_t offset, DIWhence whence)
{
    //di_off_t fileLength = fpFile->GetDataLength();

    switch (whence) {
    case kSeekSet:
        if (offset < 0 || offset > fOpenEOF)
            return kDIErrInvalidArg;
        fOffset = offset;
        break;
    case kSeekEnd:
        if (offset > 0 || offset < -fOpenEOF)
            return kDIErrInvalidArg;
        fOffset = fOpenEOF + offset;
        break;
    case kSeekCur:
        if (offset < -fOffset ||
            offset >= (fOpenEOF - fOffset))
        {
            return kDIErrInvalidArg;
        }
        fOffset += offset;
        break;
    default:
        assert(false);
        return kDIErrInvalidArg;
    }

    assert(fOffset >= 0 && fOffset <= fOpenEOF);
    return kDIErrNone;
}

/*
 * Return current offset.
 */
di_off_t A2FDDOS::Tell(void)
{
    return fOffset;
}

/*
 * Release file state.
 *
 * If the file was modified, we need to update the sector usage count in
 * the catalog track, and possibly a length word in the first sector of
 * the file (for A/I/B).
 *
 * Given the current "write all at once" implementation of Write, we could
 * have handled the length word back when initially writing the data, but
 * someday we may fix that and I don't want to have to rewrite this part.
 *
 * Most applications don't check the value of "Close", or call it from a
 * destructor, so we call CloseDescr whether we succeed or not.
 */
DIError A2FDDOS::Close(void)
{
    DIError dierr = kDIErrNone;

    if (fModified) {
        DiskFSDOS33* pDiskFS = (DiskFSDOS33*) fpFile->GetDiskFS();
        A2FileDOS* pFile = (A2FileDOS*) fpFile;
        uint8_t sctBuf[kSctSize];
        uint8_t* pEntry;

        /*
         * Fill in the length and address, if needed for this type of file.
         */
        if (pFile->fFileType == A2FileDOS::kTypeInteger ||
            pFile->fFileType == A2FileDOS::kTypeApplesoft ||
            pFile->fFileType == A2FileDOS::kTypeBinary)
        {
            assert(fTSCount > 0);
            assert(pFile->fDataOffset > 0);
            //assert(fOpenEOF < 65536);
            if (fOpenEOF > 65535) {
                LOGW("WARNING: DOS Close trimming A/I/B file from %ld to 65535",
                    (long) fOpenEOF);
                fOpenEOF = 65535;
            }
            dierr = pDiskFS->GetDiskImg()->ReadTrackSector(fTSList[0].track,
                        fTSList[0].sector, sctBuf);
            if (dierr != kDIErrNone) {
                LOGW("DOS Close: unable to get first sector of file");
                goto bail;
            }

            if (pFile->fFileType == A2FileDOS::kTypeInteger ||
                pFile->fFileType == A2FileDOS::kTypeApplesoft)
            {
                PutShortLE(&sctBuf[0x00], (uint16_t) fOpenEOF);
            } else {
                PutShortLE(&sctBuf[0x00], pFile->fAuxType);
                PutShortLE(&sctBuf[0x02], (uint16_t) fOpenEOF);
            }

            dierr = pDiskFS->GetDiskImg()->WriteTrackSector(fTSList[0].track,
                        fTSList[0].sector, sctBuf);
            if (dierr != kDIErrNone) {
                LOGW("DOS Close: unable to write first sector of file");
                goto bail;
            }
        } else if (pFile->fFileType == A2FileDOS::kTypeText) {
            /*
             * The length of text files can be determined by looking for the
             * first $00.  A file of exactly 256 bytes occupies only one
             * sector though, so running out of sectors also works -- the
             * last $00 is not mandatory.
             *
             * Bottom line is that the value we just wrote for fOpenEOF is
             * *probably* recoverable, so we can stuff it into "fLength"
             * with some assurance that it will be there when we reopen the
             * file.
             */
        } else {
            /*
             * The remaining file types have a length based solely on
             * sector count.  We need to round off our length value.
             */
            fOpenEOF = ((fOpenEOF + kSctSize-1) / kSctSize) * kSctSize;
        }

        /*
         * Update our internal copies of stuff.
         */
        pFile->fLength = fOpenEOF;
        pFile->fSparseLength = pFile->fLength;
        pFile->fLengthInSectors = (uint16_t) fOpenSectorsUsed;

        /*
         * Update the sector count in the directory entry.
         */
        dierr = pDiskFS->GetDiskImg()->ReadTrackSector(pFile->fCatTS.track,
                    pFile->fCatTS.sector, sctBuf);
        if (dierr != kDIErrNone)
            goto bail;

        pEntry = GetCatalogEntryPtr(sctBuf, pFile->fCatEntryNum);
        assert(GetShortLE(&pEntry[0x21]) == 1);     // holds for new file
        PutShortLE(&pEntry[0x21], pFile->fLengthInSectors);
        dierr = pDiskFS->GetDiskImg()->WriteTrackSector(pFile->fCatTS.track,
                    pFile->fCatTS.sector, sctBuf);
    }

bail:
    fpFile->CloseDescr(this);
    return dierr;
}


/*
 * Return the #of sectors/blocks in the file.
 */
long A2FDDOS::GetSectorCount(void) const
{
    return fTSCount;
}

long A2FDDOS::GetBlockCount(void) const
{
    return (fTSCount+1)/2;
}

/*
 * Return the Nth track/sector in this file.
 *
 * Returns (0,0) for a sparse sector.
 */
DIError A2FDDOS::GetStorage(long sectorIdx, long* pTrack, long* pSector) const
{
    if (sectorIdx < 0 || sectorIdx >= fTSCount)
        return kDIErrInvalidIndex;

    *pTrack = fTSList[sectorIdx].track;
    *pSector = fTSList[sectorIdx].sector;
    return kDIErrNone;
}
/*
 * Return the Nth 512-byte block in this file.  Since things aren't stored
 * in 512-byte blocks, we're reduced to finding storage at (tsIndex*2) and
 * converting it to a block number.
 */
DIError A2FDDOS::GetStorage(long blockIdx, long* pBlock) const
{
    long sectorIdx = blockIdx * 2;
    if (sectorIdx < 0 || sectorIdx >= fTSCount)
        return kDIErrInvalidIndex;

    bool dummy;
    TrackSectorToBlock(fTSList[sectorIdx].track,
        fTSList[sectorIdx].sector, pBlock, &dummy);
    assert(*pBlock < fpFile->GetDiskFS()->GetDiskImg()->GetNumBlocks());
    return kDIErrNone;
}


/*
 * Dump the T/S list for an open file.
 */
void A2FDDOS::DumpTSList(void) const
{
    //A2FileDOS* pFile = (A2FileDOS*) fpFile;
    LOGI(" DOS T/S list for '%s' (count=%d)",
        ((A2FileDOS*)fpFile)->fFileName, fTSCount);

    int i;
    for (i = 0; i <= fTSCount; i++) {
        LOGI(" %3d: T=%-2d S=%d", i, fTSList[i].track, fTSList[i].sector);
    }
}
