599 lines
18 KiB
Java
Executable File
599 lines
18 KiB
Java
Executable File
package com.bytezone.diskbrowser.infocom;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
|
|
import com.bytezone.diskbrowser.utilities.HexFormatter;
|
|
|
|
// -----------------------------------------------------------------------------------//
|
|
class Instruction
|
|
// -----------------------------------------------------------------------------------//
|
|
{
|
|
static int version = 3;
|
|
|
|
final Opcode opcode;
|
|
final int startPtr;
|
|
private byte[] buffer;
|
|
// List<ZString> abbreviations;
|
|
private Header header;
|
|
|
|
enum OperandType
|
|
{
|
|
VAR_SP, VAR_LOCAL, VAR_GLOBAL, BYTE, WORD, ARG_BRANCH, ARG_STRING, OBJECT
|
|
}
|
|
|
|
static final String[] name2OP =
|
|
{ "*bad*", "je", "jl", "jg", "dec_chk", "inc_chk", "jin", "test", "or", "and",
|
|
"test_attr", "set_attr", "clear_attr", "store", "insert_obj", "loadw", "loadb",
|
|
"get_prop", "get_prop_addr", "get_next_prop", "add", "sub", "mul", "div", "mod",
|
|
"call_2s", "call_2n", "set_colour", "throw", "*bad*", "*bad*", "*bad*" };
|
|
static final String[] name1OP =
|
|
{ "jz", "get_sibling", "get_child", "get_parent", "get_prop_len", "inc", "dec",
|
|
"print_addr", "call_ls", "remove_obj", "print_obj", "ret", "jump", "print_paddr",
|
|
"load", "not" };
|
|
static final String[] name0OP =
|
|
{ "rtrue", "rfalse", "print", "print_ret", "nop", "save", "restore", "restart",
|
|
"ret_popped", "pop", "quit", "new_line", "show_status", "verify", "", "piracy" };
|
|
static final String[] nameVAR =
|
|
{ "call", "storew", "storeb", "put_prop", "sread", "print_char", "print_num",
|
|
"random", "push", "pull", "split_window", "set_window", "call_vs2",
|
|
"erase_window", "erase_line", "set_cursor", "get_cursor", "set_text_style",
|
|
"buffer_mode", "output_stream", "input_stream", "sound_effect", "read_char",
|
|
"scan_table", "not", "call_vn", "call_vn2", "tokenise", "encode_text",
|
|
"copy_table", "print_table", "check_arg" };
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
Instruction (byte[] buffer, int ptr, Header header)
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
this.buffer = buffer;
|
|
this.startPtr = ptr;
|
|
this.header = header;
|
|
byte b1 = buffer[ptr];
|
|
|
|
int type = (b1 & 0xC0) >>> 6;
|
|
switch (type)
|
|
{
|
|
case 0x03: // 11 - variable
|
|
if ((b1 & 0x20) == 0x20)
|
|
opcode = new OpcodeVar (buffer, ptr);
|
|
else
|
|
opcode = new Opcode2OPVar (buffer, ptr);
|
|
break;
|
|
|
|
case 0x02: // 10 - extended or short
|
|
if (b1 == 0xBE && version >= 5)
|
|
opcode = null;
|
|
else if ((b1 & 0x30) == 0x30)
|
|
opcode = new Opcode0OP (buffer, ptr);
|
|
else
|
|
opcode = new Opcode1OP (buffer, ptr);
|
|
break;
|
|
|
|
default: // 00, 01 - long
|
|
opcode = new Opcode2OPLong (buffer, ptr);
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
int length ()
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
return opcode.length ();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
boolean isReturn ()
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
return opcode.isReturn;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
boolean isPrint ()
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
return opcode.string != null;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
boolean isCall ()
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
return opcode.isCall;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
boolean isJump ()
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
// could use jumpTarget != 0
|
|
return (opcode instanceof Opcode1OP && opcode.opcodeNumber == 12);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
boolean isBranch ()
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
return opcode.branch != null;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
boolean isStore ()
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
return opcode.store != null;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
int target ()
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
return isBranch () ? opcode.branch.target : isJump () ? opcode.jumpTarget : 0;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
String dump ()
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
return String.format ("%05X : %s", startPtr,
|
|
HexFormatter.getHexString (buffer, startPtr, opcode.length ()));
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
String getHex ()
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
int max = opcode.length ();
|
|
String extra = "";
|
|
if (max > 9)
|
|
{
|
|
max = 9;
|
|
extra = "..";
|
|
}
|
|
|
|
String hex = HexFormatter.getHexString (buffer, startPtr, max);
|
|
return String.format ("%05X : %-26s%2s", startPtr, hex, extra);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
@Override
|
|
public String toString ()
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
return opcode.toString ();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
abstract class Opcode
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
int opcodeNumber;
|
|
int opcodeLength;
|
|
List<Operand> operands = new ArrayList<> ();
|
|
int totalOperandLength;
|
|
ArgumentBranch branch;
|
|
ArgumentString string;
|
|
OperandVariable store;
|
|
boolean isReturn, isCall, isExit;
|
|
int jumpTarget;
|
|
int callTarget;
|
|
|
|
@Override
|
|
public String toString ()
|
|
{
|
|
StringBuilder text = new StringBuilder ();
|
|
|
|
text.append (String.format ("%-12s", opcodeName ()));
|
|
|
|
if (jumpTarget != 0)
|
|
text.append (String.format (" L:%05X", jumpTarget));
|
|
else if (isCall)
|
|
{
|
|
text.append (String.format (" R:%05X (", callTarget));
|
|
int count = 0;
|
|
for (Operand op : operands)
|
|
if (count++ > 0)
|
|
text.append (op + ", ");
|
|
if (operands.size () > 1)
|
|
text.delete (text.length () - 2, text.length ());
|
|
text.append (") -> " + store);
|
|
}
|
|
else
|
|
{
|
|
for (Operand op : operands)
|
|
text.append (" " + op);
|
|
if (branch != null)
|
|
text.append (branch);
|
|
if (store != null)
|
|
text.append (" -> " + store);
|
|
if (string != null)
|
|
text.append (" \"" + string + "\"");
|
|
}
|
|
return text.toString ();
|
|
}
|
|
|
|
int length ()
|
|
{
|
|
int length = totalOperandLength + opcodeLength;
|
|
if (branch != null)
|
|
length += branch.length;
|
|
if (store != null)
|
|
length += store.length;
|
|
if (string != null)
|
|
length += string.length;
|
|
return length;
|
|
}
|
|
|
|
abstract String opcodeName ();
|
|
|
|
private void addOperand (Operand operand)
|
|
{
|
|
operands.add (operand);
|
|
totalOperandLength += operand.length;
|
|
}
|
|
|
|
void addOperand (byte[] buffer, int ptr, boolean bit1, boolean bit2)
|
|
{
|
|
int offset = ptr + totalOperandLength;
|
|
if (bit1)
|
|
{
|
|
if (!bit2)
|
|
addOperand (new OperandVariable (buffer[offset])); // %10
|
|
}
|
|
else if (bit2)
|
|
addOperand (new OperandByte (buffer[offset])); // %01
|
|
else
|
|
addOperand (new OperandWord (header.getWord (offset))); // %00
|
|
}
|
|
|
|
void addOperand (byte[] buffer, int ptr, boolean bit)
|
|
{
|
|
int address = ptr + totalOperandLength;
|
|
if (address >= buffer.length)
|
|
{
|
|
System.out.println ("Illegal byte address : " + address);
|
|
return;
|
|
}
|
|
if (bit)
|
|
addOperand (new OperandVariable (buffer[address]));
|
|
else
|
|
addOperand (new OperandByte (buffer[address]));
|
|
}
|
|
|
|
void setVariableOperands (int ptr)
|
|
{
|
|
int value = buffer[ptr + 1] & 0xFF;
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
boolean bit1 = ((value & 0x80) == 0x80);
|
|
boolean bit2 = ((value & 0x40) == 0x40);
|
|
if (bit1 && bit2)
|
|
break;
|
|
addOperand (buffer, ptr + 2, bit1, bit2);
|
|
value <<= 2;
|
|
}
|
|
}
|
|
|
|
void setStore (byte[] buffer)
|
|
{
|
|
store = new OperandVariable (buffer[startPtr + totalOperandLength + opcodeLength]);
|
|
}
|
|
|
|
void setBranch (byte[] buffer)
|
|
{
|
|
int offset = startPtr + totalOperandLength + (store == null ? 0 : 1) + opcodeLength;
|
|
if ((buffer[offset] & 0x40) != 0)
|
|
branch = new ArgumentBranch (buffer[offset], offset);
|
|
else
|
|
branch = new ArgumentBranch (header.getWord (offset), offset);
|
|
}
|
|
|
|
void setZString (byte[] buffer)
|
|
{
|
|
int offset = startPtr + totalOperandLength + opcodeLength;
|
|
string = new ArgumentString (buffer, offset);
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
class Opcode0OP extends Opcode
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
Opcode0OP (byte[] buffer, int ptr)
|
|
{
|
|
opcodeNumber = buffer[ptr] & 0x0F;
|
|
opcodeLength = 1;
|
|
|
|
if (opcodeNumber == 5 || opcodeNumber == 6 || opcodeNumber == 13)
|
|
setBranch (buffer);
|
|
|
|
if (opcodeNumber == 0 || opcodeNumber == 1 || opcodeNumber == 3
|
|
|| opcodeNumber == 8)
|
|
isReturn = true;
|
|
|
|
if (opcodeNumber == 2 || opcodeNumber == 3)
|
|
setZString (buffer);
|
|
|
|
if (opcodeNumber == 7 || opcodeNumber == 10)
|
|
isExit = true;
|
|
}
|
|
|
|
@Override
|
|
public String opcodeName ()
|
|
{
|
|
return name0OP[opcodeNumber];
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
class Opcode1OP extends Opcode
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
Opcode1OP (byte[] buffer, int ptr)
|
|
{
|
|
opcodeNumber = buffer[ptr] & 0x0F;
|
|
opcodeLength = 1;
|
|
|
|
boolean bit1 = ((buffer[ptr] & 0x20) == 0x20);
|
|
boolean bit2 = ((buffer[ptr] & 0x10) == 0x10);
|
|
addOperand (buffer, ptr + 1, bit1, bit2);
|
|
|
|
if ((opcodeNumber >= 1 && opcodeNumber <= 4) || opcodeNumber == 8
|
|
|| opcodeNumber == 14 || opcodeNumber == 15)
|
|
setStore (buffer);
|
|
if (opcodeNumber <= 2)
|
|
setBranch (buffer);
|
|
if (opcodeNumber == 12)
|
|
jumpTarget = (short) operands.get (0).value + startPtr - 2 + length ();
|
|
if (opcodeNumber == 11)
|
|
isReturn = true;
|
|
}
|
|
|
|
@Override
|
|
public String opcodeName ()
|
|
{
|
|
return name1OP[opcodeNumber];
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
abstract class Opcode2OP extends Opcode
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
Opcode2OP ()
|
|
{
|
|
opcodeLength = 1;
|
|
}
|
|
|
|
void setArguments (byte[] buffer)
|
|
{
|
|
if ((opcodeNumber >= 1 && opcodeNumber <= 7) || opcodeNumber == 10)
|
|
setBranch (buffer);
|
|
else if ((opcodeNumber >= 15 && opcodeNumber <= 25) || opcodeNumber == 8
|
|
|| opcodeNumber == 9)
|
|
setStore (buffer);
|
|
}
|
|
|
|
@Override
|
|
public String opcodeName ()
|
|
{
|
|
return name2OP[opcodeNumber];
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
class Opcode2OPLong extends Opcode2OP
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
Opcode2OPLong (byte[] buffer, int ptr)
|
|
{
|
|
opcodeNumber = buffer[ptr] & 0x1F;
|
|
boolean bit1 = ((buffer[ptr] & 0x40) == 0x40);
|
|
boolean bit2 = ((buffer[ptr] & 0x20) == 0x20);
|
|
|
|
if (opcodeNumber == 0x0D) // store (variable) value
|
|
{
|
|
addOperand (buffer, ptr + 1, true); // always a variable
|
|
addOperand (buffer, ptr + 1, bit2);
|
|
}
|
|
else
|
|
{
|
|
addOperand (buffer, ptr + 1, bit1);
|
|
addOperand (buffer, ptr + 1, bit2);
|
|
}
|
|
|
|
setArguments (buffer);
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
class Opcode2OPVar extends Opcode2OP
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
Opcode2OPVar (byte[] buffer, int ptr)
|
|
{
|
|
opcodeNumber = buffer[ptr] & 0x1F;
|
|
opcodeLength = 2;
|
|
setVariableOperands (ptr);
|
|
setArguments (buffer);
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
class OpcodeVar extends Opcode
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
OpcodeVar (byte[] buffer, int ptr)
|
|
{
|
|
opcodeNumber = buffer[ptr] & 0x1F;
|
|
opcodeLength = 2;
|
|
setVariableOperands (ptr);
|
|
|
|
if (opcodeNumber == 0 || opcodeNumber == 7)
|
|
setStore (buffer);
|
|
|
|
if (opcodeNumber == 0) // call routine
|
|
{
|
|
isCall = true;
|
|
callTarget = operands.get (0).value * 2;
|
|
}
|
|
|
|
if (opcodeNumber == 3) // put prop object propertyValue
|
|
{
|
|
// first parameter is the object id
|
|
operands.get (0).operandType = OperandType.OBJECT;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public String opcodeName ()
|
|
{
|
|
return nameVAR[opcodeNumber];
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
abstract class Operand
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
int length;
|
|
int value;
|
|
OperandType operandType;
|
|
|
|
@Override
|
|
public String toString ()
|
|
{
|
|
switch (operandType)
|
|
{
|
|
case VAR_SP:
|
|
return ("(SP)");
|
|
|
|
case VAR_LOCAL:
|
|
return (String.format ("L%02X", value - 1));
|
|
|
|
case VAR_GLOBAL:
|
|
return String.format ("G%02X", (value - 16));
|
|
|
|
case BYTE:
|
|
return String.format ("#%02X", value);
|
|
|
|
case WORD:
|
|
return String.format ("#%04X", value);
|
|
|
|
case OBJECT:
|
|
return "\"" + header.objectManager.getObject (value - 1).getName () + "\"";
|
|
|
|
default:
|
|
return "*** Illegal ***";
|
|
}
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
class OperandWord extends Operand
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
OperandWord (int value)
|
|
{
|
|
this.value = value;
|
|
length = 2;
|
|
operandType = OperandType.WORD;
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
class OperandByte extends Operand
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
OperandByte (byte value)
|
|
{
|
|
this.value = value & 0xFF;
|
|
length = 1;
|
|
operandType = OperandType.BYTE;
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
class OperandVariable extends Operand
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
OperandVariable (byte value)
|
|
{
|
|
this.value = value & 0xFF;
|
|
length = 1;
|
|
|
|
if (this.value == 0)
|
|
operandType = OperandType.VAR_SP;
|
|
else if (this.value <= 15)
|
|
operandType = OperandType.VAR_LOCAL;
|
|
else
|
|
operandType = OperandType.VAR_GLOBAL;
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
class ArgumentBranch extends Operand
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
private int target;
|
|
private boolean branchOnTrue;
|
|
|
|
ArgumentBranch (byte value, int offset)
|
|
{
|
|
branchOnTrue = (value & 0x80) != 0;
|
|
int val = value & 0x3F; // 0 - 63
|
|
if (val <= 1)
|
|
target = val;
|
|
else
|
|
target = val + offset - 1;
|
|
length = 1;
|
|
operandType = OperandType.ARG_BRANCH;
|
|
}
|
|
|
|
ArgumentBranch (int value, int offset)
|
|
{
|
|
branchOnTrue = (value & 0x8000) != 0;
|
|
int val = ((value & 0x3FFF) << 18) >> 18; // signed 14-bit number
|
|
|
|
target = val + offset;
|
|
length = 2;
|
|
operandType = OperandType.ARG_BRANCH;
|
|
}
|
|
|
|
@Override
|
|
public String toString ()
|
|
{
|
|
StringBuilder text = new StringBuilder ();
|
|
text.append (" [" + (branchOnTrue ? "true" : "false") + "] ");
|
|
if (target == 0 || target == 1)
|
|
text.append (target == 0 ? "RFALSE" : "RTRUE");
|
|
else
|
|
text.append (String.format ("%05X", target));
|
|
return text.toString ();
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------------//
|
|
class ArgumentString extends Operand
|
|
// ---------------------------------------------------------------------------------//
|
|
{
|
|
private ZString text;
|
|
private int startPtr;
|
|
private byte[] buffer;
|
|
|
|
ArgumentString (byte[] buffer, int offset)
|
|
{
|
|
this.buffer = buffer;
|
|
text = new ZString (header, offset);
|
|
length = text.length;
|
|
operandType = OperandType.ARG_STRING;
|
|
}
|
|
|
|
@Override
|
|
public String toString ()
|
|
{
|
|
return text.value;
|
|
}
|
|
}
|
|
} |