610 lines
21 KiB
Java
Executable File
610 lines
21 KiB
Java
Executable File
package com.bytezone.diskbrowser.dos;
|
||
|
||
import java.awt.Color;
|
||
import java.nio.file.Path;
|
||
import java.util.ArrayList;
|
||
import java.util.List;
|
||
|
||
import javax.swing.tree.DefaultMutableTreeNode;
|
||
|
||
import com.bytezone.diskbrowser.applefile.AppleFileSource;
|
||
import com.bytezone.diskbrowser.applefile.BootSector;
|
||
import com.bytezone.diskbrowser.disk.AbstractFormattedDisk;
|
||
import com.bytezone.diskbrowser.disk.AppleDisk;
|
||
import com.bytezone.diskbrowser.disk.DefaultAppleFileSource;
|
||
import com.bytezone.diskbrowser.disk.DefaultSector;
|
||
import com.bytezone.diskbrowser.disk.Disk;
|
||
import com.bytezone.diskbrowser.disk.DiskAddress;
|
||
import com.bytezone.diskbrowser.disk.SectorType;
|
||
import com.bytezone.diskbrowser.gui.DataSource;
|
||
|
||
// -----------------------------------------------------------------------------------//
|
||
public class DosDisk extends AbstractFormattedDisk
|
||
// -----------------------------------------------------------------------------------//
|
||
{
|
||
private static final int ENTRY_SIZE = 35;
|
||
private static final int CATALOG_TRACK = 17;
|
||
private static final int VTOC_SECTOR = 0;
|
||
|
||
final DosVTOCSector dosVTOCSector;
|
||
private final Color green = new Color (0, 200, 0);
|
||
private final DefaultMutableTreeNode volumeNode;
|
||
|
||
private int freeSectors;
|
||
private int usedSectors;
|
||
private final int volumeNo; // for multi-volume disks
|
||
|
||
public final SectorType vtocSector = new SectorType ("VTOC", Color.magenta);
|
||
public final SectorType catalogSector = new SectorType ("Catalog", green);
|
||
public final SectorType tsListSector = new SectorType ("TSList", Color.blue);
|
||
public final SectorType dataSector = new SectorType ("Data", Color.red);
|
||
public final SectorType dosSector = new SectorType ("DOS", Color.lightGray);
|
||
|
||
protected List<AppleFileSource> deletedFileEntries = new ArrayList<> ();
|
||
|
||
private static boolean debug = false;
|
||
|
||
enum FileType
|
||
{
|
||
Text, ApplesoftBasic, IntegerBasic, Binary, SS, Relocatable, AA, BB
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------------//
|
||
public DosDisk (Disk disk)
|
||
// ---------------------------------------------------------------------------------//
|
||
{
|
||
this (disk, 0);
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------------//
|
||
public DosDisk (Disk disk, int volumeNo)
|
||
// ---------------------------------------------------------------------------------//
|
||
{
|
||
super (disk);
|
||
|
||
this.volumeNo = volumeNo;
|
||
|
||
sectorTypesList.add (dosSector);
|
||
sectorTypesList.add (vtocSector);
|
||
sectorTypesList.add (catalogSector);
|
||
sectorTypesList.add (tsListSector);
|
||
sectorTypesList.add (dataSector);
|
||
|
||
DiskAddress da = disk.getDiskAddress (0, 0);
|
||
byte[] sectorBuffer = disk.readBlock (da); // Boot sector
|
||
bootSector = new BootSector (disk, sectorBuffer, "DOS", da);
|
||
|
||
da = disk.getDiskAddress (CATALOG_TRACK, VTOC_SECTOR);
|
||
sectorBuffer = disk.readBlock (da); // VTOC
|
||
((AppleDisk) disk).setDosVersion (sectorBuffer[3] & 0xFF);
|
||
dosVTOCSector = new DosVTOCSector (this, disk, sectorBuffer, da);
|
||
sectorTypes[da.getBlockNo ()] = vtocSector;
|
||
|
||
DiskAddress catalogStart = disk.getDiskAddress (sectorBuffer[1], sectorBuffer[2]);
|
||
|
||
if (dosVTOCSector.sectorSize != disk.getBlockSize ())
|
||
System.out.printf ("%s - invalid sector size : %d%n", disk.getFile ().getName (),
|
||
dosVTOCSector.sectorSize);
|
||
if (dosVTOCSector.maxSectors != disk.getBlocksPerTrack ())
|
||
System.out.printf ("%s - invalid sectors per track : %d%n",
|
||
disk.getFile ().getName (), dosVTOCSector.maxSectors);
|
||
|
||
// sectorTypes[CATALOG_TRACK * dosVTOCSector.maxSectors] = vtocSector;
|
||
|
||
// assert (maxTracks == disk.getTotalTracks ());
|
||
// assert (dosVTOCSector.maxSectors == disk.getSectorsPerTrack ());
|
||
// assert (sectorSize == disk.getBlockSize ()); HFSAssembler.dsk fails this
|
||
// assert (catalogStart.getTrack () == CATALOG_TRACK);
|
||
|
||
// arcboot.dsk starts the catalog at 17/13
|
||
// assert (catalogStart.getSector () == 15);
|
||
|
||
// build list of CatalogEntry objects
|
||
DefaultMutableTreeNode rootNode = getCatalogTreeRoot ();
|
||
volumeNode = new DefaultMutableTreeNode ();
|
||
DefaultMutableTreeNode deletedFilesNode = new DefaultMutableTreeNode ();
|
||
rootNode.add (volumeNode);
|
||
|
||
// flag the catalog sectors before any file mistakenly grabs them
|
||
da = disk.getDiskAddress (catalogStart.getBlockNo ());
|
||
do
|
||
{
|
||
if (!disk.isValidAddress (da))
|
||
break;
|
||
sectorBuffer = disk.readBlock (da);
|
||
if (!disk.isValidAddress (sectorBuffer[1], sectorBuffer[2]))
|
||
break;
|
||
|
||
// The first byte is officially unused, but it always seems to contain 0x00 or 0xFF
|
||
// See beautifulboot.dsk.
|
||
// if (sectorBuffer[0] != 0 && (sectorBuffer[0] & 0xFF) != 0xFF && false)
|
||
// {
|
||
// System.out
|
||
// .println ("Dos catalog sector buffer byte #0 invalid : " + sectorBuffer[0]);
|
||
// break;
|
||
// }
|
||
|
||
sectorTypes[da.getBlockNo ()] = catalogSector;
|
||
|
||
int track = sectorBuffer[1] & 0xFF;
|
||
int sector = sectorBuffer[2] & 0xFF;
|
||
if (!disk.isValidAddress (track, sector))
|
||
break;
|
||
|
||
da = disk.getDiskAddress (track, sector);
|
||
|
||
} while (!da.isZero () && da.isValidAddress ());
|
||
|
||
// same loop, but now all the catalog sectors are properly flagged
|
||
da = disk.getDiskAddress (catalogStart.getBlockNo ());
|
||
loop: do
|
||
{
|
||
if (!disk.isValidAddress (da))
|
||
break;
|
||
sectorBuffer = disk.readBlock (da);
|
||
if (!disk.isValidAddress (sectorBuffer[1], sectorBuffer[2]))
|
||
break;
|
||
|
||
for (int ptr = 11; ptr < 256; ptr += ENTRY_SIZE)
|
||
{
|
||
if (sectorBuffer[ptr] == 0) // empty slot, no more catalog entries
|
||
break loop;
|
||
|
||
byte[] entryBuffer = new byte[ENTRY_SIZE];
|
||
System.arraycopy (sectorBuffer, ptr, entryBuffer, 0, ENTRY_SIZE);
|
||
int track = entryBuffer[0] & 0xFF;
|
||
boolean deletedFlag = (entryBuffer[0] & 0x80) != 0;
|
||
|
||
if (deletedFlag) // deleted file
|
||
{
|
||
DeletedCatalogEntry deletedCatalogEntry =
|
||
new DeletedCatalogEntry (this, da, entryBuffer, dosVTOCSector.dosVersion);
|
||
deletedFileEntries.add (deletedCatalogEntry);
|
||
DefaultMutableTreeNode node = new DefaultMutableTreeNode (deletedCatalogEntry);
|
||
node.setAllowsChildren (false);
|
||
deletedFilesNode.add (node);
|
||
}
|
||
else
|
||
{
|
||
CatalogEntry catalogEntry = new CatalogEntry (this, da, entryBuffer);
|
||
fileEntries.add (catalogEntry);
|
||
DefaultMutableTreeNode node = new DefaultMutableTreeNode (catalogEntry);
|
||
node.setAllowsChildren (false);
|
||
volumeNode.add (node);
|
||
}
|
||
}
|
||
|
||
int track = sectorBuffer[1] & 0xFF;
|
||
int sector = sectorBuffer[2] & 0xFF;
|
||
if (dosVTOCSector.dosVersion >= 0x41)
|
||
{
|
||
track = track & 0x3F;
|
||
sector = sector & 0x1F;
|
||
}
|
||
|
||
if (!disk.isValidAddress (track, sector))
|
||
break;
|
||
|
||
da = disk.getDiskAddress (sectorBuffer[1], sectorBuffer[2]);
|
||
|
||
} while (!da.isZero ());
|
||
|
||
// link double hi-res files
|
||
for (AppleFileSource fe : fileEntries)
|
||
{
|
||
String name = fe.getUniqueName ();
|
||
if (name.endsWith (".AUX"))
|
||
{
|
||
String partner1 = name.substring (0, name.length () - 4);
|
||
String partner2 = partner1 + ".BIN";
|
||
for (AppleFileSource fe2 : fileEntries)
|
||
if (fe2.getUniqueName ().equals (partner1)
|
||
|| fe2.getUniqueName ().equals (partner2))
|
||
{
|
||
((CatalogEntry) fe2).link ((CatalogEntry) fe);
|
||
((CatalogEntry) fe).link ((CatalogEntry) fe2);
|
||
}
|
||
}
|
||
}
|
||
|
||
// add up all the free and used sectors, and label DOS sectors while we're here
|
||
int lastDosSector = dosVTOCSector.maxSectors * 3; // first three tracks
|
||
for (DiskAddress da2 : disk)
|
||
{
|
||
int blockNo = da2.getBlockNo ();
|
||
if (blockNo < lastDosSector) // in the DOS region
|
||
{
|
||
if (freeBlocks.get (blockNo)) // according to the VTOC
|
||
++freeSectors;
|
||
else
|
||
{
|
||
++usedSectors;
|
||
if (sectorTypes[blockNo] == usedSector)
|
||
sectorTypes[blockNo] = dosSector;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (stillAvailable (da2)) // free or used, ie not specifically labelled
|
||
++freeSectors;
|
||
else
|
||
++usedSectors;
|
||
}
|
||
|
||
if (freeBlocks.get (blockNo) && !stillAvailable (da2))
|
||
falsePositives++;
|
||
if (!freeBlocks.get (blockNo) && stillAvailable (da2))
|
||
falseNegatives++;
|
||
}
|
||
|
||
if (deletedFilesNode.getDepth () > 0)
|
||
{
|
||
rootNode.add (deletedFilesNode);
|
||
deletedFilesNode.setUserObject (getDeletedList ());
|
||
makeNodeVisible (deletedFilesNode.getFirstLeaf ());
|
||
}
|
||
|
||
volumeNode.setUserObject (getCatalog ());
|
||
makeNodeVisible (volumeNode.getFirstLeaf ());
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------------//
|
||
@Override
|
||
public void setOriginalPath (Path path)
|
||
// ---------------------------------------------------------------------------------//
|
||
{
|
||
super.setOriginalPath (path);
|
||
|
||
// this has already been set in the constructor
|
||
volumeNode.setUserObject (getCatalog ());
|
||
}
|
||
|
||
// Beagle Bros FRAMEUP disk only has one catalog block
|
||
// ARCBOOT.DSK has a catalog which starts at sector 0C
|
||
// ---------------------------------------------------------------------------------//
|
||
public static boolean isCorrectFormat (AppleDisk disk)
|
||
// ---------------------------------------------------------------------------------//
|
||
{
|
||
if (false) // testing
|
||
{
|
||
disk.setInterleave (1);
|
||
return true;
|
||
}
|
||
|
||
int blocksPerTrack = disk.getBlocksPerTrack ();
|
||
if (blocksPerTrack > 16 && blocksPerTrack != 32) // 32 = unidos
|
||
{
|
||
if (debug)
|
||
System.out.printf ("Blocks per track: %d", blocksPerTrack);
|
||
return false;
|
||
}
|
||
|
||
int[] cb = new int[3];
|
||
int best = 0;
|
||
int il = -1;
|
||
int max = disk.getBlocksPerTrack () == 16 ? 3 : 1; // no interleave for 13 sector?
|
||
|
||
for (int interleave = 0; interleave < max; interleave++)
|
||
{
|
||
if (debug)
|
||
System.out.printf ("Checking interleave %d%n", interleave);
|
||
|
||
disk.setInterleave (interleave);
|
||
cb[interleave] = checkFormat (disk);
|
||
if (cb[interleave] >= 15)
|
||
return true;
|
||
|
||
if (cb[interleave] > best)
|
||
{
|
||
best = cb[interleave];
|
||
il = interleave;
|
||
}
|
||
}
|
||
|
||
if (best <= 1)
|
||
return false;
|
||
|
||
disk.setInterleave (il);
|
||
return true;
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------------//
|
||
public String getVersionText ()
|
||
// ---------------------------------------------------------------------------------//
|
||
{
|
||
switch (getVersion ())
|
||
{
|
||
case 0x01:
|
||
return "3.1";
|
||
case 0x02:
|
||
return "3.2";
|
||
case 0x03:
|
||
return "3.3";
|
||
case 0x41:
|
||
return "4.1";
|
||
case 0x42:
|
||
return "4.2";
|
||
case 0x43:
|
||
return "4.3";
|
||
case 0x45:
|
||
return "4.5";
|
||
default:
|
||
return "??";
|
||
}
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------------//
|
||
public int getVersion ()
|
||
// ---------------------------------------------------------------------------------//
|
||
{
|
||
return dosVTOCSector.dosVersion;
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------------//
|
||
private static int checkFormat (AppleDisk disk)
|
||
// ---------------------------------------------------------------------------------//
|
||
{
|
||
byte[] buffer = disk.readBlock (0x11, 0x00);
|
||
|
||
// DISCCOMMANDER.DSK uses track 0x17 for the catalog
|
||
// if (buffer[1] != 0x11) // first catalog track
|
||
// return 0;
|
||
|
||
// Apple Assembly Language.dsk claims 0x2A tracks per disk
|
||
// if (buffer[52] != 35 && buffer[52] != 50)
|
||
// {
|
||
// if (debug)
|
||
// System.out.printf ("Bad tracks per disk : %02X%n", buffer[52]);
|
||
// return 0;
|
||
// }
|
||
|
||
if (debug)
|
||
System.out.printf ("Sectors per track: %02X%n", buffer[53]);
|
||
|
||
if (buffer[53] != 16 && buffer[53] != 13 && buffer[53] != 32) // sectors per track
|
||
{
|
||
if (debug)
|
||
System.out.printf ("Bad sectors per track : %02X%n", buffer[53]);
|
||
return 0;
|
||
}
|
||
|
||
// if (buffer[49] < -1 || buffer[49] > 1) // direction of next file save
|
||
// {
|
||
// System.out.println ("Bad direction : " + buffer[49]);
|
||
// // Visicalc data disk had 0xF8
|
||
// // return 0;
|
||
// }
|
||
|
||
int version = buffer[3] & 0xFF;
|
||
if (debug)
|
||
System.out.printf ("Version: %02X%n", buffer[3]);
|
||
if (version == 0 || (version > 0x45 && version != 0xFF))
|
||
{
|
||
if (debug)
|
||
System.out.printf ("Bad version : %02X%n", version);
|
||
return 0;
|
||
}
|
||
|
||
int catalogBlocks = countCatalogBlocks (disk, buffer);
|
||
if (debug)
|
||
System.out.printf ("Catalog blocks: %s%n", catalogBlocks);
|
||
|
||
if (catalogBlocks > 0)
|
||
disk.setDosVersion (version);
|
||
return catalogBlocks;
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------------//
|
||
private static int countCatalogBlocks (AppleDisk disk, byte[] buffer)
|
||
// ---------------------------------------------------------------------------------//
|
||
{
|
||
if (!disk.isValidAddress (buffer[1], buffer[2]))
|
||
{
|
||
if (debug)
|
||
System.out.printf ("Invalid address1: %02X %02X%n", buffer[1], buffer[2]);
|
||
return 0;
|
||
}
|
||
|
||
DiskAddress catalogStart = disk.getDiskAddress (buffer[1], buffer[2]);
|
||
DiskAddress da = disk.getDiskAddress (catalogStart.getBlockNo ());
|
||
List<DiskAddress> catalogAddresses = new ArrayList<> ();
|
||
|
||
do
|
||
{
|
||
if (debug)
|
||
System.out.printf ("Checking: %s%n", da);
|
||
|
||
if (!disk.isValidAddress (da))
|
||
{
|
||
if (debug)
|
||
System.out.printf ("Invalid address: %s%n", da);
|
||
return 0;
|
||
}
|
||
|
||
if (isDuplicate (catalogAddresses, da))
|
||
{
|
||
if (debug)
|
||
System.out.println ("Catalog looping");
|
||
return 0;
|
||
}
|
||
|
||
buffer = disk.readBlock (da);
|
||
if (!disk.isValidAddress (buffer[1], buffer[2]))
|
||
{
|
||
if (debug)
|
||
System.out.printf ("Invalid address2: %02X %02X%n", buffer[1], buffer[2]);
|
||
return catalogAddresses.size ();
|
||
}
|
||
|
||
catalogAddresses.add (da);
|
||
|
||
da = disk.getDiskAddress (buffer[1], buffer[2]);
|
||
} while (!da.isZero ());
|
||
|
||
if (debug)
|
||
System.out.printf ("Catalog blocks: %d%n", catalogAddresses.size ());
|
||
return catalogAddresses.size ();
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------------//
|
||
private static boolean isDuplicate (List<DiskAddress> catalogAddresses, DiskAddress da)
|
||
// ---------------------------------------------------------------------------------//
|
||
{
|
||
for (DiskAddress diskAddress : catalogAddresses)
|
||
if (diskAddress.getBlockNo () == da.getBlockNo ())
|
||
return true;
|
||
return false;
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------------//
|
||
@Override
|
||
public String toString ()
|
||
// ---------------------------------------------------------------------------------//
|
||
{
|
||
StringBuilder text = new StringBuilder ();
|
||
|
||
text.append (String.format ("Disk name ............. %s%n", getDisplayPath ()));
|
||
text.append (
|
||
String.format ("DOS version ........... %s%n", dosVTOCSector.dosVersion));
|
||
text.append (
|
||
String.format ("Sectors per track ..... %d%n", dosVTOCSector.maxSectors));
|
||
text.append (String.format ("Volume no ............. %d%n", volumeNo));
|
||
text.append (String.format ("Interleave ............ %d", disk.getInterleave ()));
|
||
|
||
return text.toString ();
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------------//
|
||
@Override
|
||
public DataSource getFormattedSector (DiskAddress da)
|
||
// ---------------------------------------------------------------------------------//
|
||
{
|
||
SectorType type = sectorTypes[da.getBlockNo ()];
|
||
if (type == vtocSector)
|
||
return dosVTOCSector;
|
||
if (da.isZero ())
|
||
return bootSector;
|
||
|
||
byte[] buffer = disk.readBlock (da);
|
||
String address = String.format ("%02X %02X", da.getTrackNo (), da.getSectorNo ());
|
||
|
||
if (type == tsListSector)
|
||
return new DosTSListSector (getSectorFilename (da), disk, buffer, da);
|
||
if (type == catalogSector)
|
||
return new DosCatalogSector (this, disk, buffer, da);
|
||
if (type == dataSector)
|
||
return new DefaultSector (
|
||
"Data Sector at " + address + " : " + getSectorFilename (da), disk, buffer, da);
|
||
if (type == dosSector)
|
||
return new DefaultSector ("DOS sector at " + address, disk, buffer, da);
|
||
return super.getFormattedSector (da);
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------------//
|
||
@Override
|
||
public List<DiskAddress> getFileSectors (int fileNo)
|
||
// ---------------------------------------------------------------------------------//
|
||
{
|
||
if (fileEntries.size () > 0 && fileEntries.size () > fileNo)
|
||
return fileEntries.get (fileNo).getSectors ();
|
||
return null;
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------------//
|
||
private int countEntries (AppleFileSource catalogEntry)
|
||
// ---------------------------------------------------------------------------------//
|
||
{
|
||
int count = 0;
|
||
for (AppleFileSource ce : fileEntries)
|
||
{
|
||
if (ce.getUniqueName ().equals (catalogEntry.getUniqueName ()))
|
||
count++;
|
||
}
|
||
return count;
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------------//
|
||
@Override
|
||
public AppleFileSource getCatalog ()
|
||
// ---------------------------------------------------------------------------------//
|
||
{
|
||
String newLine = String.format ("%n");
|
||
String underline = "- --- --- ------------------------------ ----- -------------"
|
||
+ " -- ---- -------------------" + newLine;
|
||
|
||
StringBuilder text = new StringBuilder ();
|
||
|
||
text.append (String.format ("File : %s%n%n", getDisplayPath ()));
|
||
text.append ("L Typ Len Name Addr"
|
||
+ " Length TS Data Comment" + newLine);
|
||
text.append (underline);
|
||
|
||
for (AppleFileSource fileEntry : fileEntries)
|
||
{
|
||
String entry = ((CatalogEntry) fileEntry).getDetails ();
|
||
if (countEntries (fileEntry) > 1)
|
||
entry += "** duplicate **";
|
||
text.append (entry + newLine);
|
||
}
|
||
|
||
text.append (underline);
|
||
text.append (String.format (
|
||
" Free sectors: %3d " + "Used sectors: %3d Total sectors: %3d",
|
||
dosVTOCSector.freeSectors, dosVTOCSector.usedSectors,
|
||
(dosVTOCSector.freeSectors + dosVTOCSector.usedSectors)));
|
||
if (dosVTOCSector.freeSectors != freeSectors)
|
||
text.append (String.format (
|
||
"%nActual: Free sectors: %3d "
|
||
+ "Used sectors: %3d Total sectors: %3d",
|
||
freeSectors, usedSectors, (usedSectors + freeSectors)));
|
||
|
||
String volumeText = volumeNo == 0 ? "" : "Side " + volumeNo + " ";
|
||
|
||
return new DefaultAppleFileSource (volumeText + "DOS Volume " + dosVTOCSector.volume,
|
||
text.toString (), this);
|
||
}
|
||
|
||
// ---------------------------------------------------------------------------------//
|
||
private AppleFileSource getDeletedList ()
|
||
// ---------------------------------------------------------------------------------//
|
||
{
|
||
StringBuilder text =
|
||
new StringBuilder ("List of files that were deleted from this disk\n");
|
||
|
||
for (AppleFileSource afs : deletedFileEntries)
|
||
text.append (((DeletedCatalogEntry) afs).getDetails () + "\n");
|
||
|
||
return new DefaultAppleFileSource ("Deleted files", text.toString (), this);
|
||
}
|
||
|
||
/* From http://apple2history.org/history/ah15/
|
||
*
|
||
There were actually three versions of DOS 3.3 that Apple released without
|
||
bumping the version number:
|
||
|
||
The first version that was released had FPBASIC and INTBASIC files that were 50
|
||
sectors in size.
|
||
|
||
The second version of DOS 3.3, often referred to as “DOS 3.3e”, appeared at the
|
||
time the Apple IIe was released. In this version, the FPBASIC and INTBASIC files
|
||
were 42 sectors in size. The changes introduced at that time included code to turn
|
||
off the IIe 80-column card at boot time, and an attempt to fix a bug in the APPEND
|
||
command. This fix reportedly introduced an even worse bug, but as the command was
|
||
not heavily used it did not make much of an impact on most programmers. The APPEND
|
||
fix was applied by utilizing some formerly unused space in the DOS 3.3 code.
|
||
|
||
The third version of DOS 3.3 appeared just before the first release of ProDOS.
|
||
The only mention of this in the press was in the DOSTalk column of Softalk magazine.
|
||
This final version of DOS 3.3 included a different fix for the APPEND bug, using
|
||
another bit of unused space in DOS 3.3.
|
||
|
||
With regard to the FPBASIC and INTBASIC files: There were three differences between
|
||
the 50 sector and the 42 sector versions of the INTBASIC file. Firstly, the
|
||
$F800-$FFFF section was removed. This area was the code for the Monitor, and with
|
||
the changes introduced in the Apple IIe, it could cause some things to “break” if
|
||
the older Monitor code was executed. Secondly, a FOR/NEXT bug in Integer BASIC was
|
||
fixed. Finally, there was a three-byte bug in the Programmer’s Aid ROM #1 chip.
|
||
The code for this chip was included in the INTBASIC file, and could therefore be
|
||
patched.
|
||
*/
|
||
} |