Добавлены оптимизаторы-посетители

Author: aNNiMON

src/com/annimon/ownlang/parser/visitors/ConstantFolding.java

@@ -0,0 +1,87 @@
+package com.annimon.ownlang.parser.visitors;
+
+import com.annimon.ownlang.exceptions.OperationIsNotSupportedException;
+import com.annimon.ownlang.parser.Optimizer;
+import com.annimon.ownlang.parser.ast.BinaryExpression;
+import com.annimon.ownlang.parser.ast.ConditionalExpression;
+import com.annimon.ownlang.parser.ast.Node;
+import com.annimon.ownlang.parser.ast.UnaryExpression;
+import com.annimon.ownlang.parser.ast.ValueExpression;
+
+/**
+ * Performs constant folding optimization.
+ */
+public class ConstantFolding extends OptimizationVisitor<Void> implements Optimizer.Info {
+
+    private int binaryExpressionFoldingCount;
+    private int conditionalExpressionFoldingCount;
+    private int unaryExpressionFoldingCount;
+
+    public ConstantFolding() {
+        binaryExpressionFoldingCount = 0;
+        conditionalExpressionFoldingCount = 0;
+        unaryExpressionFoldingCount = 0;
+    }
+
+    @Override
+    public int optimizationsCount() {
+        return binaryExpressionFoldingCount
+                + conditionalExpressionFoldingCount
+                + unaryExpressionFoldingCount;
+    }
+
+    @Override
+    public String summaryInfo() {
+        if (optimizationsCount() == 0) return "";
+        final StringBuilder sb = new StringBuilder();
+        if (binaryExpressionFoldingCount > 0) {
+            sb.append("\nBinaryExpression foldings: ").append(binaryExpressionFoldingCount);
+        }
+        if (conditionalExpressionFoldingCount > 0) {
+            sb.append("\nConditionalExpression foldings: ").append(conditionalExpressionFoldingCount);
+        }
+        if (unaryExpressionFoldingCount > 0) {
+            sb.append("\nUnaryExpression foldings: ").append(unaryExpressionFoldingCount);
+        }
+        return sb.toString();
+    }
+
+    @Override
+    public Node visit(BinaryExpression s, Void t) {
+        if ( (s.expr1 instanceof ValueExpression) && (s.expr2 instanceof ValueExpression) ) {
+            binaryExpressionFoldingCount++;
+            try {
+                return new ValueExpression(s.eval());
+            } catch (OperationIsNotSupportedException op) {
+                binaryExpressionFoldingCount--;
+            }
+        }
+        return super.visit(s, t);
+    }
+
+    @Override
+    public Node visit(ConditionalExpression s, Void t) {
+        if ( (s.expr1 instanceof ValueExpression) && (s.expr2 instanceof ValueExpression) ) {
+            conditionalExpressionFoldingCount++;
+            try {
+                return new ValueExpression(s.eval());
+            } catch (OperationIsNotSupportedException op) {
+                conditionalExpressionFoldingCount--;
+            }
+        }
+        return super.visit(s, t);
+    }
+
+    @Override
+    public Node visit(UnaryExpression s, Void t) {
+        if (s.expr1 instanceof ValueExpression) {
+            unaryExpressionFoldingCount++;
+            try {
+                return new ValueExpression(s.eval());
+            } catch (OperationIsNotSupportedException op) {
+                unaryExpressionFoldingCount--;
+            }
+        }
+        return super.visit(s, t);
+    }
+}

src/com/annimon/ownlang/parser/visitors/DeadCodeElimination.java

@@ -0,0 +1,81 @@
+package com.annimon.ownlang.parser.visitors;
+
+import com.annimon.ownlang.parser.Optimizer;
+import com.annimon.ownlang.parser.ast.ExprStatement;
+import com.annimon.ownlang.parser.ast.IfStatement;
+import com.annimon.ownlang.parser.ast.Node;
+import com.annimon.ownlang.parser.ast.TernaryExpression;
+import com.annimon.ownlang.parser.ast.ValueExpression;
+import com.annimon.ownlang.parser.ast.WhileStatement;
+
+/**
+ * Performs dead code elimination.
+ */
+public class DeadCodeElimination extends OptimizationVisitor<Void> implements Optimizer.Info {
+
+    private int ifStatementEliminatedCount;
+    private int ternaryExpressionEliminatedCount;
+    private int whileStatementEliminatedCount;
+
+    @Override
+    public int optimizationsCount() {
+        return ifStatementEliminatedCount + ternaryExpressionEliminatedCount
+                + whileStatementEliminatedCount;
+    }
+
+    @Override
+    public String summaryInfo() {
+        if (optimizationsCount() == 0) return "";
+        final StringBuilder sb = new StringBuilder();
+        if (ifStatementEliminatedCount > 0) {
+            sb.append("\nEliminated IfStatement: ").append(ifStatementEliminatedCount);
+        }
+        if (ternaryExpressionEliminatedCount > 0) {
+            sb.append("\nEliminated TernaryExpression: ").append(ternaryExpressionEliminatedCount);
+        }
+        if (whileStatementEliminatedCount > 0) {
+            sb.append("\nEliminated WhileStatement: ").append(whileStatementEliminatedCount);
+        }
+        return sb.toString();
+    }
+
+    @Override
+    public Node visit(IfStatement s, Void t) {
+        if (s.expression instanceof ValueExpression) {
+            ifStatementEliminatedCount++;
+            // true statement
+            if (s.expression.eval().asInt() != 0) {
+                return s.ifStatement;
+            }
+            // false statement
+            if (s.elseStatement != null) {
+                return s.elseStatement;
+            }
+            return new ExprStatement(s.expression);
+        }
+        return super.visit(s, t);
+    }
+
+    @Override
+    public Node visit(TernaryExpression s, Void t) {
+        if (s.condition instanceof ValueExpression) {
+            ternaryExpressionEliminatedCount++;
+            if (s.condition.eval().asInt() != 0) {
+                return s.trueExpr;
+            }
+            return s.falseExpr;
+        }
+        return super.visit(s, t);
+    }
+
+    @Override
+    public Node visit(WhileStatement s, Void t) {
+        if (s.condition instanceof ValueExpression) {
+            if (s.condition.eval().asInt() == 0) {
+                whileStatementEliminatedCount++;
+                return new ExprStatement(s.condition);
+            }
+        }
+        return super.visit(s, t);
+    }
+}