summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--dice-lang/src/bjc/dicelang/v2/DiceLangEngine.java174
-rw-r--r--dice-lang/src/bjc/dicelang/v2/Errors.java4
-rw-r--r--dice-lang/src/bjc/dicelang/v2/Evaluator.java196
-rw-r--r--dice-lang/src/bjc/dicelang/v2/EvaluatorResult.java94
-rw-r--r--dice-lang/src/bjc/dicelang/v2/Node.java4
-rw-r--r--dice-lang/src/bjc/dicelang/v2/Parser.java112
-rw-r--r--dice-lang/src/bjc/dicelang/v2/StreamEngine.java4
-rw-r--r--dice-lang/src/bjc/dicelang/v2/Token.java8
8 files changed, 311 insertions, 285 deletions
diff --git a/dice-lang/src/bjc/dicelang/v2/DiceLangEngine.java b/dice-lang/src/bjc/dicelang/v2/DiceLangEngine.java
index ad56cc1..1517abd 100644
--- a/dice-lang/src/bjc/dicelang/v2/DiceLangEngine.java
+++ b/dice-lang/src/bjc/dicelang/v2/DiceLangEngine.java
@@ -224,8 +224,7 @@ public class DiceLangEngine {
System.out.println("\tString literals in table");
stringLiterals.forEach((key, val) -> {
- System.out.printf("\t\tName: (%s)\tValue: (%s)\n",
- key, val);
+ System.out.printf("\t\tName: (%s)\tValue: (%s)\n", key, val);
});
}
}
@@ -287,57 +286,10 @@ public class DiceLangEngine {
IList<Token> shuntedTokens = lexedTokens;
IList<Token> preparedTokens = new FunctionalList<>();
- int curBraceCount = 0;
- Deque<IList<Token>> bracedTokens = new LinkedList<>();
- IList<Token> curBracedTokens = null;
-
- for(Token tk : lexedTokens) {
- if(tk.type == Token.Type.OBRACE && tk.intValue == 2) {
- curBraceCount += 1;
-
- if(curBraceCount != 1) {
- bracedTokens.push(curBracedTokens);
- }
-
- curBracedTokens = new FunctionalList<>();
- } else if(tk.type == Token.Type.CBRACE && tk.intValue == 2) {
- if(curBraceCount == 0) {
- Errors.inst.printError(EK_ENG_NOOPENING);
- return false;
- }
-
- curBraceCount -= 1;
-
- IList<Token> preshuntTokens = new FunctionalList<>();
-
- success = shunt.shuntTokens(curBracedTokens, preshuntTokens);
-
- if(debugMode)
- System.out.println("\t\tPreshunted " + curBracedTokens + " into " + preshuntTokens);
-
- if(!success) return false;
-
- if(curBraceCount >= 1) {
- curBracedTokens = bracedTokens.pop();
-
- curBracedTokens.add(new Token(Token.Type.TOKGROUP, preshuntTokens));
- } else {
- preparedTokens.add(new Token(Token.Type.TOKGROUP, preshuntTokens));
- }
- } else {
- if(curBraceCount >= 1) {
- curBracedTokens.add(tk);
- } else {
- preparedTokens.add(tk);
- }
- }
- }
-
- if(curBraceCount > 0) {
- Errors.inst.printError(EK_ENG_NOCLOSING);
- return false;
- }
+ boolean sc = removePreshuntTokens(lexedTokens, preparedTokens);
+ if(!sc) return false;
+
if(debugMode && !postfixMode)
System.out.printf("\tCommand after pre-shunter removal: %s\n", preparedTokens.toString());
@@ -389,55 +341,115 @@ public class DiceLangEngine {
if(!success) return false;
if(debugMode) {
- System.out.println("\tParsed forest of asts");
- int treeNo = 1;
+ evaluateForest(astForest);
+ }
- for(ITree<Node> ast : astForest) {
- System.out.println("\t\tTree " + treeNo + " in forest:\n\t\t " + ast);
+ return true;
+ }
- if(stepEval) {
- int step = 1;
+ private void evaluateForest(IList<ITree<Node>> astForest) {
+ System.out.println("\tParsed forest of asts");
+ int treeNo = 1;
- for(Iterator<ITree<Node>> itr = eval.stepDebug(ast); itr.hasNext();){
- ITree<Node> nodeStep = itr.next();
+ for(ITree<Node> ast : astForest) {
+ System.out.println("\t\tTree " + treeNo + " in forest:\n\t\t " + ast);
- System.out.printf("\t\tStep %d: Node is %s", step, nodeStep);
+ if(stepEval) {
+ int step = 1;
- if(nodeStep.getHead().type == Node.Type.RESULT) {
- Evaluator.Result res = nodeStep.getHead().resultVal;
+ for(Iterator<ITree<Node>> itr = eval.stepDebug(ast); itr.hasNext();){
+ ITree<Node> nodeStep = itr.next();
- System.out.printf(" (result is %s", res);
+ System.out.printf("\t\tStep %d: Node is %s", step, nodeStep);
- if(res.type == Evaluator.Result.Type.DICE) {
- System.out.printf(" (sample roll %s)", res.diceVal.value());
- }
+ if(nodeStep.getHead().type == Node.Type.RESULT) {
+ EvaluatorResult res = nodeStep.getHead().resultVal;
- if(res.origVal != null) {
- System.out.printf(" (original tree is %s)", res.origVal);
- }
+ System.out.printf(" (result is %s", res);
- System.out.printf(")");
+ if(res.type == EvaluatorResult.Type.DICE) {
+ System.out.printf(" (sample roll %s)", res.diceVal.value());
}
+ if(res.origVal != null) {
+ System.out.printf(" (original tree is %s)", res.origVal);
+ }
- System.out.println();
- step += 1;
+ System.out.printf(")");
}
- } else {
- Evaluator.Result res = eval.evaluate(ast);
- System.out.printf("\t\tEvaluates to %s", res);
- if(res.type == Evaluator.Result.Type.DICE) {
- System.out.println(" (sample roll " + res.diceVal.value() + ")");
- }
+
+ System.out.println();
+ step += 1;
+ }
+ } else {
+ EvaluatorResult res = eval.evaluate(ast);
+ System.out.printf("\t\tEvaluates to %s", res);
+
+ if(res.type == EvaluatorResult.Type.DICE) {
+ System.out.println(" (sample roll " + res.diceVal.value() + ")");
}
+ }
- System.out.println();
+ System.out.println();
- treeNo += 1;
+ treeNo += 1;
+ }
+ }
+
+ private boolean removePreshuntTokens(IList<Token> lexedTokens, IList<Token> preparedTokens) {
+ boolean success;
+ int curBraceCount = 0;
+ Deque<IList<Token>> bracedTokens = new LinkedList<>();
+ IList<Token> curBracedTokens = null;
+
+ for(Token tk : lexedTokens) {
+ if(tk.type == Token.Type.OBRACE && tk.intValue == 2) {
+ curBraceCount += 1;
+
+ if(curBraceCount != 1) {
+ bracedTokens.push(curBracedTokens);
+ }
+
+ curBracedTokens = new FunctionalList<>();
+ } else if(tk.type == Token.Type.CBRACE && tk.intValue == 2) {
+ if(curBraceCount == 0) {
+ Errors.inst.printError(EK_ENG_NOOPENING);
+ return false;
+ }
+
+ curBraceCount -= 1;
+
+ IList<Token> preshuntTokens = new FunctionalList<>();
+
+ success = shunt.shuntTokens(curBracedTokens, preshuntTokens);
+
+ if(debugMode)
+ System.out.println("\t\tPreshunted " + curBracedTokens + " into " + preshuntTokens);
+
+ if(!success) return false;
+
+ if(curBraceCount >= 1) {
+ curBracedTokens = bracedTokens.pop();
+
+ curBracedTokens.add(new Token(Token.Type.TOKGROUP, preshuntTokens));
+ } else {
+ preparedTokens.add(new Token(Token.Type.TOKGROUP, preshuntTokens));
+ }
+ } else {
+ if(curBraceCount >= 1) {
+ curBracedTokens.add(tk);
+ } else {
+ preparedTokens.add(tk);
+ }
}
}
+ if(curBraceCount > 0) {
+ Errors.inst.printError(EK_ENG_NOCLOSING);
+ return false;
+ }
+
return true;
}
diff --git a/dice-lang/src/bjc/dicelang/v2/Errors.java b/dice-lang/src/bjc/dicelang/v2/Errors.java
index a533438..0f4c52d 100644
--- a/dice-lang/src/bjc/dicelang/v2/Errors.java
+++ b/dice-lang/src/bjc/dicelang/v2/Errors.java
@@ -35,8 +35,12 @@ public class Errors {
EK_EVAL_INVNODE,
// Incorrect # of args to binary operator
EK_EVAL_INVBIN,
+ // Incorrect # of args to unary operator
+ EK_EVAL_INVUNARY,
// Unknown binary operator
EK_EVAL_UNBIN,
+ // Unknown unary operator
+ EK_EVAL_UNUNARY,
// Math on strings doesn't work
EK_EVAL_STRINGMATH,
// Attempted divide by zero
diff --git a/dice-lang/src/bjc/dicelang/v2/Evaluator.java b/dice-lang/src/bjc/dicelang/v2/Evaluator.java
index c13e42d..7624b47 100644
--- a/dice-lang/src/bjc/dicelang/v2/Evaluator.java
+++ b/dice-lang/src/bjc/dicelang/v2/Evaluator.java
@@ -2,106 +2,15 @@ package bjc.dicelang.v2;
import bjc.utils.data.ITree;
import bjc.utils.data.Tree;
-import bjc.utils.data.TransformedIterator;
import bjc.utils.data.TopDownTransformIterator;
import bjc.utils.data.TopDownTransformResult;
import java.util.Iterator;
import java.util.function.Consumer;
import static bjc.dicelang.v2.Errors.ErrorKey.*;
-import static bjc.dicelang.v2.Evaluator.Result.Type.*;
+import static bjc.dicelang.v2.EvaluatorResult.Type.*;
public class Evaluator {
- public static class Result {
- public static enum Type {
- FAILURE,
- INT, FLOAT, DICE, STRING
- }
-
- public final Type type;
-
- // These may or may not have values based
- // off of the result type
- public long intVal;
- public double floatVal;
- public DiceBox.DieExpression diceVal;
- public String stringVal;
-
- // Original node data
- public ITree<Node> origVal;
-
- public Result(Type typ) {
- type = typ;
- }
-
- public Result(Type typ, ITree<Node> orig) {
- this(typ);
-
- origVal = orig;
- }
-
- public Result(Type typ, Node orig) {
- this(typ, new Tree<>(orig));
- }
-
- public Result(Type typ, Result orig) {
- this(typ, new Node(Node.Type.RESULT, orig));
- }
-
- public Result(Type typ, long iVal) {
- this(typ);
-
- intVal = iVal;
- }
-
- public Result(Type typ, double dVal) {
- this(typ);
-
- floatVal = dVal;
- }
-
- public Result(Type typ, DiceBox.DieExpression dVal) {
- this(typ);
-
- diceVal = dVal;
- }
-
- public Result(Type typ, DiceBox.Die dVal) {
- this(typ);
-
- diceVal = new DiceBox.DieExpression(dVal);
- }
-
- public Result(Type typ, DiceBox.DieList dVal) {
- this(typ);
-
- diceVal = new DiceBox.DieExpression(dVal);
- }
-
- public Result(Type typ, String strang) {
- this(typ);
-
- stringVal = strang;
- }
-
- public String toString() {
- switch(type) {
- case INT:
- return type.toString() + "(" + intVal + ")";
- case FLOAT:
- return type.toString() + "(" + floatVal + ")";
- case DICE:
- return type.toString() + "(" + diceVal + ")";
- case STRING:
- return type.toString() + "(" + stringVal + ")";
- case FAILURE:
- return type.toString();
- default:
- return "Unknown result type " + type.toString();
- }
- }
- }
-
private static class Context {
public Consumer<Iterator<ITree<Node>>> thunk;
@@ -109,19 +18,19 @@ public class Evaluator {
}
private static Node FAIL() {
- return new Node(Node.Type.RESULT, new Result(Result.Type.FAILURE));
+ return new Node(Node.Type.RESULT, new EvaluatorResult(EvaluatorResult.Type.FAILURE));
}
private static Node FAIL(ITree<Node> orig) {
- return new Node(Node.Type.RESULT, new Result(Result.Type.FAILURE, orig));
+ return new Node(Node.Type.RESULT, new EvaluatorResult(EvaluatorResult.Type.FAILURE, orig));
}
private static Node FAIL(Node orig) {
- return new Node(Node.Type.RESULT, new Result(Result.Type.FAILURE, orig));
+ return new Node(Node.Type.RESULT, new EvaluatorResult(EvaluatorResult.Type.FAILURE, orig));
}
- private static Node FAIL(Result res) {
- return new Node(Node.Type.RESULT, new Result(Result.Type.FAILURE, new Node(Node.Type.RESULT, res)));
+ private static Node FAIL(EvaluatorResult res) {
+ return new Node(Node.Type.RESULT, new EvaluatorResult(EvaluatorResult.Type.FAILURE, new Node(Node.Type.RESULT, res)));
}
private DiceLangEngine eng;
@@ -130,7 +39,7 @@ public class Evaluator {
eng = en;
}
- public Result evaluate(ITree<Node> comm) {
+ public EvaluatorResult evaluate(ITree<Node> comm) {
Context ctx = new Context();
ctx.isDebug = false;
@@ -161,7 +70,7 @@ public class Evaluator {
case UNARYOP:
switch(nd.operatorType) {
case COERCE:
- return TopDownTransformResult.PULLUP;
+ return TopDownTransformResult.RTRANSFORM;
default:
return TopDownTransformResult.PUSHDOWN;
}
@@ -190,7 +99,7 @@ public class Evaluator {
switch(ast.getHead().operatorType) {
case COERCE:
if(ast.getChildrenCount() != 1) {
- Errors.inst.printError(EK_EVAL_NOTUNARY, ast.getChildrenCount());
+ Errors.inst.printError(EK_EVAL_UNUNARY, Integer.toString(ast.getChildrenCount()));
return new Tree<>(FAIL(ast));
}
break;
@@ -198,6 +107,9 @@ public class Evaluator {
Errors.inst.printError(EK_EVAL_INVUNARY, ast.getHead().operatorType.toString());
return new Tree<>(FAIL(ast));
}
+
+ // @TODO remove me
+ return new Tree<>(FAIL(ast));
}
private ITree<Node> evaluateBinaryOp(ITree<Node> ast, Context ctx) {
@@ -234,26 +146,26 @@ public class Evaluator {
}
private ITree<Node> evaluateDiceBinary(Token.Type op,
- Result left, Result right, Context ctx) {
- Result res = null;
+ EvaluatorResult left, EvaluatorResult right, Context ctx) {
+ EvaluatorResult res = null;
switch(op) {
case DICEGROUP:
if(left.type == DICE && !left.diceVal.isList) {
if(right.type == DICE && !right.diceVal.isList) {
- res = new Result(DICE,
+ res = new EvaluatorResult(DICE,
new DiceBox.SimpleDie(left.diceVal.scalar, right.diceVal.scalar));
} else if (right.type == INT) {
- res = new Result(DICE, new DiceBox.SimpleDie(left.diceVal.scalar, right.intVal));
+ res = new EvaluatorResult(DICE, new DiceBox.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) {
- res = new Result(DICE, new DiceBox.SimpleDie(left.intVal, right.diceVal.scalar));
+ res = new EvaluatorResult(DICE, new DiceBox.SimpleDie(left.intVal, right.diceVal.scalar));
} else if (right.type == INT) {
- res = new Result(DICE, new DiceBox.SimpleDie(left.intVal, right.intVal));
+ res = new EvaluatorResult(DICE, new DiceBox.SimpleDie(left.intVal, right.intVal));
} else {
Errors.inst.printError(EK_EVAL_INVDGROUP, right.type.toString());
return new Tree<>(FAIL(right));
@@ -270,7 +182,7 @@ public class Evaluator {
Errors.inst.printError(EK_EVAL_INVDICE, right.type.toString());
return new Tree<>(FAIL(right));
} else {
- res = new Result(DICE,
+ res = new EvaluatorResult(DICE,
new DiceBox.CompoundDie(left.diceVal.scalar, right.diceVal.scalar));
}
break;
@@ -282,7 +194,7 @@ public class Evaluator {
Errors.inst.printError(EK_EVAL_INVDICE, right.type.toString());
return new Tree<>(FAIL(right));
} else {
- res = new Result(DICE,
+ res = new EvaluatorResult(DICE,
new DiceBox.SimpleDieList(left.diceVal.scalar, right.diceVal.scalar));
}
break;
@@ -295,84 +207,84 @@ public class Evaluator {
}
private ITree<Node> evaluateMathBinary(Token.Type op,
- Result left, Result right, Context ctx) {
- if(left.type == Result.Type.DICE || right.type == Result.Type.DICE) {
+ EvaluatorResult left, EvaluatorResult right, Context ctx) {
+ if(left.type == EvaluatorResult.Type.DICE || right.type == EvaluatorResult.Type.DICE) {
System.out.println("\tEVALUATOR ERROR: Math on dice isn't supported yet");
return new Tree<>(FAIL());
- } else if(left.type == Result.Type.STRING || right.type == Result.Type.STRING) {
+ } else if(left.type == EvaluatorResult.Type.STRING || right.type == EvaluatorResult.Type.STRING) {
Errors.inst.printError(EK_EVAL_STRINGMATH);
return new Tree<>(FAIL());
- } else if(left.type == Result.Type.FAILURE || right.type == Result.Type.FAILURE) {
+ } else if(left.type == EvaluatorResult.Type.FAILURE || right.type == EvaluatorResult.Type.FAILURE) {
return new Tree<>(FAIL());
- } else if(left.type == Result.Type.INT && right.type != Result.Type.INT) {
+ } else if(left.type == EvaluatorResult.Type.INT && right.type != EvaluatorResult.Type.INT) {
Errors.inst.printError(EK_EVAL_MISMATH);
return new Tree<>(FAIL(right));
- } else if(left.type == Result.Type.FLOAT && right.type != Result.Type.FLOAT) {
+ } else if(left.type == EvaluatorResult.Type.FLOAT && right.type != EvaluatorResult.Type.FLOAT) {
Errors.inst.printError(EK_EVAL_MISMATH);
return new Tree<>(FAIL(right));
- } else if(right.type == Result.Type.INT && left.type != Result.Type.INT) {
+ } else if(right.type == EvaluatorResult.Type.INT && left.type != EvaluatorResult.Type.INT) {
Errors.inst.printError(EK_EVAL_MISMATH);
return new Tree<>(FAIL(left));
- } else if(right.type == Result.Type.FLOAT && left.type != Result.Type.FLOAT) {
+ } else if(right.type == EvaluatorResult.Type.FLOAT && left.type != EvaluatorResult.Type.FLOAT) {
Errors.inst.printError(EK_EVAL_MISMATH);
return new Tree<>(FAIL(left));
}
- Result res = null;
+ EvaluatorResult res = null;
switch(op) {
case ADD:
- if(left.type == Result.Type.INT) {
- res = new Result(Result.Type.INT, left.intVal + right.intVal);
+ if(left.type == EvaluatorResult.Type.INT) {
+ res = new EvaluatorResult(EvaluatorResult.Type.INT, left.intVal + right.intVal);
} else {
- res = new Result(Result.Type.FLOAT, left.floatVal + right.floatVal);
+ res = new EvaluatorResult(EvaluatorResult.Type.FLOAT, left.floatVal + right.floatVal);
}
break;
case SUBTRACT:
- if(left.type == Result.Type.INT) {
- res = new Result(Result.Type.INT, left.intVal - right.intVal);
+ if(left.type == EvaluatorResult.Type.INT) {
+ res = new EvaluatorResult(EvaluatorResult.Type.INT, left.intVal - right.intVal);
} else {
- res = new Result(Result.Type.FLOAT, left.floatVal - right.floatVal);
+ res = new EvaluatorResult(EvaluatorResult.Type.FLOAT, left.floatVal - right.floatVal);
}
break;
case MULTIPLY:
- if(left.type == Result.Type.INT) {
- res = new Result(Result.Type.INT, left.intVal * right.intVal);
+ if(left.type == EvaluatorResult.Type.INT) {
+ res = new EvaluatorResult(EvaluatorResult.Type.INT, left.intVal * right.intVal);
} else {
- res = new Result(Result.Type.FLOAT, left.floatVal * right.floatVal);
+ res = new EvaluatorResult(EvaluatorResult.Type.FLOAT, left.floatVal * right.floatVal);
}
break;
case DIVIDE:
- if(left.type == Result.Type.INT) {
+ if(left.type == EvaluatorResult.Type.INT) {
if(right.intVal == 0) {
Errors.inst.printError(EK_EVAL_DIVZERO);
- res = new Result(Result.Type.FAILURE, right);
+ res = new EvaluatorResult(EvaluatorResult.Type.FAILURE, right);
} else {
- res = new Result(Result.Type.FLOAT, left.intVal / right.intVal);
+ res = new EvaluatorResult(EvaluatorResult.Type.FLOAT, left.intVal / right.intVal);
}
} else {
if(right.floatVal == 0) {
Errors.inst.printError(EK_EVAL_DIVZERO);
- res = new Result(Result.Type.FAILURE, right);
+ res = new EvaluatorResult(EvaluatorResult.Type.FAILURE, right);
} else {
- res = new Result(Result.Type.FLOAT, left.floatVal / right.floatVal);
+ res = new EvaluatorResult(EvaluatorResult.Type.FLOAT, left.floatVal / right.floatVal);
}
}
break;
case IDIVIDE:
- if(left.type == Result.Type.INT) {
+ if(left.type == EvaluatorResult.Type.INT) {
if(right.intVal == 0) {
Errors.inst.printError(EK_EVAL_DIVZERO);
- res = new Result(Result.Type.FAILURE, right);
+ res = new EvaluatorResult(EvaluatorResult.Type.FAILURE, right);
} else {
- res = new Result(Result.Type.INT, (int) (left.intVal / right.intVal));
+ res = new EvaluatorResult(EvaluatorResult.Type.INT, (int) (left.intVal / right.intVal));
}
} else {
if(right.floatVal == 0) {
Errors.inst.printError(EK_EVAL_DIVZERO);
- res = new Result(Result.Type.FAILURE, right);
+ res = new EvaluatorResult(EvaluatorResult.Type.FAILURE, right);
} else {
- res = new Result(Result.Type.INT, (int) (left.floatVal / right.floatVal));
+ res = new EvaluatorResult(EvaluatorResult.Type.INT, (int) (left.floatVal / right.floatVal));
}
}
break;
@@ -385,24 +297,24 @@ public class Evaluator {
}
private ITree<Node> evaluateTokenRef(Token tk, Context ctx) {
- Result res = null;
+ EvaluatorResult res = null;
switch(tk.type) {
case INT_LIT:
- res = new Result(Result.Type.INT, tk.intValue);
+ res = new EvaluatorResult(EvaluatorResult.Type.INT, tk.intValue);
break;
case FLOAT_LIT:
- res = new Result(Result.Type.FLOAT, tk.floatValue);
+ res = new EvaluatorResult(EvaluatorResult.Type.FLOAT, tk.floatValue);
break;
case DICE_LIT:
- res = new Result(Result.Type.DICE, tk.diceValue);
+ res = new EvaluatorResult(EvaluatorResult.Type.DICE, tk.diceValue);
break;
case STRING_LIT:
- res = new Result(Result.Type.STRING, eng.stringLits.get((int)(tk.intValue)));
+ res = new EvaluatorResult(EvaluatorResult.Type.STRING, eng.stringLits.get((int)(tk.intValue)));
break;
default:
Errors.inst.printError(EK_EVAL_UNTOK, tk.type.toString());
- res = new Result(Result.Type.FAILURE);
+ res = new EvaluatorResult(EvaluatorResult.Type.FAILURE);
}
return new Tree<>(new Node(Node.Type.RESULT, res));
diff --git a/dice-lang/src/bjc/dicelang/v2/EvaluatorResult.java b/dice-lang/src/bjc/dicelang/v2/EvaluatorResult.java
new file mode 100644
index 0000000..510d5e9
--- /dev/null
+++ b/dice-lang/src/bjc/dicelang/v2/EvaluatorResult.java
@@ -0,0 +1,94 @@
+package bjc.dicelang.v2;
+
+import bjc.utils.data.ITree;
+import bjc.utils.data.Tree;
+
+public class EvaluatorResult {
+ public static enum Type {
+ FAILURE,
+ INT, FLOAT, DICE, STRING
+ }
+
+ public final EvaluatorResult.Type type;
+
+ // These may or may not have values based
+ // off of the result type
+ public long intVal;
+ public double floatVal;
+ public DiceBox.DieExpression diceVal;
+ public String stringVal;
+
+ // Original node data
+ public ITree<Node> origVal;
+
+ public EvaluatorResult(EvaluatorResult.Type typ) {
+ type = typ;
+ }
+
+ public EvaluatorResult(EvaluatorResult.Type typ, ITree<Node> orig) {
+ this(typ);
+
+ origVal = orig;
+ }
+
+ public EvaluatorResult(EvaluatorResult.Type typ, Node orig) {
+ this(typ, new Tree<>(orig));
+ }
+
+ public EvaluatorResult(EvaluatorResult.Type typ, EvaluatorResult orig) {
+ this(typ, new Node(Node.Type.RESULT, orig));
+ }
+
+ public EvaluatorResult(EvaluatorResult.Type typ, long iVal) {
+ this(typ);
+
+ intVal = iVal;
+ }
+
+ public EvaluatorResult(EvaluatorResult.Type typ, double dVal) {
+ this(typ);
+
+ floatVal = dVal;
+ }
+
+ public EvaluatorResult(EvaluatorResult.Type typ, DiceBox.DieExpression dVal) {
+ this(typ);
+
+ diceVal = dVal;
+ }
+
+ public EvaluatorResult(EvaluatorResult.Type typ, DiceBox.Die dVal) {
+ this(typ);
+
+ diceVal = new DiceBox.DieExpression(dVal);
+ }
+
+ public EvaluatorResult(EvaluatorResult.Type typ, DiceBox.DieList dVal) {
+ this(typ);
+
+ diceVal = new DiceBox.DieExpression(dVal);
+ }
+
+ public EvaluatorResult(EvaluatorResult.Type typ, String strang) {
+ this(typ);
+
+ stringVal = strang;
+ }
+
+ public String toString() {
+ switch(type) {
+ case INT:
+ return type.toString() + "(" + intVal + ")";
+ case FLOAT:
+ return type.toString() + "(" + floatVal + ")";
+ case DICE:
+ return type.toString() + "(" + diceVal + ")";
+ case STRING:
+ return type.toString() + "(" + stringVal + ")";
+ case FAILURE:
+ return type.toString();
+ default:
+ return "Unknown result type " + type.toString();
+ }
+ }
+} \ No newline at end of file
diff --git a/dice-lang/src/bjc/dicelang/v2/Node.java b/dice-lang/src/bjc/dicelang/v2/Node.java
index bd191d2..334a9f3 100644
--- a/dice-lang/src/bjc/dicelang/v2/Node.java
+++ b/dice-lang/src/bjc/dicelang/v2/Node.java
@@ -18,7 +18,7 @@ public class Node {
public Token tokenVal;
public Token.Type operatorType;
public GroupType groupType;
- public Evaluator.Result resultVal;
+ public EvaluatorResult resultVal;
public Node(Type typ) {
type = typ;
@@ -42,7 +42,7 @@ public class Node {
groupType = grupType;
}
- public Node(Type typ, Evaluator.Result res) {
+ public Node(Type typ, EvaluatorResult res) {
this(typ);
resultVal = res;
diff --git a/dice-lang/src/bjc/dicelang/v2/Parser.java b/dice-lang/src/bjc/dicelang/v2/Parser.java
index 7151e0e..c939a8b 100644
--- a/dice-lang/src/bjc/dicelang/v2/Parser.java
+++ b/dice-lang/src/bjc/dicelang/v2/Parser.java
@@ -28,59 +28,8 @@ public class Parser {
break;
case CBRACKET:
case CBRACE:
- if(working.size() == 0) {
- Errors.inst.printError(EK_PARSE_NOCLOSE);
- return false;
- }
-
- ITree<Node> groupNode = null;
- switch(tk.type) {
- case CBRACE:
- groupNode = new Tree<>(new Node(GROUP, Node.GroupType.CODE));
- break;
- case CBRACKET:
- groupNode = new Tree<>(new Node(GROUP, Node.GroupType.ARRAY));
- break;
- default:
- break;
- }
- Token matching = null;
-
- if(tk.type == CBRACKET) {
- matching = new Token(Token.Type.OBRACKET, tk.intValue);
- } else if(tk.type == CBRACE) {
- matching = new Token(Token.Type.OBRACE, tk.intValue);
- }
-
- ITree<Node> matchNode = new Tree<>(new Node(OGROUP, matching));
-
- if(!working.contains(matchNode)) {
- Errors.inst.printError(EK_PARSE_UNCLOSE, tk.toString(), matchNode.toString());
-
- System.out.println("\tCurrent forest is: ");
-
- int treeNo = 1;
- for(ITree<Node> ast : working) {
- System.out.println("Tree " + treeNo++ + ": " + ast.toString());
- }
-
- return false;
- } else {
- Deque<ITree<Node>> childs = new LinkedList<>();
-
- while(!working.peek().equals(matchNode)) {
- childs.push(working.pop());
- }
-
- // Discard opener
- working.pop();
-
- for(ITree<Node> child : childs) {
- groupNode.addChild(child);
- }
-
- working.push(groupNode);
- }
+ boolean sc = parseClosingGrouper(working, tk);
+ if(!sc) return false;
break;
case LET:
case BIND:
@@ -158,4 +107,61 @@ public class Parser {
return true;
}
+
+ private boolean parseClosingGrouper(Deque<ITree<Node>> working, Token tk) {
+ if(working.size() == 0) {
+ Errors.inst.printError(EK_PARSE_NOCLOSE);
+ return false;
+ }
+
+ ITree<Node> groupNode = null;
+ switch(tk.type) {
+ case CBRACE:
+ groupNode = new Tree<>(new Node(GROUP, Node.GroupType.CODE));
+ break;
+ case CBRACKET:
+ groupNode = new Tree<>(new Node(GROUP, Node.GroupType.ARRAY));
+ break;
+ default:
+ break;
+ }
+
+ Token matching = null;
+ if(tk.type == CBRACKET) {
+ matching = new Token(Token.Type.OBRACKET, tk.intValue);
+ } else if(tk.type == CBRACE) {
+ matching = new Token(Token.Type.OBRACE, tk.intValue);
+ }
+
+ ITree<Node> matchNode = new Tree<>(new Node(OGROUP, matching));
+ if(!working.contains(matchNode)) {
+ Errors.inst.printError(EK_PARSE_UNCLOSE, tk.toString(), matchNode.toString());
+
+ System.out.println("\tCurrent forest is: ");
+
+ int treeNo = 1;
+ for(ITree<Node> ast : working) {
+ System.out.println("Tree " + treeNo++ + ": " + ast.toString());
+ }
+
+ return false;
+ } else {
+ Deque<ITree<Node>> childs = new LinkedList<>();
+
+ while(!working.peek().equals(matchNode)) {
+ childs.push(working.pop());
+ }
+
+ // Discard opener
+ working.pop();
+
+ for(ITree<Node> child : childs) {
+ groupNode.addChild(child);
+ }
+
+ working.push(groupNode);
+ }
+
+ return true;
+ }
}
diff --git a/dice-lang/src/bjc/dicelang/v2/StreamEngine.java b/dice-lang/src/bjc/dicelang/v2/StreamEngine.java
index 8755e19..383c7f3 100644
--- a/dice-lang/src/bjc/dicelang/v2/StreamEngine.java
+++ b/dice-lang/src/bjc/dicelang/v2/StreamEngine.java
@@ -41,8 +41,8 @@ public class StreamEngine {
} else {
if(tk.equals("{@SU}")) {
quoteMode = false;
- } else if(tk.equals("\\{@SU}")) {
- currStream.add("{@SU}");
+ } else if(tk.matches("\\\\+{@SU}")) {
+ currStream.add(tk.substring(1));
} else {
currStream.add(tk);
}
diff --git a/dice-lang/src/bjc/dicelang/v2/Token.java b/dice-lang/src/bjc/dicelang/v2/Token.java
index ed5ee8b..e5d3d9f 100644
--- a/dice-lang/src/bjc/dicelang/v2/Token.java
+++ b/dice-lang/src/bjc/dicelang/v2/Token.java
@@ -28,11 +28,7 @@ public class Token {
// Synthetic tokens
// These are produced when needed
NIL, GROUPSEP, TOKGROUP,
- TAGOP, TAGOPR,
-
- // Tag tokens
- // These are used for the TAG* tokens
-
+ TAGOP, TAGOPR
}
public final Type type;
@@ -104,6 +100,8 @@ public class Token {
case DICE_LIT:
return type.toString() + "("
+ diceValue + ")";
+ case TAGOP:
+ case TAGOPR:
case TOKGROUP:
return type.toString() + "("
+ tokenValues + ")";
generated by cgit v1.2.3 (git 2.25.1) at 2026-05-10 06:50:01 +0000