Archived
Renamed packages to match Java guidelines.
This commit is contained in:
Deryck Brown
+624
@@ -0,0 +1,624 @@
|
||||
/*
|
||||
* @(#)Interpreter.java 2.1 2003/10/07
|
||||
*
|
||||
* Copyright (C) 1999, 2003 D.A. Watt and D.F. Brown
|
||||
* Dept. of Computing Science, University of Glasgow, Glasgow G12 8QQ Scotland
|
||||
* and School of Computer and Math Sciences, The Robert Gordon University,
|
||||
* St. Andrew Street, Aberdeen AB25 1HG, Scotland.
|
||||
* All rights reserved.
|
||||
*
|
||||
* This software is provided free for educational use only. It may
|
||||
* not be used for commercial purposes without the prior written permission
|
||||
* of the authors.
|
||||
*/
|
||||
|
||||
package triangle.abstractMachine;
|
||||
|
||||
import java.io.DataInputStream;
|
||||
import java.io.FileInputStream;
|
||||
import java.io.FileNotFoundException;
|
||||
import java.io.IOException;
|
||||
|
||||
public class Interpreter {
|
||||
|
||||
static String objectName;
|
||||
|
||||
// DATA STORE
|
||||
|
||||
static int[] data = new int[1024];
|
||||
|
||||
// DATA STORE REGISTERS AND OTHER REGISTERS
|
||||
|
||||
final static int CB = 0, SB = 0, HB = 1024; // = upper bound of data array + 1
|
||||
|
||||
static int CT, CP, ST, HT, LB, status;
|
||||
|
||||
// status values
|
||||
final static int running = 0, halted = 1, failedDataStoreFull = 2, failedInvalidCodeAddress = 3,
|
||||
failedInvalidInstruction = 4, failedOverflow = 5, failedZeroDivide = 6, failedIOError = 7;
|
||||
|
||||
static long accumulator;
|
||||
|
||||
static int content(int r) {
|
||||
var register = Register.values()[r];
|
||||
return content(register);
|
||||
}
|
||||
|
||||
static int content(Register r) {
|
||||
// Returns the current content of register r,
|
||||
// even if r is one of the pseudo-registers L1..L6.
|
||||
|
||||
switch (r) {
|
||||
case CB:
|
||||
return CB;
|
||||
case CT:
|
||||
return CT;
|
||||
case PB:
|
||||
return Machine.PB;
|
||||
case PT:
|
||||
return Machine.PT;
|
||||
case SB:
|
||||
return SB;
|
||||
case ST:
|
||||
return ST;
|
||||
case HB:
|
||||
return HB;
|
||||
case HT:
|
||||
return HT;
|
||||
case LB:
|
||||
return LB;
|
||||
case L1:
|
||||
return data[LB];
|
||||
case L2:
|
||||
return data[data[LB]];
|
||||
case L3:
|
||||
return data[data[data[LB]]];
|
||||
case L4:
|
||||
return data[data[data[data[LB]]]];
|
||||
case L5:
|
||||
return data[data[data[data[data[LB]]]]];
|
||||
case L6:
|
||||
return data[data[data[data[data[data[LB]]]]]];
|
||||
case CP:
|
||||
return CP;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
// PROGRAM STATUS
|
||||
|
||||
static void dump() {
|
||||
// Writes a summary of the machine state.
|
||||
|
||||
System.out.println("");
|
||||
System.out.println("State of data store and registers:");
|
||||
System.out.println("");
|
||||
if (HT == HB)
|
||||
System.out.println(" |--------| (heap is empty)");
|
||||
else {
|
||||
System.out.println(" HB-->");
|
||||
System.out.println(" |--------|");
|
||||
for (var addr = HB - 1; addr >= HT; addr--) {
|
||||
System.out.print(addr + ":");
|
||||
if (addr == HT)
|
||||
System.out.print(" HT-->");
|
||||
else
|
||||
System.out.print(" ");
|
||||
System.out.println("|" + data[addr] + "|");
|
||||
}
|
||||
System.out.println(" |--------|");
|
||||
}
|
||||
System.out.println(" |////////|");
|
||||
System.out.println(" |////////|");
|
||||
if (ST == SB)
|
||||
System.out.println(" |--------| (stack is empty)");
|
||||
else {
|
||||
var dynamicLink = LB;
|
||||
var staticLink = LB;
|
||||
var localRegNum = Register.LB;
|
||||
System.out.println(" ST--> |////////|");
|
||||
System.out.println(" |--------|");
|
||||
for (var addr = ST - 1; addr >= SB; addr--) {
|
||||
System.out.print(addr + ":");
|
||||
if (addr == SB)
|
||||
System.out.print(" SB-->");
|
||||
else if (addr == staticLink) {
|
||||
switch (localRegNum) {
|
||||
case LB:
|
||||
System.out.print(" LB-->");
|
||||
break;
|
||||
case L1:
|
||||
System.out.print(" L1-->");
|
||||
break;
|
||||
case L2:
|
||||
System.out.print(" L2-->");
|
||||
break;
|
||||
case L3:
|
||||
System.out.print(" L3-->");
|
||||
break;
|
||||
case L4:
|
||||
System.out.print(" L4-->");
|
||||
break;
|
||||
case L5:
|
||||
System.out.print(" L5-->");
|
||||
break;
|
||||
case L6:
|
||||
System.out.print(" L6-->");
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
staticLink = data[addr];
|
||||
localRegNum = Register.values()[localRegNum.ordinal() + 1];
|
||||
} else
|
||||
System.out.print(" ");
|
||||
if ((addr == dynamicLink) && (dynamicLink != SB))
|
||||
System.out.print("|SL=" + data[addr] + "|");
|
||||
else if ((addr == dynamicLink + 1) && (dynamicLink != SB))
|
||||
System.out.print("|DL=" + data[addr] + "|");
|
||||
else if ((addr == dynamicLink + 2) && (dynamicLink != SB))
|
||||
System.out.print("|RA=" + data[addr] + "|");
|
||||
else
|
||||
System.out.print("|" + data[addr] + "|");
|
||||
System.out.println("");
|
||||
if (addr == dynamicLink) {
|
||||
System.out.println(" |--------|");
|
||||
dynamicLink = data[addr + 1];
|
||||
}
|
||||
}
|
||||
}
|
||||
System.out.println("");
|
||||
}
|
||||
|
||||
static void showStatus() {
|
||||
// Writes an indication of whether and why the program has terminated.
|
||||
System.out.println("");
|
||||
switch (status) {
|
||||
case running:
|
||||
System.out.println("Program is running.");
|
||||
break;
|
||||
case halted:
|
||||
System.out.println("Program has halted normally.");
|
||||
break;
|
||||
case failedDataStoreFull:
|
||||
System.out.println("Program has failed due to exhaustion of Data Store.");
|
||||
break;
|
||||
case failedInvalidCodeAddress:
|
||||
System.out.println("Program has failed due to an invalid code address.");
|
||||
break;
|
||||
case failedInvalidInstruction:
|
||||
System.out.println("Program has failed due to an invalid instruction.");
|
||||
break;
|
||||
case failedOverflow:
|
||||
System.out.println("Program has failed due to overflow.");
|
||||
break;
|
||||
case failedZeroDivide:
|
||||
System.out.println("Program has failed due to division by zero.");
|
||||
break;
|
||||
case failedIOError:
|
||||
System.out.println("Program has failed due to an IO error.");
|
||||
break;
|
||||
}
|
||||
if (status != halted)
|
||||
dump();
|
||||
}
|
||||
|
||||
// INTERPRETATION
|
||||
|
||||
static void checkSpace(int spaceNeeded) {
|
||||
// Signals failure if there is not enough space to expand the stack or
|
||||
// heap by spaceNeeded.
|
||||
|
||||
if (HT - ST < spaceNeeded)
|
||||
status = failedDataStoreFull;
|
||||
}
|
||||
|
||||
static boolean isTrue(int datum) {
|
||||
// Tests whether the given datum represents true.
|
||||
return (datum == Machine.trueRep);
|
||||
}
|
||||
|
||||
static boolean equal(int size, int addr1, int addr2) {
|
||||
// Tests whether two multi-word objects are equal, given their common
|
||||
// size and their base addresses.
|
||||
|
||||
boolean eq;
|
||||
int index;
|
||||
|
||||
eq = true;
|
||||
index = 0;
|
||||
while (eq && (index < size))
|
||||
if (data[addr1 + index] == data[addr2 + index])
|
||||
index = index + 1;
|
||||
else
|
||||
eq = false;
|
||||
return eq;
|
||||
}
|
||||
|
||||
static int overflowChecked(long datum) {
|
||||
// Signals failure if the datum is too large to fit into a single word,
|
||||
// otherwise returns the datum as a single word.
|
||||
|
||||
if ((-Machine.maxintRep <= datum) && (datum <= Machine.maxintRep))
|
||||
return (int) datum;
|
||||
else {
|
||||
status = failedOverflow;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
static int toInt(boolean b) {
|
||||
return b ? Machine.trueRep : Machine.falseRep;
|
||||
}
|
||||
|
||||
static int currentChar;
|
||||
|
||||
static int readInt() throws java.io.IOException {
|
||||
int temp = 0;
|
||||
int sign = 1;
|
||||
|
||||
do {
|
||||
currentChar = System.in.read();
|
||||
} while (Character.isWhitespace((char) currentChar));
|
||||
|
||||
if ((currentChar == '-') || (currentChar == '+'))
|
||||
do {
|
||||
sign = (currentChar == '-') ? -1 : 1;
|
||||
currentChar = System.in.read();
|
||||
} while ((currentChar == '-') || currentChar == '+');
|
||||
|
||||
if (Character.isDigit((char) currentChar))
|
||||
do {
|
||||
temp = temp * 10 + (currentChar - '0');
|
||||
currentChar = System.in.read();
|
||||
} while (Character.isDigit((char) currentChar));
|
||||
|
||||
return sign * temp;
|
||||
}
|
||||
|
||||
static void callPrimitive(int primitiveDisplacement) {
|
||||
// Invokes the given primitive routine.
|
||||
|
||||
int addr, size;
|
||||
char ch;
|
||||
|
||||
var primitive = Primitive.values()[primitiveDisplacement];
|
||||
switch (primitive) {
|
||||
case ID:
|
||||
break; // nothing to be done
|
||||
case NOT:
|
||||
data[ST - 1] = toInt(!isTrue(data[ST - 1]));
|
||||
break;
|
||||
case AND:
|
||||
ST = ST - 1;
|
||||
data[ST - 1] = toInt(isTrue(data[ST - 1]) & isTrue(data[ST]));
|
||||
break;
|
||||
case OR:
|
||||
ST = ST - 1;
|
||||
data[ST - 1] = toInt(isTrue(data[ST - 1]) | isTrue(data[ST]));
|
||||
break;
|
||||
case SUCC:
|
||||
data[ST - 1] = overflowChecked(data[ST - 1] + 1);
|
||||
break;
|
||||
case PRED:
|
||||
data[ST - 1] = overflowChecked(data[ST - 1] - 1);
|
||||
break;
|
||||
case NEG:
|
||||
data[ST - 1] = -data[ST - 1];
|
||||
break;
|
||||
case ADD:
|
||||
ST = ST - 1;
|
||||
accumulator = data[ST - 1];
|
||||
data[ST - 1] = overflowChecked(accumulator + data[ST]);
|
||||
break;
|
||||
case SUB:
|
||||
ST = ST - 1;
|
||||
accumulator = data[ST - 1];
|
||||
data[ST - 1] = overflowChecked(accumulator - data[ST]);
|
||||
break;
|
||||
case MULT:
|
||||
ST = ST - 1;
|
||||
accumulator = data[ST - 1];
|
||||
data[ST - 1] = overflowChecked(accumulator * data[ST]);
|
||||
break;
|
||||
case DIV:
|
||||
ST = ST - 1;
|
||||
accumulator = data[ST - 1];
|
||||
if (data[ST] != 0)
|
||||
data[ST - 1] = (int) (accumulator / data[ST]);
|
||||
else
|
||||
status = failedZeroDivide;
|
||||
break;
|
||||
case MOD:
|
||||
ST = ST - 1;
|
||||
accumulator = data[ST - 1];
|
||||
if (data[ST] != 0)
|
||||
data[ST - 1] = (int) (accumulator % data[ST]);
|
||||
else
|
||||
status = failedZeroDivide;
|
||||
break;
|
||||
case LT:
|
||||
ST = ST - 1;
|
||||
data[ST - 1] = toInt(data[ST - 1] < data[ST]);
|
||||
break;
|
||||
case LE:
|
||||
ST = ST - 1;
|
||||
data[ST - 1] = toInt(data[ST - 1] <= data[ST]);
|
||||
break;
|
||||
case GE:
|
||||
ST = ST - 1;
|
||||
data[ST - 1] = toInt(data[ST - 1] >= data[ST]);
|
||||
break;
|
||||
case GT:
|
||||
ST = ST - 1;
|
||||
data[ST - 1] = toInt(data[ST - 1] > data[ST]);
|
||||
break;
|
||||
case EQ:
|
||||
size = data[ST - 1]; // size of each comparand
|
||||
ST = ST - 2 * size;
|
||||
data[ST - 1] = toInt(equal(size, ST - 1, ST - 1 + size));
|
||||
break;
|
||||
case NE:
|
||||
size = data[ST - 1]; // size of each comparand
|
||||
ST = ST - 2 * size;
|
||||
data[ST - 1] = toInt(!equal(size, ST - 1, ST - 1 + size));
|
||||
break;
|
||||
case EOL:
|
||||
data[ST] = toInt(currentChar == '\n');
|
||||
ST = ST + 1;
|
||||
break;
|
||||
case EOF:
|
||||
data[ST] = toInt(currentChar == -1);
|
||||
ST = ST + 1;
|
||||
break;
|
||||
case GET:
|
||||
ST = ST - 1;
|
||||
addr = data[ST];
|
||||
try {
|
||||
currentChar = System.in.read();
|
||||
} catch (java.io.IOException s) {
|
||||
status = failedIOError;
|
||||
}
|
||||
data[addr] = currentChar;
|
||||
break;
|
||||
case PUT:
|
||||
ST = ST - 1;
|
||||
ch = (char) data[ST];
|
||||
System.out.print(ch);
|
||||
break;
|
||||
case GETEOL:
|
||||
try {
|
||||
while ((currentChar = System.in.read()) != '\n')
|
||||
;
|
||||
} catch (java.io.IOException s) {
|
||||
status = failedIOError;
|
||||
}
|
||||
break;
|
||||
case PUTEOL:
|
||||
System.out.println("");
|
||||
break;
|
||||
case GETINT:
|
||||
ST = ST - 1;
|
||||
addr = data[ST];
|
||||
try {
|
||||
accumulator = readInt();
|
||||
} catch (java.io.IOException s) {
|
||||
status = failedIOError;
|
||||
}
|
||||
data[addr] = (int) accumulator;
|
||||
break;
|
||||
case PUTINT:
|
||||
ST = ST - 1;
|
||||
accumulator = data[ST];
|
||||
System.out.print(accumulator);
|
||||
break;
|
||||
case NEW:
|
||||
size = data[ST - 1];
|
||||
checkSpace(size);
|
||||
HT = HT - size;
|
||||
data[ST - 1] = HT;
|
||||
break;
|
||||
case DISPOSE:
|
||||
ST = ST - 1; // no action taken at present
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static void interpretProgram() {
|
||||
// Runs the program in code store.
|
||||
|
||||
Instruction currentInstr;
|
||||
|
||||
// Initialize registers ...
|
||||
ST = SB;
|
||||
HT = HB;
|
||||
LB = SB;
|
||||
CP = CB;
|
||||
status = running;
|
||||
do {
|
||||
// Fetch instruction ...
|
||||
currentInstr = Machine.code[CP];
|
||||
// Decode instruction ...
|
||||
var op = currentInstr.opCode;
|
||||
var r = currentInstr.register;
|
||||
var n = currentInstr.length;
|
||||
var d = currentInstr.operand;
|
||||
int addr;
|
||||
|
||||
// Execute instruction ...
|
||||
switch (op) {
|
||||
case LOAD:
|
||||
addr = d + content(r);
|
||||
checkSpace(n);
|
||||
for (var index = 0; index < n; index++)
|
||||
data[ST + index] = data[addr + index];
|
||||
ST = ST + n;
|
||||
CP = CP + 1;
|
||||
break;
|
||||
case LOADA:
|
||||
addr = d + content(r);
|
||||
checkSpace(1);
|
||||
data[ST] = addr;
|
||||
ST = ST + 1;
|
||||
CP = CP + 1;
|
||||
break;
|
||||
case LOADI:
|
||||
ST = ST - 1;
|
||||
addr = data[ST];
|
||||
checkSpace(n);
|
||||
for (var index = 0; index < n; index++)
|
||||
data[ST + index] = data[addr + index];
|
||||
ST = ST + n;
|
||||
CP = CP + 1;
|
||||
break;
|
||||
case LOADL:
|
||||
checkSpace(1);
|
||||
data[ST] = d;
|
||||
ST = ST + 1;
|
||||
CP = CP + 1;
|
||||
break;
|
||||
case STORE:
|
||||
addr = d + content(r);
|
||||
ST = ST - n;
|
||||
for (var index = 0; index < n; index++)
|
||||
data[addr + index] = data[ST + index];
|
||||
CP = CP + 1;
|
||||
break;
|
||||
case STOREI:
|
||||
ST = ST - 1;
|
||||
addr = data[ST];
|
||||
ST = ST - n;
|
||||
for (var index = 0; index < n; index++)
|
||||
data[addr + index] = data[ST + index];
|
||||
CP = CP + 1;
|
||||
break;
|
||||
case CALL:
|
||||
addr = d + content(r);
|
||||
if (addr >= Machine.PB) {
|
||||
callPrimitive(addr - Machine.PB);
|
||||
CP = CP + 1;
|
||||
} else {
|
||||
checkSpace(3);
|
||||
if (0 <= n && n <= 15)
|
||||
data[ST] = content(n); // static link
|
||||
else
|
||||
status = failedInvalidInstruction;
|
||||
data[ST + 1] = LB; // dynamic link
|
||||
data[ST + 2] = CP + 1; // return address
|
||||
LB = ST;
|
||||
ST = ST + 3;
|
||||
CP = addr;
|
||||
}
|
||||
break;
|
||||
case CALLI:
|
||||
ST = ST - 2;
|
||||
addr = data[ST + 1];
|
||||
if (addr >= Machine.PB) {
|
||||
callPrimitive(addr - Machine.PB);
|
||||
CP = CP + 1;
|
||||
} else {
|
||||
// data[ST] = static link already
|
||||
data[ST + 1] = LB; // dynamic link
|
||||
data[ST + 2] = CP + 1; // return address
|
||||
LB = ST;
|
||||
ST = ST + 3;
|
||||
CP = addr;
|
||||
}
|
||||
break;
|
||||
case RETURN:
|
||||
addr = LB - d;
|
||||
CP = data[LB + 2];
|
||||
LB = data[LB + 1];
|
||||
ST = ST - n;
|
||||
for (var index = 0; index < n; index++)
|
||||
data[addr + index] = data[ST + index];
|
||||
ST = addr + n;
|
||||
break;
|
||||
case PUSH:
|
||||
checkSpace(d);
|
||||
ST = ST + d;
|
||||
CP = CP + 1;
|
||||
break;
|
||||
case POP:
|
||||
addr = ST - n - d;
|
||||
ST = ST - n;
|
||||
for (var index = 0; index < n; index++)
|
||||
data[addr + index] = data[ST + index];
|
||||
ST = addr + n;
|
||||
CP = CP + 1;
|
||||
break;
|
||||
case JUMP:
|
||||
CP = d + content(r);
|
||||
break;
|
||||
case JUMPI:
|
||||
ST = ST - 1;
|
||||
CP = data[ST];
|
||||
break;
|
||||
case JUMPIF:
|
||||
ST = ST - 1;
|
||||
if (data[ST] == n)
|
||||
CP = d + content(r);
|
||||
else
|
||||
CP = CP + 1;
|
||||
break;
|
||||
case HALT:
|
||||
status = halted;
|
||||
break;
|
||||
}
|
||||
if ((CP < CB) || (CP >= CT))
|
||||
status = failedInvalidCodeAddress;
|
||||
} while (status == running);
|
||||
}
|
||||
|
||||
// LOADING
|
||||
|
||||
static void loadObjectProgram(String objectName) {
|
||||
// Loads the TAM object program into code store from the named file.
|
||||
|
||||
FileInputStream objectFile = null;
|
||||
DataInputStream objectStream = null;
|
||||
|
||||
int addr;
|
||||
boolean finished = false;
|
||||
|
||||
try {
|
||||
objectFile = new FileInputStream(objectName);
|
||||
objectStream = new DataInputStream(objectFile);
|
||||
|
||||
addr = Machine.CB;
|
||||
while (!finished) {
|
||||
Machine.code[addr] = Instruction.read(objectStream);
|
||||
if (Machine.code[addr] == null)
|
||||
finished = true;
|
||||
else
|
||||
addr = addr + 1;
|
||||
}
|
||||
CT = addr;
|
||||
objectFile.close();
|
||||
} catch (FileNotFoundException s) {
|
||||
CT = CB;
|
||||
System.err.println("Error opening object file: " + s);
|
||||
} catch (IOException s) {
|
||||
CT = CB;
|
||||
System.err.println("Error reading object file: " + s);
|
||||
}
|
||||
}
|
||||
|
||||
// RUNNING
|
||||
|
||||
public static void main(String[] args) {
|
||||
System.out.println("********** TAM Interpreter (Java Version 2.1) **********");
|
||||
|
||||
if (args.length == 1)
|
||||
objectName = args[0];
|
||||
else
|
||||
objectName = "obj.tam";
|
||||
|
||||
loadObjectProgram(objectName);
|
||||
if (CT != CB) {
|
||||
interpretProgram();
|
||||
showStatus();
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user