diff options
Diffstat (limited to 'Homework/cs5300/compiler/p5-compiler/submit/ast')
29 files changed, 1181 insertions, 0 deletions
diff --git a/Homework/cs5300/compiler/p5-compiler/submit/ast/AbstractNode.java b/Homework/cs5300/compiler/p5-compiler/submit/ast/AbstractNode.java new file mode 100644 index 0000000..0a53882 --- /dev/null +++ b/Homework/cs5300/compiler/p5-compiler/submit/ast/AbstractNode.java @@ -0,0 +1,15 @@ +package submit.ast; + +import submit.MIPSResult; +import submit.RegisterAllocator; +import submit.SymbolTable; + +public class AbstractNode implements Node { + public void toCminus(StringBuilder sb, String prefix) { + } + + public MIPSResult toMIPS(StringBuilder code, StringBuilder data, SymbolTable symbolTable, + RegisterAllocator regAllocator) { + return MIPSResult.createVoidResult(); + } +} diff --git a/Homework/cs5300/compiler/p5-compiler/submit/ast/Assignment.java b/Homework/cs5300/compiler/p5-compiler/submit/ast/Assignment.java new file mode 100644 index 0000000..9c06cbe --- /dev/null +++ b/Homework/cs5300/compiler/p5-compiler/submit/ast/Assignment.java @@ -0,0 +1,58 @@ +/* + * Code formatter project + * CS 4481 + */ +package submit.ast; + +import submit.MIPSResult; +import submit.RegisterAllocator; +import submit.SymbolTable; + +/** + * + * @author edwajohn + */ +public class Assignment extends AbstractNode implements Expression { + + private final Mutable mutable; + private final AssignmentType type; + private final Expression rhs; + + public Assignment(Mutable mutable, String assign, Expression rhs) { + this.mutable = mutable; + this.type = AssignmentType.fromString(assign); + this.rhs = rhs; + } + + public void toCminus(StringBuilder builder, final String prefix) { + mutable.toCminus(builder, prefix); + if (rhs != null) { + builder.append(" ").append(type.toString()).append(" "); + rhs.toCminus(builder, prefix); + } else { + builder.append(type.toString()); + } + } + + public MIPSResult toMIPS(StringBuilder code, StringBuilder data, + SymbolTable symbolTable, + RegisterAllocator regAllocator) { + MIPSResult mut = mutable.toMIPS(code, data, symbolTable, regAllocator); + MIPSResult result = rhs.toMIPS(code, data, symbolTable, regAllocator); + + String registerWithAddressOfMutable = mut.getAddress(); + + if (result.getRegister() != null) { + code.append(String.format("sw %s 0(%s)\n", result.getRegister(), + registerWithAddressOfMutable)); + regAllocator.clear(result.getRegister()); + } else if (result.getAddress() != null) { + regAllocator.loadIntoRegister(result, code, result.getAddress()); + regAllocator.clear(result.getAddress()); + } + + regAllocator.clear(registerWithAddressOfMutable); + + return MIPSResult.createVoidResult(); + } +} diff --git a/Homework/cs5300/compiler/p5-compiler/submit/ast/AssignmentType.java b/Homework/cs5300/compiler/p5-compiler/submit/ast/AssignmentType.java new file mode 100644 index 0000000..9dd2bdf --- /dev/null +++ b/Homework/cs5300/compiler/p5-compiler/submit/ast/AssignmentType.java @@ -0,0 +1,35 @@ +/* + * Code formatter project + * CS 4481 + */ +package submit.ast; + +/** + * + * @author edwajohn + */ +public enum AssignmentType { + + EQUALS("="), PLUS("+="), MINUS("-="), TIMES("*="), DIVIDE("/="), INC("++"), DEC("--"); + + private final String value; + + private AssignmentType(String value) { + this.value = value; + } + + public static AssignmentType fromString(String s) { + for (AssignmentType at : AssignmentType.values()) { + if (at.value.equals(s)) { + return at; + } + } + throw new RuntimeException("Illegal string in AssignType.fromString()"); + } + + @Override + public String toString() { + return value; + } + +} diff --git a/Homework/cs5300/compiler/p5-compiler/submit/ast/BinaryOperator.java b/Homework/cs5300/compiler/p5-compiler/submit/ast/BinaryOperator.java new file mode 100644 index 0000000..3afce78 --- /dev/null +++ b/Homework/cs5300/compiler/p5-compiler/submit/ast/BinaryOperator.java @@ -0,0 +1,89 @@ +/* + * Code formatter project + * CS 4481 + */ +package submit.ast; + +import submit.MIPSResult; +import submit.RegisterAllocator; +import submit.SymbolTable; + +/** + * + * @author edwajohn + */ +public class BinaryOperator extends AbstractNode implements Expression { + + private final Expression lhs, rhs; + private final BinaryOperatorType type; + + public BinaryOperator(Expression lhs, BinaryOperatorType type, + Expression rhs) { + this.lhs = lhs; + this.type = type; + this.rhs = rhs; + } + + public BinaryOperator(Expression lhs, String type, Expression rhs) { + this.lhs = lhs; + this.type = BinaryOperatorType.fromString(type); + this.rhs = rhs; + } + + @Override + public void toCminus(StringBuilder builder, String prefix) { + lhs.toCminus(builder, prefix); + builder.append(" ").append(type).append(" "); + rhs.toCminus(builder, prefix); + } + + @Override + public MIPSResult toMIPS(StringBuilder code, StringBuilder data, + SymbolTable symbolTable, + RegisterAllocator registerAllocator) { + + switch (type) { + case PLUS: + case MINUS: + case TIMES: + case DIVIDE: + MIPSResult left = lhs.toMIPS(code, data, symbolTable, registerAllocator); + String leftRegister = + registerAllocator.getRegisterOrLoadIntoRegister(left, code); + + MIPSResult right = rhs.toMIPS(code, data, symbolTable, registerAllocator); + String rightRegister = + registerAllocator.getRegisterOrLoadIntoRegister(right, code); + String resultRegister = registerAllocator.getAny(); + switch (type) { + case PLUS: + code.append(String.format("add %s %s %s\n", resultRegister, + leftRegister, rightRegister)); + break; + case MINUS: + code.append(String.format("sub %s %s %s\n", resultRegister, + leftRegister, rightRegister)); + break; + case TIMES: + code.append(String.format("mult %s %s\n", leftRegister, rightRegister)); + code.append(String.format("mflo %s\n", resultRegister)); + break; + case DIVIDE: + code.append(String.format("div %s %s\n", leftRegister, rightRegister)); + code.append(String.format("mflo %s\n", resultRegister)); + break; + default: + break; + } + + registerAllocator.clear(leftRegister); + registerAllocator.clear(rightRegister); + + return MIPSResult.createRegisterResult(resultRegister, VarType.INT); + default: + break; + } + + return MIPSResult.createVoidResult(); + } +} diff --git a/Homework/cs5300/compiler/p5-compiler/submit/ast/BinaryOperatorType.java b/Homework/cs5300/compiler/p5-compiler/submit/ast/BinaryOperatorType.java new file mode 100644 index 0000000..fea3d6e --- /dev/null +++ b/Homework/cs5300/compiler/p5-compiler/submit/ast/BinaryOperatorType.java @@ -0,0 +1,45 @@ +/* + * Code formatter project + * CS 4481 + */ +package submit.ast; + +/** + * + * @author edwajohn + */ +public enum BinaryOperatorType { + + OR("||"), + AND("&&"), + LE("<="), + LT("<"), + GT(">"), + GE(">="), + EQ("=="), + NE("!="), + PLUS("+"), + MINUS("-"), + TIMES("*"), + DIVIDE("/"), + MOD("%"); + + private final String value; + + private BinaryOperatorType(String value) { this.value = value; } + + public static BinaryOperatorType fromString(String s) { + for (BinaryOperatorType at : BinaryOperatorType.values()) { + if (at.value.equals(s)) { + return at; + } + } + throw new RuntimeException("Illegal string in OperatorType.fromString(): " + + s); + } + + @Override + public String toString() { + return value; + } +} diff --git a/Homework/cs5300/compiler/p5-compiler/submit/ast/BoolConstant.java b/Homework/cs5300/compiler/p5-compiler/submit/ast/BoolConstant.java new file mode 100644 index 0000000..2a7a281 --- /dev/null +++ b/Homework/cs5300/compiler/p5-compiler/submit/ast/BoolConstant.java @@ -0,0 +1,23 @@ +/* + * Code formatter project + * CS 4481 + */ +package submit.ast; + +/** + * + * @author edwajohn + */ +public class BoolConstant extends AbstractNode implements Expression { + private final boolean value; + + public BoolConstant(boolean value) { this.value = value; } + + public void toCminus(StringBuilder builder, final String prefix) { + if (value) { + builder.append("true"); + } else { + builder.append("false"); + } + } +} diff --git a/Homework/cs5300/compiler/p5-compiler/submit/ast/Break.java b/Homework/cs5300/compiler/p5-compiler/submit/ast/Break.java new file mode 100644 index 0000000..0582c91 --- /dev/null +++ b/Homework/cs5300/compiler/p5-compiler/submit/ast/Break.java @@ -0,0 +1,16 @@ +/* + * Code formatter project + * CS 4481 + */ +package submit.ast; + +/** + * + * @author edwajohn + */ +public class Break extends AbstractNode implements Statement { + @Override + public void toCminus(StringBuilder builder, String prefix) { + builder.append(prefix).append("break;\n"); + } +} diff --git a/Homework/cs5300/compiler/p5-compiler/submit/ast/Call.java b/Homework/cs5300/compiler/p5-compiler/submit/ast/Call.java new file mode 100644 index 0000000..7da86cd --- /dev/null +++ b/Homework/cs5300/compiler/p5-compiler/submit/ast/Call.java @@ -0,0 +1,139 @@ +/* + * Code formatter project + * CS 4481 + */ +package submit.ast; + +import java.util.ArrayList; +import java.util.List; +import java.util.stream.Collectors; +import submit.MIPSResult; +import submit.RegisterAllocator; +import submit.SymbolTable; + +/** + * + * @author edwajohn + */ +public class Call implements Expression { + + private final String id; + private final List<Expression> args; + + public Call(String id, List<Expression> args) { + this.id = id; + this.args = new ArrayList<>(args); + } + + private void println(List<MIPSResult> mipsResults, StringBuilder code, + StringBuilder data, SymbolTable symbolTable, + RegisterAllocator registerAllocator) { + code.append("# println\n"); + + for (MIPSResult result : mipsResults) { + if (result.getRegister() == null && result.getAddress() != null) { + if (result.getAddress().startsWith("$")) { + // Hack - might be a register + registerAllocator.loadIntoRegister(result, code, "$a0"); + } else { + code.append(String.format("la $a0 %s\n", result.getAddress())); + } + } else if (result.getRegister() != null) { + code.append(String.format("move $a0 %s\n", result.getRegister())); + } + + if (result.getType() == VarType.INT) { + code.append("li $v0 1\n"); + } else if (result.getType() == VarType.CHAR) { + code.append("li $v0 11\n"); + } else { + code.append("li $v0 4\n"); + } + code.append("syscall\n"); + } + + // End line with newline + code.append(String.format("la $a0 %s\n", "newline")); + code.append("li $v0 4\n"); + code.append("syscall\n"); + } + + @Override + public void toCminus(StringBuilder builder, String prefix) { + builder.append(id).append("("); + for (Expression arg : args) { + arg.toCminus(builder, prefix); + builder.append(", "); + } + if (!args.isEmpty()) { + builder.setLength(builder.length() - 2); + } + builder.append(")"); + } + + @Override + public MIPSResult toMIPS(StringBuilder code, StringBuilder data, + SymbolTable symbolTable, + RegisterAllocator registerAllocator) { + List<MIPSResult> argMips; + String resultRegister = null; + + if (this.id.equals("println")) { + argMips = + args.stream() + .map(e -> e.toMIPS(code, data, symbolTable, registerAllocator)) + .collect(Collectors.toList()); + this.println(argMips, code, data, symbolTable, registerAllocator); + } else { + argMips = new ArrayList<MIPSResult>(); + String returnAddr = registerAllocator.getAny(); + code.append(String.format("move %s $ra\n", returnAddr)); + int savedRegistersOffset = registerAllocator.saveRestore( + code, -symbolTable.getOffset(), false, true); + + int argsOffset = symbolTable.getOffset() - savedRegistersOffset; + int i = argsOffset; + for (Expression expression : args) { + MIPSResult mipsResult = + expression.toMIPS(code, data, symbolTable, registerAllocator); + argMips.add(mipsResult); + i -= 4; + + String reg = + registerAllocator.getRegisterOrLoadIntoRegister(mipsResult, code); + code.append(String.format("sw %s %d($sp)\n", reg, i)); + + registerAllocator.clear(reg); + } + + code.append(String.format("add $sp $sp %d\n", argsOffset)); + + code.append(String.format("jal %s\n", id)); + + code.append(String.format("add $sp $sp %d\n", -argsOffset)); + + registerAllocator.saveRestore(code, -symbolTable.getOffset(), false, + false); + code.append(String.format("# symbol table size - %d\n", i)); + + resultRegister = registerAllocator.getAny(); + registerAllocator.loadIntoRegisterWithOffset( + MIPSResult.createAddressResult("$sp", VarType.INT), code, + resultRegister, i - 4); + + code.append(String.format("move $ra %s\n", returnAddr)); + registerAllocator.clear(returnAddr); + } + + for (MIPSResult arg : argMips) + if (arg.getRegister() != null) + registerAllocator.clear(arg.getRegister()); + + if (resultRegister != null) { + VarType returnType = symbolTable.find(id).getType(); + return MIPSResult.createRegisterResult(resultRegister, returnType); + } + + return MIPSResult.createVoidResult(); + } +} diff --git a/Homework/cs5300/compiler/p5-compiler/submit/ast/CharConstant.java b/Homework/cs5300/compiler/p5-compiler/submit/ast/CharConstant.java new file mode 100644 index 0000000..5334be2 --- /dev/null +++ b/Homework/cs5300/compiler/p5-compiler/submit/ast/CharConstant.java @@ -0,0 +1,19 @@ +/* + * Code formatter project + * CS 4481 + */ +package submit.ast; + +/** + * + * @author edwajohn + */ +public class CharConstant extends AbstractNode implements Expression { + private final char value; + + public CharConstant(char value) { this.value = value; } + + public void toCminus(StringBuilder builder, final String prefix) { + builder.append("'").append(value).append("'"); + } +} diff --git a/Homework/cs5300/compiler/p5-compiler/submit/ast/CompoundStatement.java b/Homework/cs5300/compiler/p5-compiler/submit/ast/CompoundStatement.java new file mode 100644 index 0000000..4d1c666 --- /dev/null +++ b/Homework/cs5300/compiler/p5-compiler/submit/ast/CompoundStatement.java @@ -0,0 +1,59 @@ +/* + * Code formatter project + * CS 4481 + */ +package submit.ast; + +import java.util.List; +import submit.MIPSResult; +import submit.RegisterAllocator; +import submit.SymbolTable; + +/** + * + * @author edwajohn + */ +public class CompoundStatement extends AbstractNode implements Statement { + + private final List<Statement> statements; + private SymbolTable symbolTable; + + public CompoundStatement(List<Statement> statements, + SymbolTable symbolTable) { + this.statements = statements; + this.symbolTable = symbolTable; + } + + public SymbolTable getSymbolTable() { return symbolTable; } + + @Override + public void toCminus(StringBuilder builder, String prefix) { + builder.append(prefix).append("{\n"); + for (Statement s : statements) { + s.toCminus(builder, prefix + " "); + } + builder.append(prefix).append("}\n"); + } + + @Override + public MIPSResult toMIPS(StringBuilder code, StringBuilder data, + SymbolTable symbolTable, + RegisterAllocator registerAllocator) { + code.append("# Entering a new scope.\n"); + code.append("# Symbols in symbol table:\n"); + for (String name : this.symbolTable.symbolNames()) + code.append( + String.format("# %s : %d\n", name, this.symbolTable.offsetOf(name))); + + code.append("# Update the stack pointer.\n"); + code.append(String.format("addi $sp $sp %d\n", symbolTable.getOffset())); + + for (Statement statement : statements) + statement.toMIPS(code, data, this.symbolTable, registerAllocator); + + code.append("# Exit scope.\n"); + code.append(String.format("addi $sp $sp %s\n", -symbolTable.getOffset())); + + return MIPSResult.createVoidResult(); + } +} diff --git a/Homework/cs5300/compiler/p5-compiler/submit/ast/Declaration.java b/Homework/cs5300/compiler/p5-compiler/submit/ast/Declaration.java new file mode 100644 index 0000000..99c1c1a --- /dev/null +++ b/Homework/cs5300/compiler/p5-compiler/submit/ast/Declaration.java @@ -0,0 +1,11 @@ +/* + * Code formatter project + * CS 4481 + */ +package submit.ast; + +/** + * + * @author edwajohn + */ +public interface Declaration extends Statement {} diff --git a/Homework/cs5300/compiler/p5-compiler/submit/ast/Expression.java b/Homework/cs5300/compiler/p5-compiler/submit/ast/Expression.java new file mode 100644 index 0000000..d31753a --- /dev/null +++ b/Homework/cs5300/compiler/p5-compiler/submit/ast/Expression.java @@ -0,0 +1,11 @@ +/* + * Code formatter project + * CS 4481 + */ +package submit.ast; + +/** + * + * @author edwajohn + */ +public interface Expression extends Node {} diff --git a/Homework/cs5300/compiler/p5-compiler/submit/ast/ExpressionStatement.java b/Homework/cs5300/compiler/p5-compiler/submit/ast/ExpressionStatement.java new file mode 100644 index 0000000..7870a2e --- /dev/null +++ b/Homework/cs5300/compiler/p5-compiler/submit/ast/ExpressionStatement.java @@ -0,0 +1,37 @@ +/* + * Code formatter project + * CS 4481 + */ +package submit.ast; + +import submit.MIPSResult; +import submit.RegisterAllocator; +import submit.SymbolTable; + +/** + * + * @author edwajohn + */ +public class ExpressionStatement extends AbstractNode implements Statement { + + private final Expression expression; + + public ExpressionStatement(Expression expression) { + this.expression = expression; + } + + @Override + public void toCminus(StringBuilder builder, String prefix) { + builder.append(prefix); + expression.toCminus(builder, prefix); + builder.append(";\n"); + } + + @Override + public MIPSResult toMIPS(StringBuilder code, StringBuilder data, + SymbolTable symbolTable, + RegisterAllocator registerAllocator) { + expression.toMIPS(code, data, symbolTable, registerAllocator); + return MIPSResult.createVoidResult(); + } +} diff --git a/Homework/cs5300/compiler/p5-compiler/submit/ast/FunDeclaration.java b/Homework/cs5300/compiler/p5-compiler/submit/ast/FunDeclaration.java new file mode 100644 index 0000000..f60840b --- /dev/null +++ b/Homework/cs5300/compiler/p5-compiler/submit/ast/FunDeclaration.java @@ -0,0 +1,65 @@ +/* + * Code formatter project + * CS 4481 + */ +package submit.ast; + +import java.util.ArrayList; +import java.util.List; +import submit.MIPSResult; +import submit.RegisterAllocator; +import submit.SymbolTable; + +/** + * + * @author edwajohn + */ +public class FunDeclaration extends AbstractNode implements Declaration { + + private final VarType returnType; + private final String id; + private final ArrayList<Param> params; + private final Statement statement; + + public FunDeclaration(VarType returnType, String id, List<Param> params, + Statement statement) { + this.returnType = returnType; + this.id = id; + this.params = new ArrayList<>(params); + this.statement = statement; + } + + public void toCminus(StringBuilder builder, final String prefix) { + String rt = (returnType != null) ? returnType.toString() : "void"; + builder.append("\n").append(rt).append(" "); + builder.append(id); + builder.append("("); + + for (Param param : params) { + param.toCminus(builder, prefix); + builder.append(", "); + } + if (!params.isEmpty()) { + builder.delete(builder.length() - 2, builder.length()); + } + builder.append(")\n"); + statement.toCminus(builder, prefix); + } + + @Override + public MIPSResult toMIPS(StringBuilder code, StringBuilder data, + SymbolTable symbolTable, + RegisterAllocator registerAllocator) { + code.append(id).append(":\n"); + + statement.toMIPS(code, data, symbolTable, registerAllocator); + + if (id.equals("main")) + code.append("li $v0 10\nsyscall\n"); + else + code.append("jr $ra\n"); + registerAllocator.clearAll(); + + return MIPSResult.createVoidResult(); + } +} diff --git a/Homework/cs5300/compiler/p5-compiler/submit/ast/If.java b/Homework/cs5300/compiler/p5-compiler/submit/ast/If.java new file mode 100644 index 0000000..1a481ed --- /dev/null +++ b/Homework/cs5300/compiler/p5-compiler/submit/ast/If.java @@ -0,0 +1,45 @@ +/* + * Code formatter project + * CS 4481 + */ +package submit.ast; + +/** + * + * @author edwajohn + */ +public class If extends AbstractNode implements Statement { + + private final Expression expression; + private final Statement trueStatement; + private final Statement falseStatement; + + public If(Expression expression, Statement trueStatement, + Statement falseStatement) { + this.expression = expression; + this.trueStatement = trueStatement; + this.falseStatement = falseStatement; + } + + @Override + public void toCminus(StringBuilder builder, String prefix) { + builder.append(prefix).append("if ("); + expression.toCminus(builder, prefix); + builder.append(")\n"); + if (trueStatement instanceof CompoundStatement) { + trueStatement.toCminus(builder, prefix); + } else { + trueStatement.toCminus(builder, prefix + " "); + } + if (falseStatement != null) { + builder.append(prefix).append("else\n"); + // falseStatement.toCminus(builder, prefix); + if (falseStatement instanceof CompoundStatement) { + falseStatement.toCminus(builder, prefix); + } else { + falseStatement.toCminus(builder, prefix + " "); + } + } + // builder.append(prefix).append("}"); + } +} diff --git a/Homework/cs5300/compiler/p5-compiler/submit/ast/Mutable.java b/Homework/cs5300/compiler/p5-compiler/submit/ast/Mutable.java new file mode 100644 index 0000000..ac9b7ff --- /dev/null +++ b/Homework/cs5300/compiler/p5-compiler/submit/ast/Mutable.java @@ -0,0 +1,45 @@ +/* + * Code formatter project + * CS 4481 + */ +package submit.ast; + +import submit.MIPSResult; +import submit.RegisterAllocator; +import submit.SymbolTable; + +/** + * + * @author edwajohn + */ +public class Mutable implements Expression { + + private final String id; + private final Expression index; + + public Mutable(String id, Expression index) { + this.id = id; + this.index = index; + } + + @Override + public void toCminus(StringBuilder builder, String prefix) { + builder.append(id); + if (index != null) { + builder.append("["); + index.toCminus(builder, prefix); + builder.append("]"); + } + } + + public MIPSResult toMIPS(StringBuilder code, StringBuilder data, + SymbolTable symbolTable, + RegisterAllocator regAllocator) { + String stackReg = regAllocator.getAny(); + + code.append(String.format("li %s %d\n", stackReg, symbolTable.offsetOf(id))) + .append(String.format("add %s %s $sp\n", stackReg, stackReg)); + + return MIPSResult.createAddressResult(stackReg, VarType.INT); + } +} diff --git a/Homework/cs5300/compiler/p5-compiler/submit/ast/Node.java b/Homework/cs5300/compiler/p5-compiler/submit/ast/Node.java new file mode 100644 index 0000000..cc6c2d5 --- /dev/null +++ b/Homework/cs5300/compiler/p5-compiler/submit/ast/Node.java @@ -0,0 +1,12 @@ +package submit.ast; + +import submit.MIPSResult; +import submit.RegisterAllocator; +import submit.SymbolTable; + +public interface Node { + void toCminus(StringBuilder builder, final String prefix); + + MIPSResult toMIPS(StringBuilder code, StringBuilder data, + SymbolTable symbolTable, RegisterAllocator regAllocator); +} diff --git a/Homework/cs5300/compiler/p5-compiler/submit/ast/NumConstant.java b/Homework/cs5300/compiler/p5-compiler/submit/ast/NumConstant.java new file mode 100644 index 0000000..3389238 --- /dev/null +++ b/Homework/cs5300/compiler/p5-compiler/submit/ast/NumConstant.java @@ -0,0 +1,34 @@ +/* + * Code formatter project + * CS 4481 + */ +package submit.ast; + +import submit.MIPSResult; +import submit.RegisterAllocator; +import submit.SymbolTable; + +/** + * + * @author edwajohn + */ +public class NumConstant extends AbstractNode implements Expression { + + private final int value; + + public NumConstant(int value) { this.value = value; } + + public void toCminus(StringBuilder builder, final String prefix) { + builder.append(Integer.toString(value)); + } + + @Override + public MIPSResult toMIPS(StringBuilder code, StringBuilder data, + SymbolTable symbolTable, + RegisterAllocator registerAllocator) { + String register = registerAllocator.getAny(); + code.append(String.format("li %s %d\n", register, value)); + + return MIPSResult.createRegisterResult(register, VarType.INT); + } +} diff --git a/Homework/cs5300/compiler/p5-compiler/submit/ast/Param.java b/Homework/cs5300/compiler/p5-compiler/submit/ast/Param.java new file mode 100644 index 0000000..921b179 --- /dev/null +++ b/Homework/cs5300/compiler/p5-compiler/submit/ast/Param.java @@ -0,0 +1,36 @@ +/* + * Code formatter project + * CS 4481 + */ +package submit.ast; + +/** + * + * @author edwajohn + */ +public class Param extends AbstractNode implements Node { + + private final VarType type; + private final String id; + private final boolean array; + + public Param(VarType type, String id, boolean array) { + this.type = type; + this.id = id; + this.array = array; + } + + public VarType getType() { return type; } + + public String getId() { return id; } + + public boolean isArray() { return array; } + + public void toCminus(StringBuilder builder, final String prefix) { + if (isArray()) { + builder.append(type).append(" ").append(id).append("[]"); + } else { + builder.append(type).append(" ").append(id); + } + } +} diff --git a/Homework/cs5300/compiler/p5-compiler/submit/ast/ParenExpression.java b/Homework/cs5300/compiler/p5-compiler/submit/ast/ParenExpression.java new file mode 100644 index 0000000..e61dfe3 --- /dev/null +++ b/Homework/cs5300/compiler/p5-compiler/submit/ast/ParenExpression.java @@ -0,0 +1,36 @@ +/* + * Code formatter project + * CS 4481 + */ +package submit.ast; + +import submit.MIPSResult; +import submit.RegisterAllocator; +import submit.SymbolTable; + +/** + * + * @author edwajohn + */ +public class ParenExpression extends AbstractNode implements Expression { + + private final Expression expression; + + public ParenExpression(Expression expression) { + this.expression = expression; + } + + @Override + public void toCminus(StringBuilder builder, String prefix) { + builder.append("("); + expression.toCminus(builder, prefix); + builder.append(")"); + } + + @Override + public MIPSResult toMIPS(StringBuilder code, StringBuilder data, + SymbolTable symbolTable, + RegisterAllocator registerAllocator) { + return expression.toMIPS(code, data, symbolTable, registerAllocator); + } +} diff --git a/Homework/cs5300/compiler/p5-compiler/submit/ast/Program.java b/Homework/cs5300/compiler/p5-compiler/submit/ast/Program.java new file mode 100644 index 0000000..e32a7d2 --- /dev/null +++ b/Homework/cs5300/compiler/p5-compiler/submit/ast/Program.java @@ -0,0 +1,50 @@ +/* + * Code formatter project + * CS 4481 + */ +package submit.ast; + +import java.util.ArrayList; +import java.util.List; +import submit.MIPSResult; +import submit.RegisterAllocator; +import submit.SymbolTable; + +/** + * + * @author edwajohn + */ +public class Program extends AbstractNode implements Node { + + private ArrayList<Declaration> declarations; + + public Program(List<Declaration> declarations) { + this.declarations = new ArrayList<>(declarations); + } + + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + toCminus(builder, ""); + return builder.toString(); + } + + @Override + public void toCminus(StringBuilder builder, String prefix) { + for (Declaration declaration : declarations) { + declaration.toCminus(builder, ""); + } + } + + @Override + public MIPSResult toMIPS(StringBuilder code, StringBuilder data, + SymbolTable symbolTable, + RegisterAllocator registerAllocator) { + // Store newline in .data + data.append("newline: .asciiz \"\\n\"\n"); + + for (Declaration declaration : declarations) + declaration.toMIPS(code, data, symbolTable, registerAllocator); + return MIPSResult.createVoidResult(); + } +} diff --git a/Homework/cs5300/compiler/p5-compiler/submit/ast/Return.java b/Homework/cs5300/compiler/p5-compiler/submit/ast/Return.java new file mode 100644 index 0000000..b5dd761 --- /dev/null +++ b/Homework/cs5300/compiler/p5-compiler/submit/ast/Return.java @@ -0,0 +1,46 @@ +/* + * Code formatter project + * CS 4481 + */ +package submit.ast; + +import submit.MIPSResult; +import submit.RegisterAllocator; +import submit.SymbolTable; + +/** + * + * @author edwajohn + */ +public class Return extends AbstractNode implements Statement { + private final Expression expr; + + public Return(Expression expr) { this.expr = expr; } + + @Override + public void toCminus(StringBuilder builder, String prefix) { + builder.append(prefix); + if (expr == null) { + builder.append("return;\n"); + } else { + builder.append("return "); + expr.toCminus(builder, prefix); + builder.append(";\n"); + } + } + + @Override + public MIPSResult toMIPS(StringBuilder code, StringBuilder data, + SymbolTable symbolTable, + RegisterAllocator regAllocator) { + if (expr != null) { + String reg = regAllocator.getRegisterOrLoadIntoRegister( + expr.toMIPS(code, data, symbolTable, regAllocator), code); + code.append( + String.format("# symbol table size - %d\n", symbolTable.getOffset())); + code.append( + String.format("sw %s %d($sp)\n", reg, symbolTable.getOffset())); + } + return MIPSResult.createVoidResult(); + } +} diff --git a/Homework/cs5300/compiler/p5-compiler/submit/ast/Statement.java b/Homework/cs5300/compiler/p5-compiler/submit/ast/Statement.java new file mode 100644 index 0000000..2daeb9d --- /dev/null +++ b/Homework/cs5300/compiler/p5-compiler/submit/ast/Statement.java @@ -0,0 +1,18 @@ +/* + * Code formatter project + * CS 4481 + */ +package submit.ast; + +import java.util.ArrayList; + +/** + * + * @author edwajohn + */ +public interface Statement extends Node { + public static CompoundStatement empty() { + submit.SymbolTable newTable = new submit.SymbolTable(); + return new CompoundStatement(new ArrayList<>(), newTable); + } +} diff --git a/Homework/cs5300/compiler/p5-compiler/submit/ast/StringConstant.java b/Homework/cs5300/compiler/p5-compiler/submit/ast/StringConstant.java new file mode 100644 index 0000000..bd4c37d --- /dev/null +++ b/Homework/cs5300/compiler/p5-compiler/submit/ast/StringConstant.java @@ -0,0 +1,34 @@ +/* + * Code formatter project + * CS 4481 + */ +package submit.ast; + +import submit.MIPSResult; +import submit.RegisterAllocator; +import submit.SymbolTable; + +/** + * + * @author edwajohn + */ +public class StringConstant extends AbstractNode implements Expression { + + private final String value; + + public StringConstant(String value) { this.value = value; } + + public void toCminus(StringBuilder builder, final String prefix) { + builder.append("\"").append(value).append("\""); + } + + @Override + public MIPSResult toMIPS(StringBuilder code, StringBuilder data, + SymbolTable symbolTable, + RegisterAllocator registerAllocator) { + String label = String.format("string_%s", SymbolTable.nextId()); + data.append(String.format("%s: .asciiz %s\n", label, value)); + + return MIPSResult.createAddressResult(label, null); + } +} diff --git a/Homework/cs5300/compiler/p5-compiler/submit/ast/UnaryOperator.java b/Homework/cs5300/compiler/p5-compiler/submit/ast/UnaryOperator.java new file mode 100644 index 0000000..799a0be --- /dev/null +++ b/Homework/cs5300/compiler/p5-compiler/submit/ast/UnaryOperator.java @@ -0,0 +1,54 @@ +/* + * Code formatter project + * CS 4481 + */ +package submit.ast; + +import submit.MIPSResult; +import submit.RegisterAllocator; +import submit.SymbolTable; + +/** + * + * @author edwajohn + */ +public class UnaryOperator extends AbstractNode implements Expression { + + private final UnaryOperatorType type; + private final Expression expression; + + public UnaryOperator(String type, Expression expression) { + this.type = UnaryOperatorType.fromString(type); + this.expression = expression; + } + + @Override + public void toCminus(StringBuilder builder, String prefix) { + builder.append(type); + expression.toCminus(builder, prefix); + } + @Override + public MIPSResult toMIPS(StringBuilder code, StringBuilder data, + SymbolTable symbolTable, + RegisterAllocator regAllocator) { + MIPSResult result = + expression.toMIPS(code, data, symbolTable, regAllocator); + + if (type == UnaryOperatorType.NEG) { + code.append("# Negation\n"); + if (result.getAddress() != null) { + String reg = regAllocator.getRegisterOrLoadIntoRegister(result, code); + + code.append(String.format("sub %s, $zero, %s\n", reg, reg)) + .append(String.format("sw %s 0(%s)\n", reg, result.getAddress())); + + regAllocator.clear(reg); + } else { + code.append(String.format("sub %s, $zero, %s\n", result.getRegister(), + result.getRegister())); + } + } + + return result; + } +} diff --git a/Homework/cs5300/compiler/p5-compiler/submit/ast/UnaryOperatorType.java b/Homework/cs5300/compiler/p5-compiler/submit/ast/UnaryOperatorType.java new file mode 100644 index 0000000..828ee5a --- /dev/null +++ b/Homework/cs5300/compiler/p5-compiler/submit/ast/UnaryOperatorType.java @@ -0,0 +1,35 @@ +/* + * Code formatter project + * CS 4481 + */ +package submit.ast; + +/** + * + * @author edwajohn + */ +public enum UnaryOperatorType { + + NOT("!"), NEG("-"), DEREF("*"), QUESTION("?"); + + private final String value; + + private UnaryOperatorType(String value) { + this.value = value; + } + + public static UnaryOperatorType fromString(String s) { + for (UnaryOperatorType at : UnaryOperatorType.values()) { + if (at.value.equals(s)) { + return at; + } + } + throw new RuntimeException("Illegal string in UnaryOperatorType.fromString()"); + } + + @Override + public String toString() { + return value; + } + +} diff --git a/Homework/cs5300/compiler/p5-compiler/submit/ast/VarDeclaration.java b/Homework/cs5300/compiler/p5-compiler/submit/ast/VarDeclaration.java new file mode 100644 index 0000000..809518f --- /dev/null +++ b/Homework/cs5300/compiler/p5-compiler/submit/ast/VarDeclaration.java @@ -0,0 +1,48 @@ +/* + * Code formatter project + * CS 4481 + */ +package submit.ast; + +import java.util.ArrayList; +import java.util.List; + +/** + * + * @author edwajohn + */ +public class VarDeclaration extends AbstractNode implements Declaration { + + private final VarType type; + private final List<String> ids; + private final List<Integer> arraySizes; + private final boolean isStatic; + + public VarDeclaration(VarType type, List<String> ids, + List<Integer> arraySizes, boolean isStatic) { + this.type = type; + this.ids = new ArrayList<>(ids); + this.arraySizes = arraySizes; + this.isStatic = isStatic; + } + + public void toCminus(StringBuilder builder, final String prefix) { + builder.append(prefix); + if (isStatic) { + builder.append("static "); + } + builder.append(type).append(" "); + for (int i = 0; i < ids.size(); ++i) { + final String id = ids.get(i); + final int arraySize = arraySizes.get(i); + if (arraySize >= 0) { + builder.append(id).append("[").append(arraySize).append("]").append( + ", "); + } else { + builder.append(id).append(", "); + } + } + builder.delete(builder.length() - 2, builder.length()); + builder.append(";\n"); + } +} diff --git a/Homework/cs5300/compiler/p5-compiler/submit/ast/VarType.java b/Homework/cs5300/compiler/p5-compiler/submit/ast/VarType.java new file mode 100644 index 0000000..e797d50 --- /dev/null +++ b/Homework/cs5300/compiler/p5-compiler/submit/ast/VarType.java @@ -0,0 +1,34 @@ +/* + * Code formatter project + * CS 4481 + */ +package submit.ast; + +/** + * + * @author edwajohn + */ +public enum VarType { + + INT("int"), + BOOL("bool"), + CHAR("char"); + + private final String value; + + private VarType(String value) { this.value = value; } + + public static VarType fromString(String s) { + for (VarType vt : VarType.values()) { + if (vt.value.equals(s)) { + return vt; + } + } + throw new RuntimeException("Illegal string in VarType.fromString()"); + } + + @Override + public String toString() { + return value; + } +} diff --git a/Homework/cs5300/compiler/p5-compiler/submit/ast/While.java b/Homework/cs5300/compiler/p5-compiler/submit/ast/While.java new file mode 100644 index 0000000..70b8e9f --- /dev/null +++ b/Homework/cs5300/compiler/p5-compiler/submit/ast/While.java @@ -0,0 +1,32 @@ +/* + * Code formatter project + * CS 4481 + */ +package submit.ast; + +/** + * + * @author edwajohn + */ +public class While extends AbstractNode implements Statement { + + private final Expression expression; + private final Statement statement; + + public While(Expression expression, Statement statement) { + this.expression = expression; + this.statement = statement; + } + + @Override + public void toCminus(StringBuilder builder, String prefix) { + builder.append(prefix).append("while ("); + expression.toCminus(builder, prefix); + builder.append(")\n"); + if (statement instanceof CompoundStatement) { + statement.toCminus(builder, prefix); + } else { + statement.toCminus(builder, prefix + " "); + } + } +} |