compiler-design-eth/test/cd/backend/interpreter/Interpreter.java

586 lines
14 KiB
Java
Raw Normal View History

2020-01-15 22:38:07 +01:00
package cd.backend.interpreter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.InputMismatchException;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Scanner;
import cd.backend.ExitCode;
import cd.backend.interpreter.Interpreter.MethodInterp.EarlyReturnException;
import cd.ir.Ast;
import cd.ir.Ast.Assign;
import cd.ir.Ast.BinaryOp;
import cd.ir.Ast.BooleanConst;
import cd.ir.Ast.BuiltInRead;
import cd.ir.Ast.BuiltInWrite;
import cd.ir.Ast.BuiltInWriteln;
import cd.ir.Ast.Cast;
import cd.ir.Ast.ClassDecl;
import cd.ir.Ast.Expr;
import cd.ir.Ast.Field;
import cd.ir.Ast.IfElse;
import cd.ir.Ast.Index;
import cd.ir.Ast.IntConst;
import cd.ir.Ast.MethodCall;
import cd.ir.Ast.MethodCallExpr;
import cd.ir.Ast.MethodDecl;
import cd.ir.Ast.NewArray;
import cd.ir.Ast.NewObject;
import cd.ir.Ast.NullConst;
import cd.ir.Ast.ReturnStmt;
import cd.ir.Ast.Stmt;
import cd.ir.Ast.ThisRef;
import cd.ir.Ast.UnaryOp;
import cd.ir.Ast.Var;
import cd.ir.Ast.WhileLoop;
import cd.ir.AstVisitor;
import cd.ir.BasicBlock;
import cd.ir.ControlFlowGraph;
import cd.ir.Symbol.ArrayTypeSymbol;
import cd.ir.Symbol.ClassSymbol;
import cd.ir.Symbol.TypeSymbol;
import cd.ir.Symbol.VariableSymbol;
/**
* An interpreter for the Javali IR. It requires that the IR be fully
* semantically analyzed -- in particular, that symbols be assigned to Var and
* Field nodes.
*
* It can interpret either the AST used in CD1 or the CFG from CD2. It detects
* infinite loops and also tracks how many operations of each kind were
* performed.
*/
public class Interpreter {
private static final long MAX_STEPS = 100000000;
private long steps = 0;
private final JlNull nullPointer = new JlNull();
private final List<ClassDecl> classDecls;
private final Writer output;
private final Scanner input;
public Interpreter(List<ClassDecl> classDecls, Reader in, Writer out) {
this.classDecls = classDecls;
this.input = new Scanner(in);
this.output = out;
}
public void execute() {
ClassSymbol mainType = findMainClass();
invokeMethod(mainType, "main", new JlObject(mainType),
Collections.<JlValue> emptyList());
}
// Optimization detection:
//
// We count the number of binary and unary operations that
// occurred during execution and compare this to a fully-optimized version.
// The key to this hashtable is either a BinaryOp.BOp or UnaryOp.UOp.
private final Map<Object, Integer> opCounts = new HashMap<Object, Integer>();
private void increment(Object operator) {
Integer current = opCounts.get(operator);
if (current == null)
opCounts.put(operator, 1);
else
opCounts.put(operator, current + 1);
}
public String operationSummary() {
List<String> operationSummaries = new ArrayList<String>();
for (Object operation : opCounts.keySet()) {
operationSummaries.add(String.format("%s: %s\n", operation,
opCounts.get(operation)));
}
Collections.sort(operationSummaries);
StringBuilder sb = new StringBuilder();
for (String summary : operationSummaries) {
sb.append(summary);
}
return sb.toString();
}
public void step() {
// Stop after taking too many evaluation steps!
if (++steps > MAX_STEPS) {
throw new DynamicError("Infinite Loop!",
ExitCode.INFINITE_LOOP);
}
}
// The interpreter proper:
class ExprInterp extends AstVisitor<JlValue, StackFrame> {
private JlValue v(int value) {
return new JlInt(value);
}
private JlValue v(boolean b) {
return new JlBoolean(b);
}
@Override
public JlValue visit(Ast ast, StackFrame arg) {
step();
return super.visit(ast, arg);
}
@Override
public JlValue binaryOp(BinaryOp ast, StackFrame arg) {
try {
final JlValue left = visit(ast.left(), arg);
final JlValue right = visit(ast.right(), arg);
// TODO Only increment this operator for integers
increment(ast.operator);
switch (ast.operator) {
case B_TIMES :
return left.times(right);
case B_DIV :
return left.div(right);
case B_MOD :
return left.mod(right);
case B_PLUS :
return left.add(right);
case B_MINUS :
return left.subtract(right);
case B_AND :
return left.and(right);
case B_OR :
return left.or(right);
case B_EQUAL :
return v(left.equals(right));
case B_NOT_EQUAL :
return v(!left.equals(right));
case B_LESS_THAN :
return left.less(right);
case B_LESS_OR_EQUAL :
return left.lessOrEqual(right);
case B_GREATER_THAN :
return left.greater(right);
case B_GREATER_OR_EQUAL :
return left.greaterOrEqual(right);
}
throw new DynamicError("Unhandled binary operator",
ExitCode.INTERNAL_ERROR);
} catch (ArithmeticException e) {
throw new DynamicError("Division by zero",
ExitCode.DIVISION_BY_ZERO);
}
}
@Override
public JlValue booleanConst(BooleanConst ast, StackFrame arg) {
return v(ast.value);
}
@Override
public JlValue builtInRead(BuiltInRead ast, StackFrame arg) {
try {
return v(input.nextInt());
} catch (InputMismatchException e) {
throw new DynamicError("Your .javali.in file is malformed.",
ExitCode.INTERNAL_ERROR);
} catch (NoSuchElementException e) {
throw new DynamicError("Your .javali.in does not contain enough numbers"
+ " or may not exist at all.\nMake sure that test cases that contain "
+ "read() expressions provide a [testcasename].javali.in file.",
ExitCode.INTERNAL_ERROR);
}
}
@Override
public JlValue cast(Cast ast, StackFrame arg) {
JlReference ref = visit(ast.arg(), arg).asRef();
if (ref.canBeCastTo(ast.typeName)) {
return ref;
}
throw new DynamicError("Cast failure: cannot cast " + ref.typeSym
+ " to " + ast.typeName, ExitCode.INVALID_DOWNCAST);
}
@Override
public JlValue field(Field ast, StackFrame arg) {
JlValue lhs = visit(ast.arg(), arg);
return lhs.asRef().field(ast.sym);
}
@Override
public JlValue index(Index ast, StackFrame arg) {
JlValue lhs = visit(ast.left(), arg);
JlValue idx = visit(ast.right(), arg);
return lhs.asRef().deref(idx.asInt());
}
@Override
public JlValue intConst(IntConst ast, StackFrame arg) {
return v(ast.value);
}
@Override
public JlValue newArray(NewArray ast, StackFrame arg) {
JlValue size = visit(ast.arg(), arg);
return new JlArray((ArrayTypeSymbol) ast.type, size.asInt());
}
@Override
public JlValue newObject(NewObject ast, StackFrame arg) {
return new JlObject((ClassSymbol) ast.type);
}
@Override
public JlValue nullConst(NullConst ast, StackFrame arg) {
return nullPointer;
}
@Override
public JlValue thisRef(ThisRef ast, StackFrame arg) {
return arg.getThisPointer();
}
@Override
public JlValue methodCall(MethodCallExpr ast, StackFrame frame) {
JlObject rcvr = expr(ast.receiver(), frame).asObject();
List<JlValue> arguments = new ArrayList<JlValue>();
for (Ast arg : ast.argumentsWithoutReceiver()) {
arguments.add(expr(arg, frame));
}
return invokeMethod((ClassSymbol) rcvr.typeSym, ast.methodName,
rcvr, arguments);
}
@Override
public JlValue unaryOp(UnaryOp ast, StackFrame arg) {
JlValue val = visit(ast.arg(), arg);
// TODO Increment this only when is an int
increment(ast.operator);
switch (ast.operator) {
case U_PLUS :
return val.plus();
case U_MINUS :
return val.minus();
case U_BOOL_NOT :
return val.not();
}
throw new DynamicError("Unhandled unary operator " + ast.operator,
ExitCode.INTERNAL_ERROR);
}
@Override
public JlValue var(Var ast, StackFrame arg) {
if (ast.sym == null) {
throw new DynamicError("Var node with null symbol",
ExitCode.INTERNAL_ERROR);
}
switch (ast.sym.kind) {
case LOCAL :
case PARAM :
return arg.var(ast.sym);
case FIELD :
return arg.getThisPointer().field(ast.sym);
}
throw new DynamicError("Unhandled VariableSymbol kind: "
+ ast.sym.kind, ExitCode.INTERNAL_ERROR);
}
}
public JlValue expr(Ast ast, StackFrame frame) {
return new ExprInterp().visit(ast, frame);
}
private ClassSymbol findMainClass() {
for (ClassDecl classDecl : classDecls) {
if (classDecl.name.equals("Main"))
return classDecl.sym;
}
throw new StaticError("No Main class found");
}
public ClassDecl findClassDecl(TypeSymbol typeSym) {
for (ClassDecl cd : classDecls) {
if (cd.sym == typeSym)
return cd;
}
throw new StaticError("No such type " + typeSym.name);
}
class MethodInterp extends cd.ir.AstVisitor<JlValue, StackFrame> {
public boolean earlyReturn = false;
@SuppressWarnings("serial")
class EarlyReturnException extends RuntimeException {
public JlValue value;
public EarlyReturnException(final JlValue value) {
this.value = value;
}
}
@Override
public JlValue assign(Assign ast, final StackFrame frame) {
new AstVisitor<Void, Expr>() {
@Override
public Void field(Field ast, Expr right) {
JlValue obj = expr(ast.arg(), frame);
assert obj != null && obj.asRef() != null;
final JlValue val = expr(right, frame);
assert val != null;
obj.asRef().setField(ast.sym, val);
return null;
}
@Override
public Void index(Index ast, Expr right) {
JlValue obj = expr(ast.left(), frame);
JlValue idx = expr(ast.right(), frame);
final JlValue val = expr(right, frame);
assert val != null;
obj.asRef().setDeref(idx.asInt(), val);
return null;
}
@Override
public Void var(Var ast, Expr right) {
final JlValue val = expr(right, frame);
assert val != null;
frame.setVar(ast.sym, val);
return null;
}
@Override
protected Void dflt(Ast ast, Expr arg) {
throw new StaticError("Malformed l-value in AST");
}
}.visit(ast.left(), ast.right());
return null;
}
@Override
public JlValue builtInWrite(BuiltInWrite ast, StackFrame frame) {
JlValue val = expr(ast.arg(), frame);
try {
output.write(Integer.toString(val.asInt()));
} catch (IOException e) {
throw new DynamicError(e, ExitCode.INTERNAL_ERROR);
}
return null;
}
@Override
public JlValue builtInWriteln(BuiltInWriteln ast, StackFrame arg) {
try {
output.write("\n");
} catch (IOException e) {
throw new DynamicError(e, ExitCode.INTERNAL_ERROR);
}
return null;
}
@Override
public JlValue ifElse(IfElse ast, StackFrame frame) {
JlValue cond = expr(ast.condition(), frame);
if (cond.asBoolean()) {
return visit(ast.then(), frame);
} else {
return visit(ast.otherwise(), frame);
}
}
@Override
public JlValue methodCall(MethodCall ast, final StackFrame frame) {
return expr(ast.getMethodCallExpr(), frame);
}
@Override
public JlValue whileLoop(WhileLoop ast, StackFrame frame) {
while (true) {
JlValue cond = expr(ast.condition(), frame);
if (!cond.asBoolean()) {
return null;
}
visit(ast.body(), frame);
}
}
@Override
public JlValue returnStmt(ReturnStmt ast, StackFrame frame) {
JlValue ret = null;
if (ast.arg() != null) {
ret = expr(ast.arg(), frame);
} else {
ret = new JlNull();
}
if (!earlyReturn) {
return ret;
} else {
throw new EarlyReturnException(ret);
}
}
}
public MethodDecl findMethodDecl(ClassSymbol typeSym,
final String methodName) {
ClassSymbol currSym = typeSym;
while (currSym != ClassSymbol.objectType) {
ClassDecl cd = findClassDecl(currSym);
final List<MethodDecl> result = new ArrayList<MethodDecl>();
for (Ast mem : cd.members()) {
AstVisitor<Void, Void> vis = new AstVisitor<Void, Void>() {
@Override
public Void methodDecl(MethodDecl ast, Void arg) {
if (!ast.name.equals(methodName)) {
return null;
}
result.add(ast);
return null;
}
};
vis.visit(mem, null);
}
if (result.size() == 1) {
return result.get(0);
}
if (result.size() > 1) {
throw new StaticError(result.size()
+ " implementations of method " + methodName
+ " found in type " + currSym.name);
}
currSym = currSym.superClass;
}
throw new StaticError("No method " + methodName + " in type " + typeSym);
}
// Note: does not interpret phis!
public JlValue interpretCfg(ControlFlowGraph cfg, final StackFrame frame) {
BasicBlock current = cfg.start;
MethodInterp minterp = new MethodInterp();
JlValue res = null;
while (true) {
step();
for(Stmt stmt : current.stmts) {
res = minterp.visit(stmt, frame);
if(stmt instanceof ReturnStmt)
return res;
}
if (current == cfg.end) {
return res;
} else if (current.condition == null) {
current = current.successors.get(0);
} else {
JlValue cond = expr(current.condition, frame);
if (cond.asBoolean()) {
current = current.trueSuccessor();
} else {
current = current.falseSuccessor();
}
}
}
}
public JlValue invokeMethod(final ClassSymbol typeSym,
final String methodName, final JlObject rcvr,
final List<JlValue> arguments) {
MethodDecl mdecl = findMethodDecl(typeSym, methodName);
StackFrame newFrame = new StackFrame(rcvr);
int idx = 0;
for (VariableSymbol sym : mdecl.sym.parameters) {
newFrame.setVar(sym, arguments.get(idx++));
}
if (mdecl.cfg != null) {
return interpretCfg(mdecl.cfg, newFrame);
} else {
final MethodInterp mthInterp = new MethodInterp();
mthInterp.earlyReturn = true;
try {
return mthInterp.visit(mdecl.body(), newFrame);
} catch (final EarlyReturnException ex) {
return ex.value;
}
}
}
}