645 lines
19 KiB
Java
645 lines
19 KiB
Java
package com.bytezone.diskbrowser.visicalc;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.TreeMap;
|
|
import java.util.regex.Matcher;
|
|
import java.util.regex.Pattern;
|
|
|
|
import com.bytezone.diskbrowser.utilities.HexFormatter;
|
|
import com.bytezone.diskbrowser.visicalc.Cell.CellType;
|
|
|
|
// -----------------------------------------------------------------------------------//
|
|
public class Sheet
|
|
// -----------------------------------------------------------------------------------//
|
|
{
|
|
private static final Pattern addressPattern =
|
|
Pattern.compile ("([AB]?[A-Z])([0-9]{1,3}):");
|
|
private static final byte END_OF_LINE_TOKEN = (byte) 0x8D;
|
|
private static final int FORMAT_LENGTH = 3;
|
|
|
|
private final Map<Integer, Cell> rowOrderCells = new TreeMap<Integer, Cell> ();
|
|
private final Map<Integer, Cell> columnOrderCells = new TreeMap<Integer, Cell> ();
|
|
private final List<String> lines = new ArrayList<> ();
|
|
|
|
private final Map<Integer, Integer> columnWidths = new TreeMap<Integer, Integer> ();
|
|
private int columnWidth = 9;
|
|
|
|
private char globalFormat = ' ';
|
|
private char recalculation = 'A'; // auto/manual
|
|
private char recalculationOrder = 'C'; // row/column
|
|
|
|
private int minColumn = 9999;
|
|
private int maxColumn;
|
|
private int minRow = 9999;
|
|
private int maxRow;
|
|
|
|
int[] functionTotals = new int[Function.functionList.length];
|
|
|
|
// Maximum cell = BK254
|
|
|
|
//Commands:
|
|
// /G<address> goto
|
|
// /B blank the cell
|
|
// /C clear and home
|
|
// A-Z label (" to force a label)
|
|
// 0-9.+-()*/@# value (+ to force a value)
|
|
|
|
// /S Storage (ISLDWR)
|
|
// /SI Storage init
|
|
// /SS Storage Save
|
|
// /SL Storage Load
|
|
// /SD Storage Delete
|
|
// /SW Storage Write (to cassette)
|
|
// /SR Storage Read (from cassette)
|
|
|
|
// /R Replicate
|
|
|
|
// /G Global (CORF)
|
|
// /GF Global Format (DGILR$*)
|
|
// /GFI Global Format Integer
|
|
// /GF$ Global Format Currency
|
|
// /GC Global Column <width> 3-37
|
|
// /GR Global Recalculation A/M
|
|
// /GRA Recalculation Auto
|
|
// /GO Global Calculation Order C/R
|
|
// /GOC Calculation Order - Columns first
|
|
// /GOR Calculation Order - Rows first
|
|
|
|
// /T Titles (HVBN)
|
|
// /TH fix Horizontal Titles
|
|
// /TV fix Vertical Titles
|
|
// /TB fix Both Titles
|
|
// /TN fix Neither
|
|
|
|
// /W Window split (HV1SU)
|
|
// /WV Window Vertical (split on cursor column)
|
|
// /WH Window Horizontal (split on cursor row)
|
|
// /W1 Window (return to single window)
|
|
// /WS Window (synchronised)
|
|
// /WU Window (unsynchronised)
|
|
|
|
/*
|
|
from: Apple II TextFiles
|
|
http://www.textfiles.com/apple/
|
|
|
|
|
|
*----------------------*
|
|
VISICALC COMMAND CHART
|
|
BY: NIGHT HAWK
|
|
*----------------------*
|
|
|
|
/B SET AN ENTRY TO BLANK
|
|
|
|
/C CLEARS THE SHEET, SETTING ALL ENTRIES TO BLANK
|
|
|
|
/D DELETE
|
|
/DR THE ROW
|
|
/DC COLUMN ON WHICH THE CURSOR LIES
|
|
|
|
/E ALLOWS EDITING OF THE ENTRY CONTENTS OF ANY ENTRY POSITION
|
|
BY REDISPLAYING IT ON THE EDIT LINE. USE <- -> KEYS & ESC.
|
|
|
|
/F FORMATS:
|
|
/FG GENERAL
|
|
/FI INTEGER
|
|
/F$ DOLLAR AND CENTS
|
|
/FL LEFT JUSTIFIED
|
|
/FR RIGHT JUSTIFIED
|
|
/F* GRAPH
|
|
/FD DEFAULT
|
|
|
|
/G GLOBAL COMMANDS. THESE APPLY TO THE ENTIRE SHEET OR WINDOW.
|
|
/GC SETS COLUMN WIDTH
|
|
/GF SETS THE GLOBAL DEFAULT FORMAT
|
|
/GO SETS THE ORDER OF RECALCULATION TO BE DOWN THE
|
|
COLUMNS OR ACROSS THE ROWS
|
|
/GR SETS RECALCULATION TO BE AUTOMATIC(/GRA) OR MANUAL(/GRM).
|
|
|
|
/I INSERTS A ROW(/IR) OR A COLUMN(/IC)
|
|
/M MOVES AN ENTIRE ROW OR COLUMN TO A NEW POSITION.
|
|
/P PRINT COMMAND
|
|
/R REPLICATE COMMAND
|
|
|
|
/S STORAGE COMMANDS
|
|
/SS SAVE
|
|
/SL LOAD (left/right arrow to scroll through catalog)
|
|
/SD DELETES SPECIFIED FILE ON DISK
|
|
/SI INITIALIZE A DISK ON SPECIFIED DRIVE
|
|
/SQ QUITS VISICALC
|
|
|
|
/T
|
|
/TH SETS A HORIZONTAL TITLE AREA
|
|
/TV SETS A VERTICAL TITLE AREA
|
|
/TB SET BOTH A HORIZONTAL & VERTICAL TITLE AREA
|
|
/TN RESETS THE WINDOWS TO HAVE NO TITLE AREAS
|
|
|
|
/V DISPLAYS VISICALC'S VERSION NUMBER ON THE PROMPT LINE
|
|
/W WINDOW CONTROL
|
|
/WH HORIZONTAL WINDOW
|
|
/WV VERTICAL WINDOW
|
|
/W1 RETURNS SCREEN TO ONE WINDOW
|
|
/WS SYNCHRONIZED WINDOWS
|
|
/WU UNSYNCHRONIZED
|
|
|
|
/- REPEATING LABEL
|
|
*/
|
|
|
|
// /X!/X>A3:>A7: A3:top-left cell in window, A7:cell to place cursor
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
public Sheet (byte[] buffer)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
int last = buffer.length;
|
|
while (buffer[--last] == 0) // ignore trailing zeroes
|
|
;
|
|
|
|
int ptr = 0;
|
|
while (ptr < last)
|
|
{
|
|
int length = getLineLength (buffer, ptr);
|
|
String line = HexFormatter.getString (buffer, ptr, length);
|
|
assert !line.isEmpty ();
|
|
lines.add (line);
|
|
|
|
// System.out.println (line);
|
|
|
|
if (line.startsWith ("/"))
|
|
doFormat (line);
|
|
else if (line.startsWith (">")) // GOTO cell
|
|
processLine (line);
|
|
else
|
|
System.out.printf ("Error [%s]%n", line);
|
|
|
|
ptr += length + 1; // +1 for end-of-line token
|
|
}
|
|
|
|
// might have to keep recalculating until nothing changes??
|
|
calculate (recalculationOrder);
|
|
if (false)
|
|
{
|
|
for (Cell cell : rowOrderCells.values ())
|
|
cell.reset ();
|
|
calculate (recalculationOrder);
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
private void calculate (char order)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
Map<Integer, Cell> cells = order == 'R' ? rowOrderCells : columnOrderCells;
|
|
for (Cell cell : cells.values ())
|
|
if (cell.isCellType (CellType.VALUE))
|
|
cell.calculate ();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
private int getLineLength (byte[] buffer, int offset)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
int ptr = offset;
|
|
while (buffer[ptr] != END_OF_LINE_TOKEN)
|
|
ptr++;
|
|
return ptr - offset;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
private void processLine (String line)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
Cell currentCell = null;
|
|
|
|
Matcher m = addressPattern.matcher (line); // <cell address>:<contents>
|
|
if (m.find ())
|
|
{
|
|
Address address = new Address (m.group (1), m.group (2));
|
|
currentCell = rowOrderCells.get (address.getRowKey ());
|
|
|
|
int pos = line.indexOf (':'); // end of cell address
|
|
line = line.substring (pos + 1); // remove address from line
|
|
|
|
if (currentCell == null)
|
|
{
|
|
currentCell = new Cell (this, address);
|
|
if (!line.startsWith ("/G"))
|
|
addCell (currentCell);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
System.out.printf ("Invalid cell address: %s%n", line);
|
|
return;
|
|
}
|
|
|
|
assert currentCell != null;
|
|
|
|
if (line.startsWith ("/G")) // global column widths
|
|
{
|
|
if (line.charAt (2) == 'C' && line.charAt (3) == 'C')
|
|
{
|
|
int width = Integer.parseInt (line.substring (4));
|
|
columnWidths.put (currentCell.getAddress ().getColumn (), width);
|
|
}
|
|
else
|
|
System.out.printf ("Unknown Global:[%s]%n", line);
|
|
|
|
return;
|
|
}
|
|
|
|
// check for formatting commands
|
|
while (line.startsWith ("/"))
|
|
{
|
|
if (line.charAt (1) == '-') // repeating label
|
|
{
|
|
currentCell.setFormat (line);
|
|
line = "";
|
|
}
|
|
else
|
|
{
|
|
currentCell.setFormat (line.substring (0, FORMAT_LENGTH));
|
|
line = line.substring (FORMAT_LENGTH);
|
|
}
|
|
}
|
|
|
|
// if there is anything left it must be an expression
|
|
if (!line.isEmpty ())
|
|
currentCell.setValue (line); // expression
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
private void addCell (Cell cell)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
rowOrderCells.put (cell.getAddress ().getRowKey (), cell);
|
|
columnOrderCells.put (cell.getAddress ().getColumnKey (), cell);
|
|
|
|
minRow = Math.min (minRow, cell.getAddress ().getRow ());
|
|
minColumn = Math.min (minColumn, cell.getAddress ().getColumn ());
|
|
|
|
maxRow = Math.max (maxRow, cell.getAddress ().getRow ());
|
|
maxColumn = Math.max (maxColumn, cell.getAddress ().getColumn ());
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
Cell getCell (String addressText)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
return getCell (new Address (addressText));
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
Cell getCell (Address address)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
Cell cell = rowOrderCells.get (address.getRowKey ());
|
|
if (cell == null)
|
|
{
|
|
cell = new Cell (this, address);
|
|
addCell (cell);
|
|
}
|
|
return cell;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
boolean cellExists (Address address)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
return rowOrderCells.get (address.getRowKey ()) != null;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
public int size ()
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
return rowOrderCells.size ();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
private void doFormat (String line)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
switch (line.charAt (1))
|
|
{
|
|
case 'G':
|
|
setGlobal (line);
|
|
break;
|
|
case 'W':
|
|
break;
|
|
case 'X':
|
|
break;
|
|
default:
|
|
System.out.printf ("Skipping [%s]%n", line);
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
private void setGlobal (String line)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
switch (line.charAt (2))
|
|
{
|
|
case 'C':
|
|
columnWidth = Integer.parseInt (line.substring (3));
|
|
break;
|
|
case 'O':
|
|
recalculationOrder = line.charAt (3);
|
|
break;
|
|
case 'R':
|
|
recalculation = line.charAt (3);
|
|
break;
|
|
case 'F':
|
|
globalFormat = line.charAt (3);
|
|
break;
|
|
case 'P':
|
|
// System.out.printf ("Skipping [%s]%n", line);
|
|
break;
|
|
default:
|
|
System.out.printf ("Unknown global format [%s]%n", line);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
public String getTextDisplay (boolean debug)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
StringBuilder text = new StringBuilder ();
|
|
String longLine;
|
|
if (false)
|
|
longLine = "%+++++++++++++++++++++++++++++++++++++++++++++++++++++++"
|
|
+ "++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++";
|
|
else
|
|
longLine = " "
|
|
+ " ";
|
|
String underline = "---------------------------------------------------------"
|
|
+ "-----------------------------------------------------------------";
|
|
// String left = "";
|
|
// String right = "";
|
|
// if (columnWidth > 2)
|
|
// {
|
|
// left = underline.substring (0, (columnWidth - 2) / 2);
|
|
// right = underline.substring (0, columnWidth - 3 - left.length ()) + "+";
|
|
// }
|
|
|
|
int lastRow = 0;
|
|
int lastColumn = 0;
|
|
|
|
StringBuilder heading = new StringBuilder (" ");
|
|
for (int column = 0; column <= maxColumn; column++)
|
|
{
|
|
int width = columnWidth;
|
|
if (columnWidths.containsKey (column))
|
|
width = columnWidths.get (column);
|
|
|
|
char letter1 = column < 26 ? '-' : column < 52 ? 'A' : 'B';
|
|
char letter2 = (char) ((column % 26) + 'A');
|
|
|
|
if (width == 1)
|
|
heading.append (letter2);
|
|
else if (width == 2)
|
|
heading.append (String.format ("%s%s", letter1, letter2));
|
|
else
|
|
{
|
|
String fmt =
|
|
String.format ("%s%s%%%d.%ds", letter1, letter2, (width - 2), (width - 2));
|
|
heading.append (String.format (fmt, underline));
|
|
// heading.append (left);
|
|
// heading.append (String.format ("%s%s", letter1, letter2));
|
|
// heading.append (right);
|
|
}
|
|
}
|
|
|
|
if (debug)
|
|
{
|
|
List<String> counts = new ArrayList<> ();
|
|
for (int i = 0; i < functionTotals.length; i++)
|
|
if (functionTotals[i] > 0)
|
|
{
|
|
String name = Function.functionList[i];
|
|
if (name.endsWith ("("))
|
|
name = name.substring (0, name.length () - 1);
|
|
counts.add (String.format ("%-10s%d", name, functionTotals[i]));
|
|
}
|
|
|
|
while (counts.size () < 18)
|
|
counts.add ("");
|
|
|
|
text.append (String.format ("+%-83.83s+%n", underline));
|
|
text.append (String.format ("| Global format : %-18s %-14s %-14s %-14s |%n",
|
|
globalFormat, counts.get (0), counts.get (6), counts.get (12)));
|
|
text.append (String.format ("| Column width : %-2d %-15s %-14s %-14s %-14s |%n",
|
|
columnWidth, "", counts.get (1), counts.get (7), counts.get (13)));
|
|
text.append (String.format ("| Recalc order : %-18s %-14s %-14s %-14s |%n",
|
|
recalculationOrder == 'R' ? "Row" : "Column", counts.get (2), counts.get (8),
|
|
counts.get (14)));
|
|
text.append (String.format ("| Recalculation : %-18s %-14s %-14s %-14s |%n",
|
|
recalculation == 'A' ? "Automatic" : "Manual", counts.get (3), counts.get (9),
|
|
counts.get (15)));
|
|
text.append (String.format ("| Cells : %-5d %-11s %-14s %-14s %-14s |%n",
|
|
size (), "", counts.get (4), counts.get (10), counts.get (16)));
|
|
|
|
String rangeText = size () > 0 ? Address.getCellName (minRow + 1, minColumn) + ":"
|
|
+ Address.getCellName (maxRow + 1, maxColumn) : "";
|
|
text.append (String.format ("| Range : %-18s %-14s %-14s %-14s |%n",
|
|
rangeText, counts.get (5), counts.get (11), counts.get (17)));
|
|
text.append (String.format ("+%-83.83s+%n", underline));
|
|
}
|
|
|
|
if (debug)
|
|
{
|
|
text.append (heading);
|
|
text.append ("\n001:");
|
|
}
|
|
|
|
for (Cell cell : rowOrderCells.values ())
|
|
{
|
|
Address cellAddress = cell.getAddress ();
|
|
|
|
// insert newlines for empty rows
|
|
while (lastRow < cellAddress.getRow ())
|
|
{
|
|
++lastRow;
|
|
lastColumn = 0;
|
|
if (debug)
|
|
text.append (String.format ("%n%03d:", lastRow + 1));
|
|
else
|
|
text.append ("\n");
|
|
}
|
|
|
|
// pad out empty columns
|
|
while (lastColumn < cellAddress.getColumn ())
|
|
{
|
|
int width = columnWidth;
|
|
if (columnWidths.containsKey (lastColumn))
|
|
width = columnWidths.get (lastColumn);
|
|
text.append (longLine.substring (0, width));
|
|
++lastColumn;
|
|
}
|
|
|
|
++lastColumn;
|
|
|
|
int colWidth = columnWidth;
|
|
if (columnWidths.containsKey (cellAddress.getColumn ()))
|
|
colWidth = columnWidths.get (cellAddress.getColumn ());
|
|
|
|
text.append (cell.getFormattedText (colWidth, globalFormat));
|
|
}
|
|
|
|
if (debug)
|
|
{
|
|
text.append ("\n\n");
|
|
int last = -1;
|
|
for (Cell cell : columnOrderCells.values ())
|
|
{
|
|
if (last < cell.getAddress ().getColumn ())
|
|
{
|
|
String columnName = Address.getCellName (1, cell.getAddress ().getColumn ());
|
|
columnName = columnName.substring (0, columnName.length () - 1);
|
|
text.append ("\n *** Column " + columnName
|
|
+ " ***\n\n");
|
|
last = cell.getAddress ().getColumn ();
|
|
}
|
|
|
|
text.append (cell);
|
|
text.append (AbstractValue.LINE);
|
|
|
|
text.append ("\n\n");
|
|
}
|
|
|
|
text.append ("File contents:\n\n");
|
|
for (String line : lines)
|
|
{
|
|
text.append (line);
|
|
text.append ("\n");
|
|
}
|
|
|
|
if (text.length () > 0)
|
|
text.deleteCharAt (text.length () - 1);
|
|
}
|
|
|
|
return text.toString ();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
Function getFunction (Cell cell, String text)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
int functionId = -1;
|
|
for (int i = 0; i < Function.functionList.length; i++)
|
|
if (text.startsWith (Function.functionList[i]))
|
|
{
|
|
functionId = i;
|
|
functionTotals[i]++;
|
|
break;
|
|
}
|
|
|
|
if (functionId < 0)
|
|
{
|
|
System.out.printf ("Unknown function: [%s]%n", text);
|
|
return new Error (cell, "@ERROR");
|
|
}
|
|
|
|
switch (functionId)
|
|
{
|
|
case 0:
|
|
return new Abs (cell, text);
|
|
|
|
case 1:
|
|
return new Acos (cell, text);
|
|
|
|
case 2:
|
|
return new And (cell, text);
|
|
|
|
case 3:
|
|
return new Asin (cell, text);
|
|
|
|
case 4:
|
|
return new Atan (cell, text);
|
|
|
|
case 5:
|
|
return new Average (cell, text);
|
|
|
|
case 6:
|
|
return new Count (cell, text);
|
|
|
|
case 7:
|
|
return new Choose (cell, text);
|
|
|
|
case 8:
|
|
return new Cos (cell, text);
|
|
|
|
case 9:
|
|
return new Error (cell, text);
|
|
|
|
case 10:
|
|
return new Exp (cell, text);
|
|
|
|
case 11:
|
|
return new False (cell, text);
|
|
|
|
case 12:
|
|
return new If (cell, text);
|
|
|
|
case 13:
|
|
return new Int (cell, text);
|
|
|
|
case 14:
|
|
return new IsError (cell, text);
|
|
|
|
case 15:
|
|
return new IsNa (cell, text);
|
|
|
|
case 16:
|
|
return new Log10 (cell, text);
|
|
|
|
case 17:
|
|
return new Lookup (cell, text);
|
|
|
|
case 18:
|
|
return new Ln (cell, text);
|
|
|
|
case 19:
|
|
return new Min (cell, text);
|
|
|
|
case 20:
|
|
return new Max (cell, text);
|
|
|
|
case 21:
|
|
return new Na (cell, text);
|
|
|
|
case 22:
|
|
return new Not (cell, text);
|
|
|
|
case 23:
|
|
return new Npv (cell, text);
|
|
|
|
case 24:
|
|
return new Or (cell, text);
|
|
|
|
case 25:
|
|
return new Pi (cell, text);
|
|
|
|
case 26:
|
|
return new Sin (cell, text);
|
|
|
|
case 27:
|
|
return new Sum (cell, text);
|
|
|
|
case 28:
|
|
return new Sqrt (cell, text);
|
|
|
|
case 29:
|
|
return new Tan (cell, text);
|
|
|
|
case 30:
|
|
return new True (cell, text);
|
|
|
|
default:
|
|
System.out.printf ("Unknown function ID: %d%n", functionId);
|
|
return new Error (cell, "@ERROR");
|
|
}
|
|
}
|
|
} |