658 lines
20 KiB
Java
658 lines
20 KiB
Java
package com.bytezone.diskbrowser.applefile;
|
|
|
|
import java.util.*;
|
|
|
|
import com.bytezone.diskbrowser.HexFormatter;
|
|
|
|
public class BasicProgram extends AbstractFile
|
|
{
|
|
private static final byte ASCII_QUOTE = 0x22;
|
|
private static final byte ASCII_COLON = 0x3A;
|
|
private static final byte ASCII_SEMI_COLON = 0x3B;
|
|
|
|
private static final byte TOKEN_FOR = (byte) 0x81;
|
|
private static final byte TOKEN_NEXT = (byte) 0x82;
|
|
private static final byte TOKEN_LET = (byte) 0xAA;
|
|
private static final byte TOKEN_GOTO = (byte) 0xAB;
|
|
private static final byte TOKEN_IF = (byte) 0xAD;
|
|
private static final byte TOKEN_GOSUB = (byte) 0xB0;
|
|
private static final byte TOKEN_REM = (byte) 0xB2;
|
|
private static final byte TOKEN_PRINT = (byte) 0xBA;
|
|
private static final byte TOKEN_THEN = (byte) 0xC4;
|
|
private static final byte TOKEN_EQUALS = (byte) 0xD0;
|
|
|
|
private final List<SourceLine> sourceLines = new ArrayList<SourceLine> ();
|
|
private final int endPtr;
|
|
private final Set<Integer> gotoLines = new HashSet<Integer> ();
|
|
private final Set<Integer> gosubLines = new HashSet<Integer> ();
|
|
|
|
boolean splitRem = false; // should be a user preference
|
|
boolean alignAssign = true; // should be a user preference
|
|
boolean showTargets = true; // should be a user preference
|
|
boolean showHeader = true; // should be a user preference
|
|
boolean onlyShowTargetLineNumbers = false; // should be a user preference
|
|
int wrapPrintAt = 40;
|
|
int wrapRemAt = 60;
|
|
|
|
public BasicProgram (String name, byte[] buffer)
|
|
{
|
|
super (name, buffer);
|
|
|
|
int ptr = 0;
|
|
int prevOffset = 0;
|
|
|
|
int max = buffer.length - 4; // need at least 4 bytes to make a SourceLine
|
|
while (ptr < max)
|
|
{
|
|
int offset = HexFormatter.intValue (buffer[ptr], buffer[ptr + 1]);
|
|
if (offset <= prevOffset)
|
|
break;
|
|
|
|
SourceLine line = new SourceLine (ptr);
|
|
sourceLines.add (line);
|
|
ptr += line.length;
|
|
prevOffset = offset;
|
|
}
|
|
endPtr = ptr;
|
|
}
|
|
|
|
@Override
|
|
public String getText ()
|
|
{
|
|
StringBuilder fullText = new StringBuilder ();
|
|
Stack<String> loopVariables = new Stack<String> ();
|
|
if (showHeader)
|
|
addHeader (fullText);
|
|
int alignPos = 0;
|
|
StringBuilder text;
|
|
int baseOffset = showTargets ? 12 : 8;
|
|
|
|
for (SourceLine line : sourceLines)
|
|
{
|
|
text = new StringBuilder (getBase (line) + " ");
|
|
|
|
int indent = loopVariables.size (); // each full line starts at the loop indent
|
|
int ifIndent = 0; // IF statement(s) limit back indentation by NEXT
|
|
|
|
for (SubLine subline : line.sublines)
|
|
{
|
|
// Allow empty statements (caused by a single colon)
|
|
if (subline.isEmpty ())
|
|
continue;
|
|
|
|
// A REM statement might conceal an assembler routine - see P.CREATE on Diags2E.DSK
|
|
if (subline.is (TOKEN_REM) && subline.containsToken ())
|
|
{
|
|
int address = subline.getAddress () + 1; // skip the REM token
|
|
fullText.append (text
|
|
+ String.format ("REM - Inline assembler @ $%02X (%d)%n", address, address));
|
|
String padding = " ".substring (0, text.length () + 2);
|
|
for (String asm : subline.getAssembler ())
|
|
fullText.append (padding + asm + "\n");
|
|
continue;
|
|
}
|
|
|
|
// Reduce the indent by each NEXT, but only as far as the IF indent allows
|
|
if (subline.is (TOKEN_NEXT))
|
|
{
|
|
popLoopVariables (loopVariables, subline);
|
|
indent = Math.max (ifIndent, loopVariables.size ());
|
|
}
|
|
|
|
// Are we joining REM lines with the previous subline?
|
|
if (!splitRem && subline.isJoinableRem ())
|
|
{
|
|
// Join this REM statement to the previous line, so no indenting
|
|
fullText.deleteCharAt (fullText.length () - 1); // remove newline
|
|
fullText.append (" ");
|
|
}
|
|
// ... otherwise do all the indenting and showing of targets etc.
|
|
else
|
|
{
|
|
// Prepare target indicators for subsequent sublines (ie no line number)
|
|
if (showTargets && !subline.isFirst ())
|
|
if (subline.is (TOKEN_GOSUB))
|
|
text.append ("<<--");
|
|
else if (subline.is (TOKEN_GOTO) || subline.isImpliedGoto ())
|
|
text.append (" <--");
|
|
|
|
// Align assign statements if required
|
|
if (alignAssign)
|
|
alignPos = alignEqualsPosition (subline, alignPos);
|
|
|
|
int column = indent * 2 + baseOffset;
|
|
while (text.length () < column)
|
|
text.append (" ");
|
|
}
|
|
|
|
// Add the current text, then reset it
|
|
int pos = subline.is (TOKEN_REM) ? 0 : alignPos;
|
|
String lineText = subline.getAlignedText (pos);
|
|
|
|
// if (subline.is (TOKEN_REM) && lineText.length () > wrapRemAt + 4)
|
|
// {
|
|
// System.out.println (subline.getAlignedText (pos));
|
|
// String copy = lineText.substring (4);
|
|
// text.append ("REM ");
|
|
// int inset = text.length ();
|
|
// System.out.println (inset);
|
|
// List<String> remarks = splitRemark (copy, wrapRemAt);
|
|
// for (String remark : remarks)
|
|
// text.append (" ".substring (0, inset) + remark);
|
|
// }
|
|
// else
|
|
text.append (lineText);
|
|
|
|
// Check for a wrapable PRINT statement (see FROM MACHINE LANGUAGE TO BASIC on DOSToolkit2eB.dsk)
|
|
if (subline.is (TOKEN_PRINT) && wrapPrintAt > 0 && countChars (text, ASCII_QUOTE) == 2
|
|
&& countChars (text, ASCII_SEMI_COLON) == 0)
|
|
{
|
|
int first = text.indexOf ("\"");
|
|
int last = text.indexOf ("\"", first + 1);
|
|
if ((last - first) > wrapPrintAt)
|
|
{
|
|
int ptr = first + wrapPrintAt;
|
|
do
|
|
{
|
|
fullText.append (text.substring (0, ptr)
|
|
+ "\n ".substring (0, first + 1));
|
|
text.delete (0, ptr);
|
|
ptr = wrapPrintAt;
|
|
} while (text.length () > wrapPrintAt);
|
|
}
|
|
}
|
|
|
|
fullText.append (text + "\n");
|
|
text.setLength (0);
|
|
|
|
// Calculate indent changes that take effect after the current subline
|
|
if (subline.is (TOKEN_IF))
|
|
ifIndent = ++indent;
|
|
else if (subline.is (TOKEN_FOR))
|
|
{
|
|
loopVariables.push (subline.forVariable);
|
|
++indent;
|
|
}
|
|
}
|
|
|
|
// Reset the alignment value if we just left an IF - the indentation will be different now.
|
|
if (ifIndent > 0)
|
|
alignPos = 0;
|
|
}
|
|
|
|
fullText.deleteCharAt (fullText.length () - 1); // remove last newline
|
|
return fullText.toString ();
|
|
}
|
|
|
|
private List<String> splitRemark (String remark, int wrapLength)
|
|
{
|
|
List<String> remarks = new ArrayList<String> ();
|
|
while (remark.length () > wrapLength)
|
|
{
|
|
int max = Math.min (wrapLength, remark.length () - 1);
|
|
while (max > 0 && remark.charAt (max) != ' ')
|
|
--max;
|
|
System.out.println (remark.substring (0, max));
|
|
remarks.add (remark.substring (0, max) + "\n");
|
|
if (max == 0)
|
|
break;
|
|
remark = remark.substring (max + 1);
|
|
}
|
|
remarks.add (remark);
|
|
System.out.println (remark);
|
|
return remarks;
|
|
}
|
|
|
|
private int countChars (StringBuilder text, byte ch)
|
|
{
|
|
int total = 0;
|
|
for (int i = 0; i < text.length (); i++)
|
|
if (text.charAt (i) == ch)
|
|
total++;
|
|
return total;
|
|
}
|
|
|
|
private String getBase (SourceLine line)
|
|
{
|
|
if (!showTargets)
|
|
return String.format (" %5d", line.lineNumber);
|
|
|
|
String lineNumberText = String.format ("%5d", line.lineNumber);
|
|
SubLine subline = line.sublines.get (0);
|
|
String c1 = " ", c2 = " ";
|
|
if (subline.is (TOKEN_GOSUB))
|
|
c1 = "<<";
|
|
if (subline.is (TOKEN_GOTO))
|
|
c1 = " <";
|
|
if (gotoLines.contains (line.lineNumber))
|
|
c2 = "> ";
|
|
if (gosubLines.contains (line.lineNumber))
|
|
c2 = ">>";
|
|
if (c1.equals (" ") && !c2.equals (" "))
|
|
c1 = "--";
|
|
if (!c1.equals (" ") && c2.equals (" "))
|
|
c2 = "--";
|
|
if (onlyShowTargetLineNumbers && !c2.startsWith (">"))
|
|
lineNumberText = "";
|
|
return String.format ("%s%s %s", c1, c2, lineNumberText);
|
|
}
|
|
|
|
// Decide whether the current subline needs to be aligned on its equals sign. If so,
|
|
// and the column hasn't been calculated, read ahead to find the highest position.
|
|
private int alignEqualsPosition (SubLine subline, int currentAlignPosition)
|
|
{
|
|
if (subline.assignEqualPos > 0) // does the line have an equals sign?
|
|
{
|
|
if (currentAlignPosition == 0)
|
|
currentAlignPosition = findHighest (subline); // examine following sublines for alignment
|
|
return currentAlignPosition;
|
|
}
|
|
return 0; // reset it
|
|
}
|
|
|
|
// The IF processing is so that any assignment that is being aligned doesn't continue
|
|
// to the next full line (because the indentation has changed).
|
|
private int findHighest (SubLine startSubline)
|
|
{
|
|
boolean started = false;
|
|
int highestAssign = startSubline.assignEqualPos;
|
|
fast: for (SourceLine line : sourceLines)
|
|
{
|
|
boolean inIf = false;
|
|
for (SubLine subline : line.sublines)
|
|
{
|
|
if (started)
|
|
{
|
|
// Stop when we come to a line without an equals sign (except for non-split REMs).
|
|
// Lines that start with a REM always break.
|
|
if (subline.assignEqualPos == 0
|
|
// && (splitRem || !subline.is (TOKEN_REM) || subline.isFirst ()))
|
|
&& (splitRem || !subline.isJoinableRem ()))
|
|
break fast; // of champions
|
|
|
|
if (subline.assignEqualPos > highestAssign)
|
|
highestAssign = subline.assignEqualPos;
|
|
}
|
|
else if (subline == startSubline)
|
|
started = true;
|
|
else if (subline.is (TOKEN_IF))
|
|
inIf = true;
|
|
}
|
|
if (started && inIf)
|
|
break;
|
|
}
|
|
return highestAssign;
|
|
}
|
|
|
|
@Override
|
|
public String getHexDump ()
|
|
{
|
|
if (buffer.length < 2)
|
|
return super.getHexDump ();
|
|
|
|
StringBuilder pgm = new StringBuilder ();
|
|
if (showHeader)
|
|
addHeader (pgm);
|
|
|
|
int ptr = 0;
|
|
int offset = HexFormatter.intValue (buffer[0], buffer[1]);
|
|
int programLoadAddress = offset - getLineLength (0);
|
|
|
|
while (ptr <= endPtr) // stop at the same place as the source listing
|
|
{
|
|
int length = getLineLength (ptr);
|
|
if (length == 0)
|
|
{
|
|
pgm.append (HexFormatter.formatNoHeader (buffer, ptr, 2, programLoadAddress));
|
|
ptr += 2;
|
|
break;
|
|
}
|
|
|
|
if (ptr + length < buffer.length)
|
|
pgm.append (HexFormatter.formatNoHeader (buffer, ptr, length, programLoadAddress)
|
|
+ "\n\n");
|
|
ptr += length;
|
|
}
|
|
|
|
if (ptr < buffer.length)
|
|
{
|
|
int length = buffer.length - ptr;
|
|
pgm.append ("\n\n");
|
|
pgm.append (HexFormatter.formatNoHeader (buffer, ptr, length, programLoadAddress));
|
|
}
|
|
|
|
return pgm.toString ();
|
|
}
|
|
|
|
private void addHeader (StringBuilder pgm)
|
|
{
|
|
pgm.append ("Name : " + name + "\n");
|
|
pgm.append ("Length : $" + HexFormatter.format4 (buffer.length));
|
|
pgm.append (" (" + buffer.length + ")\n");
|
|
|
|
int programLoadAddress = getLoadAddress ();
|
|
pgm.append ("Load at : $" + HexFormatter.format4 (programLoadAddress));
|
|
pgm.append (" (" + programLoadAddress + ")\n\n");
|
|
}
|
|
|
|
private int getLoadAddress ()
|
|
{
|
|
int programLoadAddress = 0;
|
|
if (buffer.length > 1)
|
|
{
|
|
int offset = HexFormatter.intValue (buffer[0], buffer[1]);
|
|
programLoadAddress = offset - getLineLength (0);
|
|
}
|
|
return programLoadAddress;
|
|
}
|
|
|
|
private int getLineLength (int ptr)
|
|
{
|
|
int offset = HexFormatter.intValue (buffer[ptr], buffer[ptr + 1]);
|
|
if (offset == 0)
|
|
return 0;
|
|
ptr += 4;
|
|
int length = 5;
|
|
|
|
while (ptr < buffer.length && buffer[ptr++] != 0)
|
|
length++;
|
|
|
|
return length;
|
|
}
|
|
|
|
private void popLoopVariables (Stack<String> loopVariables, SubLine subline)
|
|
{
|
|
if (subline.nextVariables.length == 0) // naked NEXT
|
|
{
|
|
if (loopVariables.size () > 0)
|
|
loopVariables.pop ();
|
|
}
|
|
else
|
|
for (String variable : subline.nextVariables)
|
|
// e.g. NEXT X,Y,Z
|
|
while (loopVariables.size () > 0)
|
|
if (sameVariable (variable, loopVariables.pop ()))
|
|
break;
|
|
}
|
|
|
|
private boolean sameVariable (String v1, String v2)
|
|
{
|
|
if (v1.equals (v2))
|
|
return true;
|
|
if (v1.length () >= 2 && v2.length () >= 2 && v1.charAt (0) == v2.charAt (0)
|
|
&& v1.charAt (1) == v2.charAt (1))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
private class SourceLine
|
|
{
|
|
List<SubLine> sublines = new ArrayList<SubLine> ();
|
|
int lineNumber;
|
|
int linePtr;
|
|
int length;
|
|
|
|
public SourceLine (int ptr)
|
|
{
|
|
linePtr = ptr;
|
|
lineNumber = HexFormatter.intValue (buffer[ptr + 2], buffer[ptr + 3]);
|
|
|
|
int startPtr = ptr += 4;
|
|
boolean inString = false; // can toggle
|
|
boolean inRemark = false; // can only go false -> true
|
|
byte b;
|
|
|
|
while ((b = buffer[ptr++]) != 0)
|
|
{
|
|
switch (b)
|
|
{
|
|
// break IF statements into two sublines (allows for easier line indenting)
|
|
case TOKEN_IF:
|
|
if (!inString && !inRemark)
|
|
{
|
|
// skip to THEN or GOTO - if not found then it's an error
|
|
while (buffer[ptr] != TOKEN_THEN && buffer[ptr] != TOKEN_GOTO
|
|
&& buffer[ptr] != 0)
|
|
ptr++;
|
|
|
|
// keep THEN with the IF
|
|
if (buffer[ptr] == TOKEN_THEN)
|
|
++ptr;
|
|
|
|
// create subline from the condition (and THEN if it exists)
|
|
sublines.add (new SubLine (this, startPtr, ptr - startPtr));
|
|
startPtr = ptr;
|
|
}
|
|
break;
|
|
|
|
// end of subline, so add it, advance startPtr and continue
|
|
case ASCII_COLON:
|
|
if (!inString && !inRemark)
|
|
{
|
|
sublines.add (new SubLine (this, startPtr, ptr - startPtr));
|
|
startPtr = ptr;
|
|
}
|
|
break;
|
|
|
|
case TOKEN_REM:
|
|
if (!inString && !inRemark)
|
|
inRemark = true;
|
|
break;
|
|
|
|
case ASCII_QUOTE:
|
|
if (!inRemark)
|
|
inString = !inString;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// add whatever is left
|
|
sublines.add (new SubLine (this, startPtr, ptr - startPtr));
|
|
this.length = ptr - linePtr;
|
|
}
|
|
}
|
|
|
|
private class SubLine
|
|
{
|
|
SourceLine parent;
|
|
int startPtr;
|
|
int length;
|
|
String[] nextVariables;
|
|
String forVariable = "";
|
|
int targetLine = -1;
|
|
|
|
// used for aligning the equals sign
|
|
int assignEqualPos;
|
|
|
|
public SubLine (SourceLine parent, int startPtr, int length)
|
|
{
|
|
this.parent = parent;
|
|
this.startPtr = startPtr;
|
|
this.length = length;
|
|
|
|
byte b = buffer[startPtr];
|
|
if ((b & 0x80) > 0) // token
|
|
{
|
|
switch (b)
|
|
{
|
|
case TOKEN_FOR:
|
|
int p = startPtr + 1;
|
|
while (buffer[p] != TOKEN_EQUALS)
|
|
forVariable += (char) buffer[p++];
|
|
break;
|
|
|
|
case TOKEN_NEXT:
|
|
if (length == 2) // no variables
|
|
nextVariables = new String[0];
|
|
else
|
|
{
|
|
String varList = new String (buffer, startPtr + 1, length - 2);
|
|
nextVariables = varList.split (",");
|
|
}
|
|
break;
|
|
|
|
case TOKEN_LET:
|
|
recordEqualsPosition ();
|
|
break;
|
|
|
|
case TOKEN_GOTO:
|
|
String target = new String (buffer, startPtr + 1, length - 2);
|
|
try
|
|
{
|
|
gotoLines.add (Integer.parseInt (target));
|
|
}
|
|
catch (NumberFormatException e)
|
|
{
|
|
System.out.println ("Error parsing : GOTO " + target + " in "
|
|
+ parent.lineNumber);
|
|
}
|
|
break;
|
|
|
|
case TOKEN_GOSUB:
|
|
String target2 = new String (buffer, startPtr + 1, length - 2);
|
|
try
|
|
{
|
|
gosubLines.add (Integer.parseInt (target2));
|
|
}
|
|
catch (NumberFormatException e)
|
|
{
|
|
System.out.println ("Error parsing : GOSUB " + target2 + " in "
|
|
+ parent.lineNumber);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (b >= 48 && b <= 57) // numeric, so must be a line number
|
|
{
|
|
String target = new String (buffer, startPtr, length - 1);
|
|
try
|
|
{
|
|
targetLine = Integer.parseInt (target);
|
|
gotoLines.add (targetLine);
|
|
}
|
|
catch (NumberFormatException e)
|
|
{
|
|
System.out.println (target);
|
|
System.out.println (HexFormatter.format (buffer, startPtr, length - 1));
|
|
System.out.println (e.toString ());
|
|
}
|
|
}
|
|
else if (alignAssign)
|
|
recordEqualsPosition ();
|
|
}
|
|
}
|
|
|
|
private boolean isImpliedGoto ()
|
|
{
|
|
byte b = buffer[startPtr];
|
|
if ((b & 0x80) > 0) // token
|
|
return false;
|
|
return (b >= 48 && b <= 57);
|
|
}
|
|
|
|
// Record the position of the equals sign so it can be aligned with adjacent lines.
|
|
private void recordEqualsPosition ()
|
|
{
|
|
int p = startPtr + 1;
|
|
int max = startPtr + length;
|
|
while (buffer[p] != TOKEN_EQUALS && p < max)
|
|
p++;
|
|
if (buffer[p] == TOKEN_EQUALS)
|
|
assignEqualPos = toString ().indexOf ('='); // use expanded line
|
|
}
|
|
|
|
private boolean isJoinableRem ()
|
|
{
|
|
return is (TOKEN_REM) && !isFirst ();
|
|
}
|
|
|
|
public boolean isFirst ()
|
|
{
|
|
return (parent.linePtr + 4) == startPtr;
|
|
}
|
|
|
|
public boolean is (byte token)
|
|
{
|
|
return buffer[startPtr] == token;
|
|
}
|
|
|
|
public boolean isEmpty ()
|
|
{
|
|
return length == 1 && buffer[startPtr] == 0;
|
|
}
|
|
|
|
public boolean containsToken ()
|
|
{
|
|
// ignore first byte, check the rest for tokens
|
|
for (int p = startPtr + 1, max = startPtr + length; p < max; p++)
|
|
if ((buffer[p] & 0x80) > 0)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
public int getAddress ()
|
|
{
|
|
return getLoadAddress () + startPtr;
|
|
}
|
|
|
|
public String getAlignedText (int alignPosition)
|
|
{
|
|
StringBuilder line = toStringBuilder ();
|
|
|
|
while (alignPosition-- > assignEqualPos)
|
|
line.insert (assignEqualPos, ' ');
|
|
|
|
return line.toString ();
|
|
}
|
|
|
|
// A REM statement might conceal an assembler routine
|
|
public String[] getAssembler ()
|
|
{
|
|
byte[] buffer2 = new byte[length - 1];
|
|
System.arraycopy (buffer, startPtr + 1, buffer2, 0, buffer2.length);
|
|
AssemblerProgram program =
|
|
new AssemblerProgram ("REM assembler", buffer2, getAddress () + 1);
|
|
return program.getAssembler ().split ("\n");
|
|
}
|
|
|
|
@Override
|
|
public String toString ()
|
|
{
|
|
return toStringBuilder ().toString ();
|
|
}
|
|
|
|
public StringBuilder toStringBuilder ()
|
|
{
|
|
StringBuilder line = new StringBuilder ();
|
|
|
|
// All sublines end with 0 or : except IF lines that are split into two
|
|
int max = startPtr + length - 1;
|
|
if (buffer[max] == 0)
|
|
--max;
|
|
|
|
for (int p = startPtr; p <= max; p++)
|
|
{
|
|
byte b = buffer[p];
|
|
if ((b & 0x80) > 0) // token
|
|
{
|
|
if (line.length () > 0 && line.charAt (line.length () - 1) != ' ')
|
|
line.append (' ');
|
|
int val = b & 0x7F;
|
|
if (val < ApplesoftConstants.tokens.length)
|
|
line.append (ApplesoftConstants.tokens[b & 0x7F]);
|
|
// else
|
|
// System.out.println ("Bad value : " + val + " " + line.toString () + " "
|
|
// + parent.lineNumber);
|
|
}
|
|
else if (b < 32) // CTRL character
|
|
line.append ("^" + (char) (b + 64)); // would be better in inverse text
|
|
else
|
|
line.append ((char) b);
|
|
}
|
|
|
|
return line;
|
|
}
|
|
}
|
|
} |