InitHEADmain

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 + " ");
+    }
+  }
+}