Moved examples

1 files changed, 0 insertions, 91 deletions

diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/optimization/ConstantCollapser.java b/dice-lang/src/main/java/bjc/dicelang/ast/optimization/ConstantCollapser.java
deleted file mode 100644
index 95badd2..0000000
--- a/dice-lang/src/main/java/bjc/dicelang/ast/optimization/ConstantCollapser.java
+++ /dev/null
@@ -1,91 +0,0 @@
-package bjc.dicelang.ast.optimization;
-
-import bjc.utils.funcdata.IList;
-import bjc.utils.funcdata.ITree;
-import bjc.utils.funcdata.Tree;
-
-import bjc.dicelang.ComplexDice;
-import bjc.dicelang.ast.DiceASTUtils;
-import bjc.dicelang.ast.nodes.IDiceASTNode;
-import bjc.dicelang.ast.nodes.IntegerLiteralNode;
-import bjc.dicelang.ast.nodes.OperatorDiceNode;
-
-/**
- * Collapses operations with constants to constants
- * 
- * @author ben
- *
- */
-public class ConstantCollapser implements IOptimizationPass {
-	private static final ArithmeticCollapser	additionCollapser	= new ArithmeticCollapser(
-			(left, right) -> left + right, OperatorDiceNode.ADD);
-
-	private static final ArithmeticCollapser	divideCollapser		= new ArithmeticCollapser(
-			(left, right) -> left / right, OperatorDiceNode.DIVIDE);
-
-	private static final ArithmeticCollapser	multiplyCollapser	= new ArithmeticCollapser(
-			(left, right) -> left * right, OperatorDiceNode.MULTIPLY);
-
-	private static final ArithmeticCollapser	subtractCollapser	= new ArithmeticCollapser(
-			(left, right) -> left - right, OperatorDiceNode.SUBTRACT);
-
-	private static final ArithmeticCollapser	compoundCollapser	= new ArithmeticCollapser(
-			(left, right) -> Integer.parseInt(
-					Integer.toString(left) + Integer.toString(left)),
-			OperatorDiceNode.COMPOUND);
-
-	@Override
-	public ITree<IDiceASTNode> optimizeLeaf(IDiceASTNode leafNode) {
-		// We don't do anything special here
-		return new Tree<>(leafNode);
-	}
-
-	@Override
-	public ITree<IDiceASTNode> optimizeOperator(IDiceASTNode operator,
-			IList<ITree<IDiceASTNode>> children) {
-		if (!operator.isOperator()) {
-			return new Tree<>(operator, children);
-		}
-
-		switch ((OperatorDiceNode) operator) {
-			case ADD:
-				return additionCollapser.collapse(children);
-			case DIVIDE:
-				return divideCollapser.collapse(children);
-			case MULTIPLY:
-				return multiplyCollapser.collapse(children);
-			case SUBTRACT:
-				return subtractCollapser.collapse(children);
-			case COMPOUND:
-				return compoundCollapser.collapse(children);
-			case GROUP:
-				if (children.getSize() != 2) {
-					return new Tree<>(operator, children);
-				}
-
-				ComplexDice dice = new ComplexDice(
-						DiceASTUtils.literalToExpression(
-								children.getByIndex(0)),
-						DiceASTUtils.literalToExpression(
-								children.getByIndex(1)));
-
-				if (dice.canOptimize()) {
-					return new Tree<>(
-							new IntegerLiteralNode(dice.optimize()));
-				}
-
-				return new Tree<>(operator, children);
-			case ARRAY:
-				if (children.getSize() != 1) {
-					return new Tree<>(operator, children);
-				}
-
-				return children.first();
-			case ASSIGN:
-			case LET:
-			default:
-				// We don't optimize these operators
-				return new Tree<>(operator, children);
-		}
-	}
-}