diff options
Diffstat (limited to 'Homework/cs5300/p4-formatter/submit/ast')
34 files changed, 840 insertions, 0 deletions
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")); + } +} |