summaryrefslogtreecommitdiff
path: root/dice-lang/src/bjc/dicelang/Evaluator.java
diff options
context:
space:
mode:
Diffstat (limited to 'dice-lang/src/bjc/dicelang/Evaluator.java')
-rw-r--r--dice-lang/src/bjc/dicelang/Evaluator.java141
1 files changed, 72 insertions, 69 deletions
diff --git a/dice-lang/src/bjc/dicelang/Evaluator.java b/dice-lang/src/bjc/dicelang/Evaluator.java
index 5ecff25..190e911 100644
--- a/dice-lang/src/bjc/dicelang/Evaluator.java
+++ b/dice-lang/src/bjc/dicelang/Evaluator.java
@@ -8,18 +8,18 @@ import bjc.dicelang.dice.SimpleDie;
import bjc.dicelang.dice.SimpleDieList;
import bjc.utils.data.ITree;
import bjc.utils.data.SingleIterator;
-import bjc.utils.data.Tree;
import bjc.utils.data.TopDownTransformIterator;
import bjc.utils.data.TopDownTransformResult;
-
-import static bjc.dicelang.Errors.ErrorKey.*;
-import static bjc.dicelang.EvaluatorResult.Type.*;
+import bjc.utils.data.Tree;
import java.util.Deque;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.function.Consumer;
+import static bjc.dicelang.Errors.ErrorKey.*;
+import static bjc.dicelang.EvaluatorResult.Type.*;
+
public class Evaluator {
private static enum CoerceSteps {
INTEGER, FLOAT;
@@ -62,8 +62,9 @@ public class Evaluator {
// It's only for stepwise evaluation
// but we don't know if stepping the iterator causes
// something to happen
- while (itr.hasNext())
+ while(itr.hasNext()) {
itr.next();
+ }
};
return comm.topDownTransform(this::pickEvaluationType, (node) -> this.evaluateNode(node, ctx))
@@ -84,9 +85,9 @@ public class Evaluator {
}
private TopDownTransformResult pickEvaluationType(Node nd) {
- switch (nd.type) {
+ switch(nd.type) {
case UNARYOP:
- switch (nd.operatorType) {
+ switch(nd.operatorType) {
case COERCE:
return TopDownTransformResult.RTRANSFORM;
default:
@@ -98,7 +99,7 @@ public class Evaluator {
}
private ITree<Node> evaluateNode(ITree<Node> ast, Context ctx) {
- switch (ast.getHead().type) {
+ switch(ast.getHead().type) {
case UNARYOP:
return evaluateUnaryOp(ast, ctx);
case BINOP:
@@ -116,12 +117,12 @@ public class Evaluator {
}
private ITree<Node> evaluateUnaryOp(ITree<Node> ast, Context ctx) {
- if (ast.getChildrenCount() != 1) {
+ if(ast.getChildrenCount() != 1) {
Errors.inst.printError(EK_EVAL_UNUNARY, Integer.toString(ast.getChildrenCount()));
return new Tree<>(FAIL(ast));
}
- switch (ast.getHead().operatorType) {
+ switch(ast.getHead().operatorType) {
/*
* @TODO move coercing to its own class
*/
@@ -132,39 +133,41 @@ public class Evaluator {
CoerceSteps curLevel = CoerceSteps.INTEGER;
- for (int i = 0; i < toCoerce.getChildrenCount(); i++) {
+ for(int i = 0; i < toCoerce.getChildrenCount(); i++) {
ITree<Node> child = toCoerce.getChild(i);
ITree<Node> nChild = null;
- if (ctx.isDebug) {
+ if(ctx.isDebug) {
Iterator<ITree<Node>> nd = stepDebug(child);
- for (; nd.hasNext(); nChild = nd.next()) {
+ for(; nd.hasNext(); nChild = nd.next()) {
ctx.thunk.accept(new SingleIterator<>(child));
}
} else {
nChild = new Tree<>(new Node(Node.Type.RESULT, evaluate(child)));
- if (nChild != null)
+ if(nChild != null) {
ctx.thunk.accept(new SingleIterator<>(nChild));
+ }
}
Node childNode = nChild.getHead();
EvaluatorResult res = childNode.resultVal;
- if (res.type == FLOAT)
+ if(res.type == FLOAT) {
curLevel = CoerceSteps.FLOAT;
+ }
children.add(nChild);
}
- for (ITree<Node> child : children) {
+ for(ITree<Node> child : children) {
Node nd = child.getHead();
EvaluatorResult res = nd.resultVal;
- switch (res.type) {
+ switch(res.type) {
case INT:
- if (curLevel == CoerceSteps.FLOAT) {
+ if(curLevel == CoerceSteps.FLOAT) {
nd.resultVal = new EvaluatorResult(FLOAT, (double) res.intVal);
}
default:
@@ -179,7 +182,7 @@ public class Evaluator {
case DICESCALAR:
EvaluatorResult opr = ast.getChild(0).getHead().resultVal;
- if (opr.type != INT) {
+ if(opr.type != INT) {
Errors.inst.printError(EK_EVAL_INVDCREATE, opr.type.toString());
}
@@ -188,7 +191,7 @@ public class Evaluator {
case DICEFUDGE:
EvaluatorResult oprn = ast.getChild(0).getHead().resultVal;
- if (oprn.type != INT) {
+ if(oprn.type != INT) {
Errors.inst.printError(EK_EVAL_INVDCREATE, oprn.type.toString());
}
@@ -203,7 +206,7 @@ public class Evaluator {
private ITree<Node> evaluateBinaryOp(ITree<Node> ast, Context ctx) {
Token.Type binOp = ast.getHead().operatorType;
- if (ast.getChildrenCount() != 2) {
+ if(ast.getChildrenCount() != 2) {
Errors.inst.printError(EK_EVAL_INVBIN, Integer.toString(ast.getChildrenCount()),
ast.toString());
@@ -213,7 +216,7 @@ public class Evaluator {
ITree<Node> left = ast.getChild(0);
ITree<Node> right = ast.getChild(1);
- switch (binOp) {
+ switch(binOp) {
case ADD:
case SUBTRACT:
case MULTIPLY:
@@ -235,16 +238,16 @@ public class Evaluator {
private ITree<Node> evaluateStringBinary(Token.Type op, EvaluatorResult left, EvaluatorResult right,
Context ctx) {
- if (left.type != STRING) {
+ if(left.type != STRING) {
Errors.inst.printError(EK_EVAL_INVSTRING, left.type.toString());
return new Tree<>(FAIL(left));
}
String strang = left.stringVal;
- switch (op) {
+ switch(op) {
case STRCAT:
- if (right.type != STRING) {
+ if(right.type != STRING) {
Errors.inst.printError(EK_EVAL_UNSTRING, right.type.toString());
return new Tree<>(FAIL(right));
} else {
@@ -253,13 +256,13 @@ public class Evaluator {
new EvaluatorResult(STRING, strang + strung)));
}
case STRREP:
- if (right.type != INT) {
+ if(right.type != INT) {
Errors.inst.printError(EK_EVAL_INVSTRING, right.type.toString());
return new Tree<>(FAIL(right));
} else {
String res = strang;
long count = right.intVal;
- for (long i = 1; i < count; i++) {
+ for(long i = 1; i < count; i++) {
res += strang;
}
return new Tree<>(new Node(Node.Type.RESULT, new EvaluatorResult(STRING, res)));
@@ -274,24 +277,24 @@ public class Evaluator {
Context ctx) {
EvaluatorResult res = null;
- switch (op) {
+ switch(op) {
case DICEGROUP:
- if (left.type == DICE && !left.diceVal.isList) {
- if (right.type == DICE && !right.diceVal.isList) {
+ if(left.type == DICE && !left.diceVal.isList) {
+ if(right.type == DICE && !right.diceVal.isList) {
res = new EvaluatorResult(DICE,
new SimpleDie(left.diceVal.scalar, right.diceVal.scalar));
- } else if (right.type == INT) {
+ } else if(right.type == INT) {
res = new EvaluatorResult(DICE,
new SimpleDie(left.diceVal.scalar, right.intVal));
} else {
Errors.inst.printError(EK_EVAL_INVDGROUP, right.type.toString());
return new Tree<>(FAIL(right));
}
- } else if (left.type == INT) {
- if (right.type == DICE && !right.diceVal.isList) {
+ } else if(left.type == INT) {
+ if(right.type == DICE && !right.diceVal.isList) {
res = new EvaluatorResult(DICE,
new SimpleDie(left.intVal, right.diceVal.scalar));
- } else if (right.type == INT) {
+ } else if(right.type == INT) {
res = new EvaluatorResult(DICE, new SimpleDie(left.intVal, right.intVal));
} else {
Errors.inst.printError(EK_EVAL_INVDGROUP, right.type.toString());
@@ -302,10 +305,10 @@ public class Evaluator {
return new Tree<>(FAIL(left));
}
case DICECONCAT:
- if (left.type != DICE || left.diceVal.isList) {
+ if(left.type != DICE || left.diceVal.isList) {
Errors.inst.printError(EK_EVAL_INVDICE, left.type.toString());
return new Tree<>(FAIL(left));
- } else if (right.type != DICE || right.diceVal.isList) {
+ } else if(right.type != DICE || right.diceVal.isList) {
Errors.inst.printError(EK_EVAL_INVDICE, right.type.toString());
return new Tree<>(FAIL(right));
} else {
@@ -314,10 +317,10 @@ public class Evaluator {
}
break;
case DICELIST:
- if (left.type != DICE || left.diceVal.isList) {
+ if(left.type != DICE || left.diceVal.isList) {
Errors.inst.printError(EK_EVAL_INVDICE, left.type.toString());
return new Tree<>(FAIL(left));
- } else if (right.type != DICE || right.diceVal.isList) {
+ } else if(right.type != DICE || right.diceVal.isList) {
Errors.inst.printError(EK_EVAL_INVDICE, right.type.toString());
return new Tree<>(FAIL(right));
} else {
@@ -335,42 +338,42 @@ public class Evaluator {
private ITree<Node> evaluateMathBinary(Token.Type op, EvaluatorResult left, EvaluatorResult right,
Context ctx) {
- if (left.type == STRING || right.type == STRING) {
+ if(left.type == STRING || right.type == STRING) {
Errors.inst.printError(EK_EVAL_STRINGMATH);
return new Tree<>(FAIL());
- } else if (left.type == FAILURE || right.type == FAILURE) {
+ } else if(left.type == FAILURE || right.type == FAILURE)
return new Tree<>(FAIL());
- } else if (left.type == INT && right.type != INT) {
+ else if(left.type == INT && right.type != INT) {
Errors.inst.printError(EK_EVAL_MISMATH);
return new Tree<>(FAIL(right));
- } else if (left.type == FLOAT && right.type != FLOAT) {
+ } else if(left.type == FLOAT && right.type != FLOAT) {
Errors.inst.printError(EK_EVAL_MISMATH);
return new Tree<>(FAIL(right));
- } else if (left.type == DICE && right.type != DICE) {
+ } else if(left.type == DICE && right.type != DICE) {
Errors.inst.printError(EK_EVAL_MISMATH);
return new Tree<>(FAIL(right));
- } else if (right.type == INT && left.type != INT) {
+ } else if(right.type == INT && left.type != INT) {
Errors.inst.printError(EK_EVAL_MISMATH);
return new Tree<>(FAIL(left));
- } else if (right.type == FLOAT && left.type != FLOAT) {
+ } else if(right.type == FLOAT && left.type != FLOAT) {
Errors.inst.printError(EK_EVAL_MISMATH);
return new Tree<>(FAIL(left));
- } else if (right.type == DICE && left.type != DICE) {
+ } else if(right.type == DICE && left.type != DICE) {
Errors.inst.printError(EK_EVAL_MISMATH);
return new Tree<>(FAIL(left));
}
EvaluatorResult res = null;
- switch (op) {
+ switch(op) {
case ADD:
- if (left.type == INT) {
+ if(left.type == INT) {
res = new EvaluatorResult(INT, left.intVal + right.intVal);
- } else if (left.type == DICE) {
- if (left.diceVal.isList) {
+ } else if(left.type == DICE) {
+ if(left.diceVal.isList) {
Errors.inst.printError(EK_EVAL_INVDICE, left.toString());
return new Tree<>(FAIL(left));
- } else if (right.diceVal.isList) {
+ } else if(right.diceVal.isList) {
Errors.inst.printError(EK_EVAL_INVDICE, right.toString());
return new Tree<>(FAIL(right));
}
@@ -382,13 +385,13 @@ public class Evaluator {
}
break;
case SUBTRACT:
- if (left.type == INT) {
+ if(left.type == INT) {
res = new EvaluatorResult(INT, left.intVal - right.intVal);
- } else if (left.type == DICE) {
- if (left.diceVal.isList) {
+ } else if(left.type == DICE) {
+ if(left.diceVal.isList) {
Errors.inst.printError(EK_EVAL_INVDICE, left.toString());
return new Tree<>(FAIL(left));
- } else if (right.diceVal.isList) {
+ } else if(right.diceVal.isList) {
Errors.inst.printError(EK_EVAL_INVDICE, right.toString());
return new Tree<>(FAIL(right));
}
@@ -400,13 +403,13 @@ public class Evaluator {
}
break;
case MULTIPLY:
- if (left.type == INT) {
+ if(left.type == INT) {
res = new EvaluatorResult(INT, left.intVal * right.intVal);
- } else if (left.type == DICE) {
- if (left.diceVal.isList) {
+ } else if(left.type == DICE) {
+ if(left.diceVal.isList) {
Errors.inst.printError(EK_EVAL_INVDICE, left.toString());
return new Tree<>(FAIL(left));
- } else if (right.diceVal.isList) {
+ } else if(right.diceVal.isList) {
Errors.inst.printError(EK_EVAL_INVDICE, right.toString());
return new Tree<>(FAIL(right));
}
@@ -418,15 +421,15 @@ public class Evaluator {
}
break;
case DIVIDE:
- if (left.type == INT) {
- if (right.intVal == 0) {
+ if(left.type == INT) {
+ if(right.intVal == 0) {
Errors.inst.printError(EK_EVAL_DIVZERO);
res = new EvaluatorResult(FAILURE, right);
} else {
res = new EvaluatorResult(FLOAT, left.intVal / right.intVal);
}
- } else if (left.type == FLOAT) {
- if (right.floatVal == 0) {
+ } else if(left.type == FLOAT) {
+ if(right.floatVal == 0) {
Errors.inst.printError(EK_EVAL_DIVZERO);
res = new EvaluatorResult(FAILURE, right);
} else {
@@ -438,15 +441,15 @@ public class Evaluator {
}
break;
case IDIVIDE:
- if (left.type == INT) {
- if (right.intVal == 0) {
+ if(left.type == INT) {
+ if(right.intVal == 0) {
Errors.inst.printError(EK_EVAL_DIVZERO);
res = new EvaluatorResult(FAILURE, right);
} else {
res = new EvaluatorResult(INT, (int) (left.intVal / right.intVal));
}
- } else if (left.type == FLOAT) {
- if (right.floatVal == 0) {
+ } else if(left.type == FLOAT) {
+ if(right.floatVal == 0) {
Errors.inst.printError(EK_EVAL_DIVZERO);
res = new EvaluatorResult(FAILURE, right);
} else {
@@ -468,7 +471,7 @@ public class Evaluator {
private ITree<Node> evaluateTokenRef(Token tk, Context ctx) {
EvaluatorResult res = null;
- switch (tk.type) {
+ switch(tk.type) {
case INT_LIT:
res = new EvaluatorResult(INT, tk.intValue);
break;
@@ -479,7 +482,7 @@ public class Evaluator {
res = new EvaluatorResult(DICE, tk.diceValue);
break;
case STRING_LIT:
- res = new EvaluatorResult(STRING, eng.getStringLiteral((int) (tk.intValue)));
+ res = new EvaluatorResult(STRING, eng.getStringLiteral((int) tk.intValue));
break;
default:
Errors.inst.printError(EK_EVAL_UNTOK, tk.type.toString());
generated by cgit v1.2.3 (git 2.25.1) at 2026-05-10 05:43:39 +0000