diff options
Diffstat (limited to 'Homework/cs5300/p4-formatter/submit')
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")); + } +} |