InitHEADmain

37 files changed, 1165 insertions, 0 deletions

diff --git a/Homework/cs5300/p4-formatter/submit/ASTVisitor.java b/Homework/cs5300/p4-formatter/submit/ASTVisitor.java
new file mode 100644
index 0000000..7f6d020
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/ASTVisitor.java
@@ -0,0 +1,239 @@
+package submit;
+
+import parser.CminusBaseVisitor;
+import parser.CminusParser;
+import submit.ast.*;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.logging.Logger;
+import java.util.stream.Collectors;
+
+public class ASTVisitor extends CminusBaseVisitor<Node> {
+    private final Logger LOGGER;
+    private SymbolTable symbolTable;
+
+    public ASTVisitor(Logger LOGGER) {
+        this.LOGGER = LOGGER;
+    }
+
+    private VarType getVarType(CminusParser.TypeSpecifierContext ctx) {
+        final String t = ctx.getText();
+        return (t.equals("int")) ? VarType.INT : (t.equals("bool")) ? VarType.BOOL : VarType.CHAR;
+    }
+
+    @Override
+    public Node visitProgram(CminusParser.ProgramContext ctx) {
+        symbolTable = new SymbolTable();
+        List<Declaration> decls = new ArrayList<>();
+        for (CminusParser.DeclarationContext d : ctx.declaration())
+            decls.add((Declaration) visitDeclaration(d));
+        return new Program(decls);
+    }
+
+    @Override
+    public Node visitVarDeclaration(CminusParser.VarDeclarationContext ctx) {
+        VarType type = getVarType(ctx.typeSpecifier());
+        List<String> ids = new ArrayList<>();
+        List<Integer> arraySizes = new ArrayList<>();
+        for (CminusParser.VarDeclIdContext v : ctx.varDeclId()) {
+            String id = v.ID().getText();
+            ids.add(id);
+            symbolTable.addSymbol(id, new SymbolInfo(id, type, false));
+            if (v.NUMCONST() != null)
+                arraySizes.add(Integer.parseInt(v.NUMCONST().getText()));
+            else
+                arraySizes.add(-1);
+        }
+        final boolean isStatic = false;
+        return new VarDeclaration(type, ids, arraySizes, isStatic);
+    }
+
+    @Override
+    public Node visitReturnStmt(CminusParser.ReturnStmtContext ctx) {
+        if (ctx.expression() != null)
+            return new Return((Expression) visitExpression(ctx.expression()));
+        return new Return(null);
+    }
+
+    @Override
+    public Node visitConstant(CminusParser.ConstantContext ctx) {
+        final Node node;
+        if (ctx.NUMCONST() != null)
+            node = new NumConstant(Integer.parseInt(ctx.NUMCONST().getText()));
+        else if (ctx.CHARCONST() != null)
+            node = new CharConstant(ctx.CHARCONST().getText().charAt(0));
+        else if (ctx.STRINGCONST() != null)
+            node = new StringConstant(ctx.STRINGCONST().getText());
+        else
+            node = new BoolConstant(ctx.getText().equals("true"));
+        return node;
+    }
+
+    @Override
+    public Node visitFunDeclaration(CminusParser.FunDeclarationContext ctx) {
+        VarType rType = VarType.VOID;
+        if (ctx.typeSpecifier() != null)
+            rType = VarType.fromString(ctx.typeSpecifier().getText());
+        String id = ctx.ID().getText();
+
+        symbolTable.addSymbol(id, new SymbolInfo(id, rType, true));
+        symbolTable = symbolTable.createChild();
+
+        List<Param> params = ctx.param().stream().map(pCtx -> (Param) visitParam(pCtx)).collect(Collectors.toList());
+        Statement statement = (Statement) visitStatement(ctx.statement());
+
+        symbolTable = symbolTable.getParent();
+        return new FunctionDeclaration(rType, id, params, statement);
+    }
+
+    @Override
+    public Node visitParam(CminusParser.ParamContext ctx) {
+        VarType pType = getVarType(ctx.typeSpecifier());
+
+        String pId = ctx.paramId().getText();
+        Boolean isArray = pId.endsWith("[]");
+        if (isArray)
+            pId = pId.substring(0, pId.length() - 2);
+
+        symbolTable.addSymbol(pId, new SymbolInfo(pId, pType, false));
+
+        return new Param(pType, pId, isArray);
+    }
+
+    @Override
+    public Node visitStatement(CminusParser.StatementContext ctx) {
+        if (ctx.expressionStmt() != null)
+            return new ExpressionStatement((Expression) visitExpression(ctx.expressionStmt().expression()));
+        if (ctx.compoundStmt() != null) {
+            CminusParser.CompoundStmtContext cCtx = ctx.compoundStmt();
+
+            symbolTable = symbolTable.createChild();
+
+            List<VarDeclaration> varDecls = cCtx.varDeclaration().stream()
+                    .map(declCtx -> (VarDeclaration) visitVarDeclaration(declCtx)).collect(Collectors.toList());
+
+            List<Statement> statements = cCtx.statement().stream().map(stmtCtx -> (Statement) visitStatement(stmtCtx))
+                    .collect(Collectors.toList());
+
+            symbolTable = symbolTable.getParent();
+
+            return new CompoundStatement(varDecls, statements);
+        }
+        if (ctx.ifStmt() != null) {
+            List<Statement> statements = ctx.ifStmt().statement().stream()
+                    .map(stmtCtx -> (Statement) visitStatement(stmtCtx)).collect(Collectors.toList());
+            return new IfStatement((Expression) visitSimpleExpression(ctx.ifStmt().simpleExpression()), statements);
+        }
+        if (ctx.whileStmt() != null)
+            return new WhileStatement((Expression) visitSimpleExpression(ctx.whileStmt().simpleExpression()),
+                    (Statement) visitStatement(ctx.whileStmt().statement()));
+        if (ctx.returnStmt() != null) {
+            if (ctx.returnStmt().expression() != null)
+                return new Return((Expression) visitExpression(ctx.returnStmt().expression()));
+            return new Return(null);
+        }
+        if (ctx.breakStmt() != null)
+            return new Break();
+        return null;
+    }
+
+    @Override
+    public Node visitExpression(CminusParser.ExpressionContext ctx) {
+        if (ctx.mutable() != null && ctx.expression() != null)
+            return new ExpressionExpression((Mutable) visitMutable(ctx.mutable()),
+                    (Expression) visitExpression(ctx.expression()), ctx.getChild(1).getText());
+        else if (ctx.mutable() != null)
+            return new ExpressionExpression((Mutable) visitMutable(ctx.mutable()), ctx.getChild(1).getText());
+        return visitSimpleExpression(ctx.simpleExpression());
+    }
+
+    @Override
+    public Node visitMutable(CminusParser.MutableContext ctx) {
+        String id = ctx.ID().getText();
+
+        if (symbolTable.find(id) == null)
+            LOGGER.warning("Undefined symbol on line " + ctx.getStart().getLine() + ": " + id);
+
+        return new Mutable(id,
+                ctx.expression() != null ? (Expression) visitExpression(ctx.expression()) : null);
+    }
+
+    @Override
+    public Node visitOrExpression(CminusParser.OrExpressionContext ctx) {
+        List<AndExpression> andExpressions = ctx.andExpression().stream().map(andExpression -> {
+            List<UnaryRelExpression> uRE = andExpression.unaryRelExpression().stream()
+                    .map(unaryRelExpressionCtx -> (UnaryRelExpression) visitUnaryRelExpression(unaryRelExpressionCtx))
+                    .collect(Collectors.toList());
+            return new AndExpression(uRE);
+        }).collect(Collectors.toList());
+
+        return new OrExpression(andExpressions);
+    }
+
+    @Override
+    public Node visitUnaryRelExpression(CminusParser.UnaryRelExpressionContext ctx) {
+        int bangs = ctx.BANG().size();
+        RelExpression relExpression = (RelExpression) visitRelExpression(ctx.relExpression());
+        return new UnaryRelExpression(bangs, relExpression);
+    }
+
+    @Override
+    public Node visitRelExpression(CminusParser.RelExpressionContext ctx) {
+        List<BinaryOperatorType> relOps = ctx.relop().stream()
+                .map(operatorContext -> BinaryOperatorType.fromString(operatorContext.getText()))
+                .collect(Collectors.toList());
+        List<SumExpression> sumExpressions = ctx.sumExpression().stream().map(sumExpressionCtx -> {
+            List<BinaryOperatorType> sumOps = sumExpressionCtx.sumop().stream()
+                    .map(operatorContext -> BinaryOperatorType.fromString(operatorContext.getText()))
+                    .collect(Collectors.toList());
+            List<TermExpression> termExprs = sumExpressionCtx.termExpression().stream()
+                    .map(termExprCtx -> (TermExpression) visitTermExpression(termExprCtx)).collect(Collectors.toList());
+            return new SumExpression(sumOps, termExprs);
+        }).collect(Collectors.toList());
+
+        return new RelExpression(sumExpressions, relOps);
+    }
+
+    public Node visitTermExpression(CminusParser.TermExpressionContext ctx) {
+        List<BinaryOperatorType> mulOps = ctx.mulop().stream()
+                .map(operatorContext -> BinaryOperatorType.fromString(operatorContext.getText()))
+                .collect(Collectors.toList());
+        List<UnaryExpression> unaryExpressions = ctx.unaryExpression().stream().map(unaryExpressionCtx -> {
+            List<String> unaryOps = unaryExpressionCtx.unaryop().stream()
+                    .map(operatorContext -> operatorContext.getText())
+                    .collect(Collectors.toList());
+            Factor factor = (Factor) visitFactor(unaryExpressionCtx.factor());
+
+            return new UnaryExpression(unaryOps, factor);
+        }).collect(Collectors.toList());
+
+        return new TermExpression(unaryExpressions, mulOps);
+    }
+
+    public Node visitFactor(CminusParser.FactorContext ctx) {
+        if (ctx.immutable() != null)
+            return new Factor((Immutable) visitImmutable(ctx.immutable()));
+        return new Factor((Mutable) visitMutable(ctx.mutable()));
+    }
+
+    public Node visitImmutable(CminusParser.ImmutableContext ctx) {
+        if (ctx.constant() != null)
+            return new Immutable((Constant) visitConstant(ctx.constant()));
+
+        if (ctx.call() != null)
+            return new Immutable((Call) visitCall(ctx.call()), true);
+
+        return new Immutable((Expression) visitExpression(ctx.expression()));
+    }
+
+    public Node visitCall(CminusParser.CallContext ctx) {
+        String id = ctx.ID().getText();
+
+        if (symbolTable.find(id) == null)
+            LOGGER.warning("Undefined symbol on line " + ctx.getStart().getLine() + ": " + id);
+
+        return new Call(id, ctx.expression().stream()
+                .map(exprCtx -> (Expression) visitExpression(exprCtx)).collect(Collectors.toList()));
+    }
+}
\ No newline at end of file
diff --git a/Homework/cs5300/p4-formatter/submit/SymbolInfo.java b/Homework/cs5300/p4-formatter/submit/SymbolInfo.java
new file mode 100644
index 0000000..19c3f9b
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/SymbolInfo.java
@@ -0,0 +1,31 @@
+/*
+ * Code formatter project
+ * CS 4481
+ */
+package submit;
+
+import submit.ast.VarType;
+
+/**
+ *
+ * @author edwajohn
+ */
+public class SymbolInfo {
+
+  private final String id;
+  // In the case of a function, type is the return type
+  private final VarType type;
+  private final boolean function;
+
+  public SymbolInfo(String id, VarType type, boolean function) {
+    this.id = id;
+    this.type = type;
+    this.function = function;
+  }
+
+  @Override
+  public String toString() {
+    return "<" + id + ", " + type + '>';
+  }
+
+}
diff --git a/Homework/cs5300/p4-formatter/submit/SymbolTable.java b/Homework/cs5300/p4-formatter/submit/SymbolTable.java
new file mode 100644
index 0000000..bfa531e
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/SymbolTable.java
@@ -0,0 +1,55 @@
+package submit;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+/*
+ * Code formatter project
+ * CS 4481
+ */
+public class SymbolTable {
+
+  private final HashMap<String, SymbolInfo> table;
+  private SymbolTable parent;
+  private final List<SymbolTable> children;
+
+  public SymbolTable() {
+    table = new HashMap<>();
+    parent = null;
+    children = new ArrayList<>();
+  }
+
+  public void addSymbol(String id, SymbolInfo symbol) { table.put(id, symbol); }
+
+  /**
+   * Returns null if no symbol with that id is in this symbol table or an
+   * ancestor table.
+   *
+   * @param id
+   * @return
+   */
+  public SymbolInfo find(String id) {
+    if (table.containsKey(id)) {
+      return table.get(id);
+    }
+    if (parent != null) {
+      return parent.find(id);
+    }
+    return null;
+  }
+
+  /**
+   * Returns the new child.
+   *
+   * @return
+   */
+  public SymbolTable createChild() {
+    SymbolTable child = new SymbolTable();
+    children.add(child);
+    child.parent = this;
+    return child;
+  }
+
+  public SymbolTable getParent() { return parent; }
+}
diff --git a/Homework/cs5300/p4-formatter/submit/ast/AndExpression.java b/Homework/cs5300/p4-formatter/submit/ast/AndExpression.java
new file mode 100644
index 0000000..515dad9
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/ast/AndExpression.java
@@ -0,0 +1,18 @@
+package submit.ast;
+
+import java.util.List;
+import java.util.ArrayList;
+
+public class AndExpression implements Expression {
+    private List<UnaryRelExpression> unaryRelExpressions;
+
+    public AndExpression(List<UnaryRelExpression> unaryRelExpressions) {
+        this.unaryRelExpressions = new ArrayList<>(unaryRelExpressions);
+    }
+
+    @Override
+    public void toCminus(StringBuilder builder, String prefix) {
+        builder.append(prefix);
+        Expression.joinExpressions(BinaryOperatorType.AND, new ArrayList<Expression>(unaryRelExpressions), builder);
+    }
+}
diff --git a/Homework/cs5300/p4-formatter/submit/ast/BinaryOperator.java b/Homework/cs5300/p4-formatter/submit/ast/BinaryOperator.java
new file mode 100644
index 0000000..747b3ba
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/ast/BinaryOperator.java
@@ -0,0 +1,35 @@
+/*
+ * Code formatter project
+ * CS 4481
+ */
+package submit.ast;
+
+/**
+ *
+ * @author edwajohn
+ */
+public class BinaryOperator 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);
+  }
+
+}
diff --git a/Homework/cs5300/p4-formatter/submit/ast/BinaryOperatorType.java b/Homework/cs5300/p4-formatter/submit/ast/BinaryOperatorType.java
new file mode 100644
index 0000000..37235c8
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/ast/BinaryOperatorType.java
@@ -0,0 +1,37 @@
+/*
+ * 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/p4-formatter/submit/ast/BoolConstant.java b/Homework/cs5300/p4-formatter/submit/ast/BoolConstant.java
new file mode 100644
index 0000000..01a7591
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/ast/BoolConstant.java
@@ -0,0 +1,27 @@
+/*
+ * Code formatter project
+ * CS 4481
+ */
+package submit.ast;
+
+/**
+ *
+ * @author edwajohn
+ */
+public class BoolConstant implements Expression, Constant {
+
+  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/p4-formatter/submit/ast/Break.java b/Homework/cs5300/p4-formatter/submit/ast/Break.java
new file mode 100644
index 0000000..7e86a71
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/ast/Break.java
@@ -0,0 +1,9 @@
+package submit.ast;
+
+public class Break implements Statement {
+    public void toCminus(StringBuilder builder, String prefix) {
+        builder.append(prefix);
+
+        builder.append("break;\n");
+    }
+}
diff --git a/Homework/cs5300/p4-formatter/submit/ast/Call.java b/Homework/cs5300/p4-formatter/submit/ast/Call.java
new file mode 100644
index 0000000..b5c8a37
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/ast/Call.java
@@ -0,0 +1,26 @@
+package submit.ast;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Call implements Expression {
+    ArrayList<Expression> expressions;
+    String id;
+
+    public Call(String id, List<Expression> expressions) {
+        this.id = id;
+        this.expressions = new ArrayList<>(expressions);
+    }
+
+    public void toCminus(StringBuilder builder, String prefix) {
+        builder.append(prefix);
+        builder.append(id).append("(");
+        int numExpr = expressions.size();
+        if (numExpr > 0)
+            expressions.get(0).toCminus(builder, "");
+        if (numExpr > 1)
+            for (Expression expr : expressions.subList(1, numExpr))
+                expr.toCminus(builder, ", ");
+        builder.append(")");
+    }
+}
diff --git a/Homework/cs5300/p4-formatter/submit/ast/CharConstant.java b/Homework/cs5300/p4-formatter/submit/ast/CharConstant.java
new file mode 100644
index 0000000..a0ccb37
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/ast/CharConstant.java
@@ -0,0 +1,23 @@
+/*
+ * Code formatter project
+ * CS 4481
+ */
+package submit.ast;
+
+/**
+ *
+ * @author edwajohn
+ */
+public class CharConstant implements Expression, Constant {
+
+  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/p4-formatter/submit/ast/CompoundStatement.java b/Homework/cs5300/p4-formatter/submit/ast/CompoundStatement.java
new file mode 100644
index 0000000..02fa298
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/ast/CompoundStatement.java
@@ -0,0 +1,28 @@
+package submit.ast;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class CompoundStatement implements Statement {
+    ArrayList<VarDeclaration> varDecls;
+    ArrayList<Statement> statements;
+
+    public CompoundStatement(List<VarDeclaration> varDecls, List<Statement> statements) {
+        this.varDecls = new ArrayList<>(varDecls);
+        this.statements = new ArrayList<>(statements);
+    }
+
+    @Override
+    public void toCminus(StringBuilder builder, String prefix) {
+        builder.append(prefix);
+        builder.append("{").append("\n");
+        for (VarDeclaration varDecl : varDecls)
+            varDecl.toCminus(builder, prefix + "\t");
+
+        for (Statement statement : statements)
+            statement.toCminus(builder, prefix + "\t");
+
+        builder.append(prefix).append("}").append("\n");
+
+    }
+}
diff --git a/Homework/cs5300/p4-formatter/submit/ast/Constant.java b/Homework/cs5300/p4-formatter/submit/ast/Constant.java
new file mode 100644
index 0000000..bb30412
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/ast/Constant.java
@@ -0,0 +1,5 @@
+package submit.ast;
+
+public interface Constant extends Node {
+
+}
diff --git a/Homework/cs5300/p4-formatter/submit/ast/Declaration.java b/Homework/cs5300/p4-formatter/submit/ast/Declaration.java
new file mode 100644
index 0000000..c70e856
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/ast/Declaration.java
@@ -0,0 +1,13 @@
+/*
+ * Code formatter project
+ * CS 4481
+ */
+package submit.ast;
+
+/**
+ *
+ * @author edwajohn
+ */
+public interface Declaration extends Statement, Node {
+
+}
diff --git a/Homework/cs5300/p4-formatter/submit/ast/Expression.java b/Homework/cs5300/p4-formatter/submit/ast/Expression.java
new file mode 100644
index 0000000..1c2ba9b
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/ast/Expression.java
@@ -0,0 +1,37 @@
+/*
+ * Code formatter project
+ * CS 4481
+ */
+package submit.ast;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ *
+ * @author edwajohn, simponic :3
+ */
+public interface Expression extends Node {
+    public static void joinExpressionOperatorLists(List<BinaryOperatorType> binaryOperatorTypes, List<Expression> exprs,
+            StringBuilder builder) {
+        int numExpr = exprs.size();
+        Expression lhs = exprs.get(0);
+        if (numExpr == 1)
+            lhs.toCminus(builder, "");
+        if (numExpr > 1) {
+            BinaryOperator binOp = null;
+            for (int i = 0; i < binaryOperatorTypes.size(); i++) {
+                binOp = new BinaryOperator(lhs, binaryOperatorTypes.get(i), exprs.get(i + 1));
+                lhs = binOp;
+            }
+            binOp.toCminus(builder, "");
+        }
+    }
+
+    public static void joinExpressions(BinaryOperatorType binaryOperatorType, List<Expression> exprs,
+            StringBuilder builder) {
+        Expression.joinExpressionOperatorLists(Arrays.asList(new BinaryOperatorType[exprs.size() - 1]).stream()
+                .map(e -> binaryOperatorType).collect(Collectors.toList()), exprs, builder);
+    }
+}
diff --git a/Homework/cs5300/p4-formatter/submit/ast/ExpressionExpression.java b/Homework/cs5300/p4-formatter/submit/ast/ExpressionExpression.java
new file mode 100644
index 0000000..cc79a1d
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/ast/ExpressionExpression.java
@@ -0,0 +1,31 @@
+package submit.ast;
+
+public class ExpressionExpression implements Expression {
+    private Mutable mutable;
+    private Expression expression;
+    private String op;
+
+    public ExpressionExpression(Mutable mutable, Expression expression, String op) {
+        this.mutable = mutable;
+        this.expression = expression;
+        this.op = op;
+    }
+
+    public ExpressionExpression(Mutable mutable, String op) {
+        this.mutable = mutable;
+        this.op = op;
+    }
+
+    @Override
+    public void toCminus(StringBuilder builder, String prefix) {
+        builder.append(prefix);
+        mutable.toCminus(builder, "");
+        if (op != null && expression != null)
+            builder.append(" ");
+        builder.append(op);
+        if (expression != null) {
+            builder.append(" ");
+            expression.toCminus(builder, "");
+        }
+    }
+}
diff --git a/Homework/cs5300/p4-formatter/submit/ast/ExpressionStatement.java b/Homework/cs5300/p4-formatter/submit/ast/ExpressionStatement.java
new file mode 100644
index 0000000..18feadf
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/ast/ExpressionStatement.java
@@ -0,0 +1,17 @@
+package submit.ast;
+
+public class ExpressionStatement implements Statement {
+    private Expression expression;
+
+    public ExpressionStatement(Expression expression) {
+        this.expression = expression;
+    }
+
+    @Override
+    public void toCminus(StringBuilder builder, String prefix) {
+        builder.append(prefix);
+        if (expression != null)
+            expression.toCminus(builder, "");
+        builder.append(";\n");
+    }
+}
diff --git a/Homework/cs5300/p4-formatter/submit/ast/Factor.java b/Homework/cs5300/p4-formatter/submit/ast/Factor.java
new file mode 100644
index 0000000..bda0f53
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/ast/Factor.java
@@ -0,0 +1,23 @@
+package submit.ast;
+
+public class Factor implements Node {
+    private Immutable immutable;
+    private Mutable mutable;
+
+    public Factor(Immutable immutable) {
+        this.immutable = immutable;
+    }
+
+    public Factor(Mutable mutable) {
+        this.mutable = mutable;
+    }
+
+    @Override
+    public void toCminus(StringBuilder builder, String prefix) {
+        builder.append(prefix);
+        if (mutable != null)
+            mutable.toCminus(builder, "");
+        if (immutable != null)
+            immutable.toCminus(builder, "");
+    }
+}
diff --git a/Homework/cs5300/p4-formatter/submit/ast/FunctionDeclaration.java b/Homework/cs5300/p4-formatter/submit/ast/FunctionDeclaration.java
new file mode 100644
index 0000000..56abd14
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/ast/FunctionDeclaration.java
@@ -0,0 +1,36 @@
+package submit.ast;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class FunctionDeclaration implements Declaration {
+
+    private VarType rType;
+    private Statement statement;
+    private ArrayList<Param> params;
+    private String id;
+
+    public FunctionDeclaration(VarType rType, String id, List<Param> params,
+            Statement statement) {
+        this.rType = rType;
+        this.id = id;
+        this.params = new ArrayList<>(params);
+        this.statement = statement;
+    }
+
+    @Override
+    public void toCminus(StringBuilder builder, String prefix) {
+        builder.append("\n").append(rType).append(" ").append(id).append("(");
+        int numParams = params.size();
+
+        if (numParams >= 1)
+            params.get(0).toCminus(builder, "");
+        if (numParams > 1)
+            for (Param param : params.subList(1, numParams))
+                param.toCminus(builder, ", ");
+
+        builder.append(")").append("\n");
+
+        statement.toCminus(builder, "");
+    }
+}
diff --git a/Homework/cs5300/p4-formatter/submit/ast/IfStatement.java b/Homework/cs5300/p4-formatter/submit/ast/IfStatement.java
new file mode 100644
index 0000000..1f9b577
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/ast/IfStatement.java
@@ -0,0 +1,33 @@
+package submit.ast;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class IfStatement implements Statement {
+    private ArrayList<Statement> statements;
+    private Expression simpleExpression;
+
+    public IfStatement(Expression simpleExpression, List<Statement> statements) {
+        this.simpleExpression = simpleExpression;
+        this.statements = new ArrayList<>(statements);
+    }
+
+    @Override
+    public void toCminus(StringBuilder builder, String prefix) {
+        builder.append(prefix);
+        builder.append("if").append(" (");
+        simpleExpression.toCminus(builder, "");
+        builder.append(")\n");
+
+        Statement ifStmt = statements.get(0);
+        boolean isIfCompound = ifStmt.getClass() == CompoundStatement.class;
+        ifStmt.toCminus(builder, prefix + (isIfCompound ? "" : "\t"));
+        if (statements.size() == 2) {
+            Statement elseStmt = statements.get(1);
+            boolean isElseCompound = elseStmt.getClass() == CompoundStatement.class;
+
+            builder.append(prefix).append("else\n");
+            elseStmt.toCminus(builder, prefix + (isElseCompound ? "" : "\t"));
+        }
+    }
+}
diff --git a/Homework/cs5300/p4-formatter/submit/ast/Immutable.java b/Homework/cs5300/p4-formatter/submit/ast/Immutable.java
new file mode 100644
index 0000000..d94ec2c
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/ast/Immutable.java
@@ -0,0 +1,34 @@
+package submit.ast;
+
+public class Immutable implements Expression, Node {
+    private Expression expression;
+    private Call call;
+    private Constant constant;
+
+    public Immutable(Expression expression) {
+        this.expression = expression;
+    }
+
+    public Immutable(Call call, boolean isCall) {
+        this.call = call;
+    }
+
+    public Immutable(Constant constant) {
+        this.constant = constant;
+    }
+
+    @Override
+    public void toCminus(StringBuilder builder, String prefix) {
+        builder.append(prefix);
+        if (constant != null)
+            constant.toCminus(builder, "");
+        if (expression != null) {
+            builder.append("(");
+            expression.toCminus(builder, "");
+            builder.append(")");
+        }
+        if (call != null)
+            call.toCminus(builder, "");
+    }
+
+}
diff --git a/Homework/cs5300/p4-formatter/submit/ast/Mutable.java b/Homework/cs5300/p4-formatter/submit/ast/Mutable.java
new file mode 100644
index 0000000..c7ef089
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/ast/Mutable.java
@@ -0,0 +1,31 @@
+/*
+ * Code formatter project
+ * CS 4481
+ */
+package submit.ast;
+
+/**
+ *
+ * @author edwajohn
+ */
+public class Mutable implements Expression, Node {
+
+  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("]");
+    }
+  }
+
+}
diff --git a/Homework/cs5300/p4-formatter/submit/ast/Node.java b/Homework/cs5300/p4-formatter/submit/ast/Node.java
new file mode 100644
index 0000000..455bb3f
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/ast/Node.java
@@ -0,0 +1,5 @@
+package submit.ast;
+
+public interface Node {
+    void toCminus(StringBuilder builder, final String prefix);
+}
diff --git a/Homework/cs5300/p4-formatter/submit/ast/NumConstant.java b/Homework/cs5300/p4-formatter/submit/ast/NumConstant.java
new file mode 100644
index 0000000..c3eea3c
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/ast/NumConstant.java
@@ -0,0 +1,23 @@
+/*
+ * Code formatter project
+ * CS 4481
+ */
+package submit.ast;
+
+/**
+ *
+ * @author edwajohn
+ */
+public class NumConstant implements Expression, Node, Constant {
+
+  private final int value;
+
+  public NumConstant(int value) {
+    this.value = value;
+  }
+
+  public void toCminus(StringBuilder builder, final String prefix) {
+    builder.append(Integer.toString(value));
+  }
+
+}
diff --git a/Homework/cs5300/p4-formatter/submit/ast/OrExpression.java b/Homework/cs5300/p4-formatter/submit/ast/OrExpression.java
new file mode 100644
index 0000000..f4b4dd7
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/ast/OrExpression.java
@@ -0,0 +1,18 @@
+package submit.ast;
+
+import java.util.List;
+import java.util.ArrayList;
+
+public class OrExpression implements Expression {
+    private ArrayList<AndExpression> andExpressions;
+
+    public OrExpression(List<AndExpression> andExpressions) {
+        this.andExpressions = new ArrayList<>(andExpressions);
+    }
+
+    @Override
+    public void toCminus(StringBuilder builder, String prefix) {
+        builder.append(prefix);
+        Expression.joinExpressions(BinaryOperatorType.OR, new ArrayList<Expression>(andExpressions), builder);
+    }
+}
diff --git a/Homework/cs5300/p4-formatter/submit/ast/Param.java b/Homework/cs5300/p4-formatter/submit/ast/Param.java
new file mode 100644
index 0000000..2afa3d6
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/ast/Param.java
@@ -0,0 +1,22 @@
+package submit.ast;
+
+public class Param implements Declaration {
+    private final VarType type;
+    private final String id;
+    private final Boolean isArray;
+
+    public Param(VarType type, String id, Boolean isArray) {
+        this.type = type;
+        this.id = id;
+        this.isArray = isArray;
+    }
+
+    @Override
+    public void toCminus(StringBuilder builder, final String prefix) {
+        builder.append(prefix);
+        builder.append(type).append(" ").append(id);
+        if (this.isArray) {
+            builder.append("[]");
+        }
+    }
+}
diff --git a/Homework/cs5300/p4-formatter/submit/ast/Program.java b/Homework/cs5300/p4-formatter/submit/ast/Program.java
new file mode 100644
index 0000000..96d1e22
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/ast/Program.java
@@ -0,0 +1,35 @@
+/*
+ * Code formatter project
+ * CS 4481
+ */
+package submit.ast;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ *
+ * @author edwajohn
+ */
+public class Program 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, "");
+    }
+  }
+}
diff --git a/Homework/cs5300/p4-formatter/submit/ast/RelExpression.java b/Homework/cs5300/p4-formatter/submit/ast/RelExpression.java
new file mode 100644
index 0000000..8201dd8
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/ast/RelExpression.java
@@ -0,0 +1,20 @@
+package submit.ast;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class RelExpression implements Expression {
+    private ArrayList<SumExpression> sumExpressions;
+    private ArrayList<BinaryOperatorType> relops;
+
+    public RelExpression(List<SumExpression> sumExpressions, List<BinaryOperatorType> relops) {
+        this.sumExpressions = new ArrayList<>(sumExpressions);
+        this.relops = new ArrayList<>(relops);
+    }
+
+    @Override
+    public void toCminus(StringBuilder builder, String prefix) {
+        builder.append(prefix);
+        Expression.joinExpressionOperatorLists(relops, new ArrayList<Expression>(sumExpressions), builder);
+    }
+}
\ No newline at end of file
diff --git a/Homework/cs5300/p4-formatter/submit/ast/Return.java b/Homework/cs5300/p4-formatter/submit/ast/Return.java
new file mode 100644
index 0000000..c1f9d4d
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/ast/Return.java
@@ -0,0 +1,31 @@
+/*
+ * Code formatter project
+ * CS 4481
+ */
+package submit.ast;
+
+/**
+ *
+ * @author edwajohn
+ */
+public class Return 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");
+    }
+  }
+
+}
diff --git a/Homework/cs5300/p4-formatter/submit/ast/Statement.java b/Homework/cs5300/p4-formatter/submit/ast/Statement.java
new file mode 100644
index 0000000..c95db57
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/ast/Statement.java
@@ -0,0 +1,14 @@
+/*
+ * Code formatter project
+ * CS 4481
+ */
+package submit.ast;
+
+import java.util.ArrayList;
+
+/**
+ *
+ * @author edwajohn
+ */
+public interface Statement extends Node {
+}
diff --git a/Homework/cs5300/p4-formatter/submit/ast/StringConstant.java b/Homework/cs5300/p4-formatter/submit/ast/StringConstant.java
new file mode 100644
index 0000000..4bf3738
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/ast/StringConstant.java
@@ -0,0 +1,23 @@
+/*
+ * Code formatter project
+ * CS 4481
+ */
+package submit.ast;
+
+/**
+ *
+ * @author edwajohn
+ */
+public class StringConstant implements Expression, Constant {
+
+  private final String value;
+
+  public StringConstant(String value) {
+    this.value = value;
+  }
+
+  public void toCminus(StringBuilder builder, final String prefix) {
+    builder.append("\"").append(value).append("\"");
+  }
+
+}
diff --git a/Homework/cs5300/p4-formatter/submit/ast/SumExpression.java b/Homework/cs5300/p4-formatter/submit/ast/SumExpression.java
new file mode 100644
index 0000000..a7bebfb
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/ast/SumExpression.java
@@ -0,0 +1,20 @@
+package submit.ast;
+
+import java.util.List;
+import java.util.ArrayList;
+
+public class SumExpression implements Expression {
+    private ArrayList<BinaryOperatorType> sumOps;
+    private ArrayList<TermExpression> termExpressions;
+
+    public SumExpression(List<BinaryOperatorType> sumOps, List<TermExpression> termExpressions) {
+        this.sumOps = new ArrayList<>(sumOps);
+        this.termExpressions = new ArrayList<>(termExpressions);
+    }
+
+    @Override
+    public void toCminus(StringBuilder builder, String prefix) {
+        builder.append(prefix);
+        Expression.joinExpressionOperatorLists(sumOps, new ArrayList<Expression>(termExpressions), builder);
+    }
+}
diff --git a/Homework/cs5300/p4-formatter/submit/ast/TermExpression.java b/Homework/cs5300/p4-formatter/submit/ast/TermExpression.java
new file mode 100644
index 0000000..47dc0b2
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/ast/TermExpression.java
@@ -0,0 +1,20 @@
+package submit.ast;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class TermExpression implements Expression {
+    private ArrayList<UnaryExpression> unaryExpressions;
+    private ArrayList<BinaryOperatorType> mulOps;
+
+    public TermExpression(List<UnaryExpression> unaryExpressions, List<BinaryOperatorType> mulOps) {
+        this.unaryExpressions = new ArrayList<>(unaryExpressions);
+        this.mulOps = new ArrayList<>(mulOps);
+    }
+
+    @Override
+    public void toCminus(StringBuilder builder, String prefix) {
+        builder.append(prefix);
+        Expression.joinExpressionOperatorLists(mulOps, new ArrayList<Expression>(unaryExpressions), builder);
+    }
+}
\ No newline at end of file
diff --git a/Homework/cs5300/p4-formatter/submit/ast/UnaryExpression.java b/Homework/cs5300/p4-formatter/submit/ast/UnaryExpression.java
new file mode 100644
index 0000000..0efdb13
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/ast/UnaryExpression.java
@@ -0,0 +1,22 @@
+package submit.ast;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class UnaryExpression implements Expression {
+    private ArrayList<String> unaryOperators;
+    private Factor factor;
+
+    public UnaryExpression(List<String> unaryOperators, Factor factor) {
+        this.unaryOperators = new ArrayList<>(unaryOperators);
+        this.factor = factor;
+    }
+
+    @Override
+    public void toCminus(StringBuilder builder, String prefix) {
+        builder.append(prefix);
+        for (String unaryOperator : unaryOperators)
+            builder.append(unaryOperator);
+        factor.toCminus(builder, "");
+    }
+}
diff --git a/Homework/cs5300/p4-formatter/submit/ast/UnaryRelExpression.java b/Homework/cs5300/p4-formatter/submit/ast/UnaryRelExpression.java
new file mode 100644
index 0000000..621f9fb
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/ast/UnaryRelExpression.java
@@ -0,0 +1,20 @@
+package submit.ast;
+
+public class UnaryRelExpression implements Expression {
+
+    private int bangs;
+    private RelExpression relExpression;
+
+    public UnaryRelExpression(int bangs, RelExpression relExpression) {
+        this.bangs = bangs;
+        this.relExpression = relExpression;
+    }
+
+    @Override
+    public void toCminus(StringBuilder builder, String prefix) {
+        builder.append(prefix);
+        for (int i = 0; i < bangs; ++i)
+            builder.append("!");
+        relExpression.toCminus(builder, "");
+    }
+}
diff --git a/Homework/cs5300/p4-formatter/submit/ast/VarDeclaration.java b/Homework/cs5300/p4-formatter/submit/ast/VarDeclaration.java
new file mode 100644
index 0000000..90f8ea5
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/ast/VarDeclaration.java
@@ -0,0 +1,47 @@
+/*
+ * Code formatter project
+ * CS 4481
+ */
+package submit.ast;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ *
+ * @author edwajohn
+ */
+public class VarDeclaration 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/p4-formatter/submit/ast/VarType.java b/Homework/cs5300/p4-formatter/submit/ast/VarType.java
new file mode 100644
index 0000000..85296d9
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/ast/VarType.java
@@ -0,0 +1,35 @@
+/*
+ * Code formatter project
+ * CS 4481
+ */
+package submit.ast;
+
+/**
+ *
+ * @author edwajohn
+ */
+public enum VarType {
+
+  VOID("void"), 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/p4-formatter/submit/ast/WhileStatement.java b/Homework/cs5300/p4-formatter/submit/ast/WhileStatement.java
new file mode 100644
index 0000000..cd99d51
--- /dev/null
+++ b/Homework/cs5300/p4-formatter/submit/ast/WhileStatement.java
@@ -0,0 +1,22 @@
+package submit.ast;
+
+public class WhileStatement implements Statement {
+    Expression simpleExpression;
+    Statement statement;
+
+    public WhileStatement(Expression simpleExpression, Statement statement) {
+        this.simpleExpression = simpleExpression;
+        this.statement = statement;
+    }
+
+    public void toCminus(StringBuilder builder, String prefix) {
+        builder.append(prefix);
+
+        builder.append("while (");
+        simpleExpression.toCminus(builder, "");
+        builder.append(")\n");
+
+        boolean isBodyCompound = statement.getClass() == CompoundStatement.class;
+        statement.toCminus(builder, prefix + (isBodyCompound ? "" : "\t"));
+    }
+}