339 lines
12 KiB
Java
Executable File
339 lines
12 KiB
Java
Executable File
package com.bytezone.diskbrowser.pascal;
|
|
|
|
import java.awt.Color;
|
|
import java.time.LocalDate;
|
|
import java.time.format.DateTimeFormatter;
|
|
import java.time.format.FormatStyle;
|
|
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;
|
|
import com.bytezone.diskbrowser.utilities.HexFormatter;
|
|
import com.bytezone.diskbrowser.utilities.Utility;
|
|
import com.bytezone.diskbrowser.wizardry.Relocator;
|
|
|
|
// useful : http://pascal.hansotten.com/ucsd-p-system/apple-pascal/apple-ii/
|
|
// -----------------------------------------------------------------------------------//
|
|
public class PascalDisk extends AbstractFormattedDisk
|
|
// -----------------------------------------------------------------------------------//
|
|
{
|
|
static final int CATALOG_ENTRY_SIZE = 26;
|
|
private final DateTimeFormatter dtf =
|
|
DateTimeFormatter.ofLocalizedDate (FormatStyle.SHORT);
|
|
private final VolumeEntry volumeEntry;
|
|
private final PascalCatalogSector diskCatalogSector;
|
|
|
|
protected Relocator relocator;
|
|
|
|
final String[] fileTypes =
|
|
{ "Volume", "Bad ", "Code", "Text", "Info", "Data", "Graf", "Foto", "SecureDir" };
|
|
|
|
SectorType diskBootSector = new SectorType ("Boot", Color.lightGray);
|
|
SectorType catalogSector = new SectorType ("Catalog", Color.magenta);
|
|
SectorType dataSector = new SectorType ("Data", new Color (0, 200, 0)); // green
|
|
SectorType codeSector = new SectorType ("Code", Color.red);
|
|
SectorType textSector = new SectorType ("Text", Color.blue);
|
|
SectorType infoSector = new SectorType ("Info", Color.orange);
|
|
SectorType grafSector = new SectorType ("Graf", Color.cyan);
|
|
SectorType fotoSector = new SectorType ("Foto", Color.gray);
|
|
SectorType badSector = new SectorType ("Bad", Color.darkGray);
|
|
|
|
SectorType[] sectors = { catalogSector, badSector, codeSector, textSector, infoSector,
|
|
dataSector, grafSector, fotoSector };
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
public PascalDisk (Disk disk)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
super (disk);
|
|
|
|
sectorTypesList.add (diskBootSector);
|
|
sectorTypesList.add (catalogSector);
|
|
sectorTypesList.add (dataSector);
|
|
sectorTypesList.add (codeSector);
|
|
sectorTypesList.add (textSector);
|
|
sectorTypesList.add (infoSector);
|
|
sectorTypesList.add (grafSector);
|
|
sectorTypesList.add (fotoSector);
|
|
sectorTypesList.add (badSector);
|
|
|
|
List<DiskAddress> blocks = disk.getDiskAddressList (0, 1); // B0, B1
|
|
this.bootSector = new BootSector (disk, disk.readBlocks (blocks), "Pascal");
|
|
|
|
for (int i = 0; i < 2; i++)
|
|
if (!disk.isBlockEmpty (i))
|
|
{
|
|
sectorTypes[i] = diskBootSector;
|
|
freeBlocks.set (i, false);
|
|
}
|
|
|
|
for (int i = 2; i < disk.getTotalBlocks (); i++)
|
|
freeBlocks.set (i, true);
|
|
|
|
byte[] buffer = disk.readBlock (2);
|
|
byte[] data = new byte[CATALOG_ENTRY_SIZE];
|
|
System.arraycopy (buffer, 0, data, 0, CATALOG_ENTRY_SIZE);
|
|
volumeEntry = new VolumeEntry (this, data);
|
|
|
|
DefaultMutableTreeNode root = getCatalogTreeRoot ();
|
|
DefaultMutableTreeNode volumeNode = new DefaultMutableTreeNode (volumeEntry);
|
|
root.add (volumeNode);
|
|
|
|
List<DiskAddress> sectors = new ArrayList<> ();
|
|
int max = Math.min (volumeEntry.lastBlock, disk.getTotalBlocks ());
|
|
for (int i = 2; i < max; i++)
|
|
{
|
|
DiskAddress da = disk.getDiskAddress (i);
|
|
if (!disk.isBlockEmpty (da))
|
|
sectorTypes[i] = catalogSector;
|
|
sectors.add (da);
|
|
freeBlocks.set (i, false);
|
|
}
|
|
|
|
diskCatalogSector =
|
|
new PascalCatalogSector (disk, disk.readBlocks (sectors), sectors);
|
|
|
|
// read the catalog
|
|
List<DiskAddress> addresses = new ArrayList<> ();
|
|
for (int i = 2; i < max; i++)
|
|
addresses.add (disk.getDiskAddress (i));
|
|
buffer = disk.readBlocks (addresses);
|
|
|
|
for (int i = 1; i <= volumeEntry.totalFiles; i++)
|
|
{
|
|
int ptr = i * CATALOG_ENTRY_SIZE;
|
|
data = new byte[CATALOG_ENTRY_SIZE];
|
|
System.arraycopy (buffer, ptr, data, 0, CATALOG_ENTRY_SIZE);
|
|
FileEntry fileEntry = new FileEntry (this, data);
|
|
|
|
fileEntries.add (fileEntry);
|
|
DefaultMutableTreeNode node = new DefaultMutableTreeNode (fileEntry);
|
|
fileEntry.setNode (node);
|
|
|
|
if (fileEntry.fileType == 2)
|
|
{
|
|
node.setAllowsChildren (true);
|
|
fileEntry.getDataSource (); // build segments
|
|
}
|
|
else
|
|
node.setAllowsChildren (false);
|
|
|
|
volumeNode.add (node);
|
|
for (int j = fileEntry.firstBlock; j < fileEntry.lastBlock; j++)
|
|
freeBlocks.set (j, false);
|
|
}
|
|
|
|
volumeNode.setUserObject (getCatalog ());
|
|
makeNodeVisible (volumeNode.getFirstLeaf ());
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
public static boolean isCorrectFormat (AppleDisk disk, boolean debug)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
disk.setInterleave (1); // should only ever be Prodos
|
|
if (checkFormat (disk, debug))
|
|
return true;
|
|
|
|
disk.setInterleave (0); // see SANE Disk 2.po
|
|
if (checkFormat (disk, debug))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
private static boolean checkFormat (AppleDisk disk, boolean debug)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
byte[] buffer = disk.readBlock (2);
|
|
int nameLength = buffer[6] & 0xFF;
|
|
if (nameLength < 1 || nameLength > 7)
|
|
{
|
|
if (debug)
|
|
System.out.println ("bad name length : " + nameLength);
|
|
return false;
|
|
}
|
|
|
|
if (debug)
|
|
{
|
|
String name = HexFormatter.getPascalString (buffer, 6);
|
|
System.out.println ("Name ok : " + name);
|
|
}
|
|
|
|
int from = Utility.getShort (buffer, 0);
|
|
int to = Utility.getShort (buffer, 2);
|
|
if (from != 0 || to != 6)
|
|
{
|
|
if (debug)
|
|
System.out.printf ("from: %d to: %d%n", from, to);
|
|
return false; // will only work for floppies!
|
|
}
|
|
|
|
int blocks = Utility.getShort (buffer, 14);
|
|
if (blocks != 280 && blocks != 1600 && blocks != 2048 && blocks != 1272)
|
|
{
|
|
if (debug)
|
|
System.out.printf ("Blocks > 280: %d%n", blocks);
|
|
return false;
|
|
}
|
|
|
|
List<DiskAddress> addresses = new ArrayList<> ();
|
|
for (int i = 2; i < to; i++)
|
|
addresses.add (disk.getDiskAddress (i));
|
|
buffer = disk.readBlocks (addresses);
|
|
|
|
int files = Utility.getShort (buffer, 16);
|
|
if (files < 0 || files > 77)
|
|
{
|
|
if (debug)
|
|
System.out.printf ("Files: %d%n", files);
|
|
return false;
|
|
}
|
|
|
|
if (debug)
|
|
System.out.println ("Files found : " + files);
|
|
|
|
for (int i = 1; i <= files; i++)
|
|
{
|
|
int ptr = i * 26;
|
|
int firstBlock = Utility.getShort (buffer, ptr);
|
|
int lastBlock = Utility.getShort (buffer, ptr + 2);
|
|
int kind = Utility.getShort (buffer, ptr + 4);
|
|
|
|
if (lastBlock < firstBlock)
|
|
{
|
|
if (debug)
|
|
System.out.printf (" %d %d lastBlock < firstBlock%n", lastBlock, firstBlock);
|
|
return false;
|
|
}
|
|
|
|
// if (kind == 0)
|
|
// {
|
|
// if (debug)
|
|
// System.out.printf (" kind = 0%n");
|
|
// return false;
|
|
// }
|
|
|
|
nameLength = buffer[ptr + 6] & 0xFF;
|
|
if (nameLength < 1 || nameLength > 15)
|
|
{
|
|
if (debug)
|
|
System.out.printf (" %d nameLength < 1 or > 15%n", nameLength);
|
|
return false;
|
|
}
|
|
|
|
int lastByte = Utility.getShort (buffer, ptr + 22);
|
|
LocalDate localDate = Utility.getPascalLocalDate (buffer, 24);
|
|
String dateString = localDate == null ? ""
|
|
: localDate.format (DateTimeFormatter.ofLocalizedDate (FormatStyle.SHORT));
|
|
if (debug)
|
|
System.out.printf ("%4d %4d %d %-15s %d %s%n", firstBlock, lastBlock, kind,
|
|
new String (buffer, ptr + 7, nameLength), lastByte, dateString);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
@Override
|
|
public DataSource getFormattedSector (DiskAddress da)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
SectorType st = sectorTypes[da.getBlockNo ()];
|
|
if (st == diskBootSector)
|
|
return bootSector;
|
|
if (st == catalogSector)
|
|
return diskCatalogSector;
|
|
String name = getSectorFilename (da);
|
|
if (name != null)
|
|
return new DefaultSector (name, disk, disk.readBlock (da), da);
|
|
return super.getFormattedSector (da);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
@Override
|
|
public String getSectorFilename (DiskAddress da)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
for (AppleFileSource ce : fileEntries)
|
|
if (((CatalogEntry) ce).contains (da))
|
|
return ((CatalogEntry) ce).name;
|
|
return null;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
@Override
|
|
public List<DiskAddress> getFileSectors (int fileNo)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
if (fileNo < 0 || fileNo >= fileEntries.size ())
|
|
return null;
|
|
return fileEntries.get (fileNo).getSectors ();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
public DataSource getFile (int fileNo)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
if (fileNo < 0 || fileNo >= fileEntries.size ())
|
|
return null;
|
|
return fileEntries.get (fileNo).getDataSource ();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
@Override
|
|
public AppleFileSource getCatalog ()
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
String newLine = String.format ("%n");
|
|
String newLine2 = newLine + newLine;
|
|
String line = "---- --------------- ---- -------- ------- ---- ---- ----"
|
|
+ newLine;
|
|
|
|
String date =
|
|
volumeEntry.localDate == null ? "--" : volumeEntry.localDate.format (dtf);
|
|
|
|
StringBuilder text = new StringBuilder ();
|
|
text.append ("File : " + getDisplayPath () + newLine2);
|
|
text.append ("Volume : " + volumeEntry.name + newLine);
|
|
text.append ("Date : " + date + newLine2);
|
|
text.append (
|
|
"Blks Name Type Date Length Frst Last Blks\n");
|
|
text.append (line);
|
|
|
|
int usedBlocks = 6;
|
|
for (AppleFileSource fe : fileEntries)
|
|
{
|
|
FileEntry ce = (FileEntry) fe;
|
|
int size = ce.lastBlock - ce.firstBlock;
|
|
usedBlocks += size;
|
|
|
|
date = ce.localDate == null ? "--" : ce.localDate.format (dtf);
|
|
|
|
int bytes = (size - 1) * 512 + ce.bytesUsedInLastBlock;
|
|
String fileType = ce.fileType < 0 || ce.fileType >= fileTypes.length ? "????"
|
|
: fileTypes[ce.fileType];
|
|
text.append (String.format ("%4d %-15s %-6s %8s %,8d $%03X $%03X $%03X%n",
|
|
size, ce.name, fileType, date, bytes, ce.firstBlock, ce.lastBlock, size));
|
|
}
|
|
|
|
text.append (line);
|
|
text.append (
|
|
String.format ("Blocks free : %3d Blocks used : %3d Total blocks : %3d%n",
|
|
(volumeEntry.totalBlocks - usedBlocks), usedBlocks, volumeEntry.totalBlocks));
|
|
|
|
return new DefaultAppleFileSource (volumeEntry.name, text.toString (), this);
|
|
}
|
|
} |