diff options
Diffstat (limited to 'dice-lang/src/examples/java')
5 files changed, 382 insertions, 0 deletions
diff --git a/dice-lang/src/examples/java/bjc/dicelang/examples/DiceASTLanguageState.java b/dice-lang/src/examples/java/bjc/dicelang/examples/DiceASTLanguageState.java new file mode 100644 index 0000000..f5a6a29 --- /dev/null +++ b/dice-lang/src/examples/java/bjc/dicelang/examples/DiceASTLanguageState.java @@ -0,0 +1,36 @@ +package bjc.dicelang.examples; + +import java.util.Map; + +import bjc.dicelang.DiceExpressionParser; +import bjc.dicelang.ast.DiceASTExpression; +import bjc.utils.data.Pair; + +/** + * Internal state of the AST-based dice langugae + * + * @author ben + * + */ +public class DiceASTLanguageState extends + Pair<DiceExpressionParser, Map<String, DiceASTExpression>> { + + /** + * Create a new state + */ + public DiceASTLanguageState() { + } + + /** + * Create a new state with the given contents + * + * @param left + * The parser to use + * @param right + * The enviroment to use + */ + public DiceASTLanguageState(DiceExpressionParser left, + Map<String, DiceASTExpression> right) { + super(left, right); + } +} diff --git a/dice-lang/src/examples/java/bjc/dicelang/examples/DiceASTLanguageTest.java b/dice-lang/src/examples/java/bjc/dicelang/examples/DiceASTLanguageTest.java new file mode 100644 index 0000000..8f3fe1d --- /dev/null +++ b/dice-lang/src/examples/java/bjc/dicelang/examples/DiceASTLanguageTest.java @@ -0,0 +1,151 @@ +package bjc.dicelang.examples; + +import java.util.HashMap; +import java.util.Map; +import java.util.Scanner; +import java.util.function.BiConsumer; +import java.util.function.Consumer; + +import bjc.dicelang.DiceExpressionParser; +import bjc.dicelang.IDiceExpression; +import bjc.dicelang.ast.DiceASTExpression; +import bjc.dicelang.ast.DiceASTFreezer; +import bjc.dicelang.ast.DiceASTParser; +import bjc.dicelang.ast.IDiceASTNode; +import bjc.dicelang.ast.VariableDiceNode; +import bjc.utils.data.GenHolder; +import bjc.utils.funcdata.ITreePart.TreeLinearizationMethod; +import bjc.utils.parserutils.AST; + +/** + * A test of the AST based dice language + * + * @author ben + * + */ +public class DiceASTLanguageTest { + private static final class LastChecker + implements Consumer<IDiceASTNode> { + private GenHolder<Boolean> canUpdateLast; + + public LastChecker(GenHolder<Boolean> canUpdateLast) { + this.canUpdateLast = canUpdateLast; + } + + @Override + public void accept(IDiceASTNode tn) { + if (tn instanceof VariableDiceNode && ((VariableDiceNode) tn) + .getVariable().equals("last")) { + canUpdateLast.transform((s) -> false); + } else { + canUpdateLast.transform((s) -> true); + } + } + } + + private static Map<String, BiConsumer<String, DiceASTLanguageState>> acts; + + static { + acts = new HashMap<>(); + + acts.put("roll", DiceASTLanguageTest::rollReference); + acts.put("env", DiceASTLanguageTest::printEnv); + acts.put("freeze", DiceASTLanguageTest::freezeVar); + } + + private static void freezeVar(String ln, DiceASTLanguageState stat) { + String[] strangs = ln.split(" "); + + System.out.println("Freezing references in " + strangs[1]); + + stat.doWith((dep, env) -> { + env.put(strangs[1], new DiceASTExpression( + DiceASTFreezer.freezeAST(env.get(strangs[1]), env), + env)); + }); + } + + /** + * @param ln + * Unused parameter, kept in place to conform to expected + * type sig + */ + private static void printEnv(String ln, DiceASTLanguageState stat) { + System.out.println("Printing enviroment for debugging purposes."); + + stat.doWith((dep, env) -> env.forEach((key, exp) -> System.out + .println("\tKey: " + key + "\tExp: " + exp.toString()))); + } + + private static void rollReference(String ln, + DiceASTLanguageState stat) { + String[] strangs = ln.split(" "); + + System.out.println("\tRolling dice expression " + strangs[1] + " " + + strangs[2] + " times."); + + int nRolls = Integer.parseInt(strangs[2]); + + IDiceExpression dexp = + stat.merge((dep, env) -> env.get(strangs[1])); + + for (int i = 1; i <= nRolls; i++) { + int roll = dexp.roll(); + + System.out.println("\tRolled " + roll); + } + } + + /** + * Main method of class + * + * @param args + * Unused CLI args + */ + public static void main(String[] args) { + Scanner scn = new Scanner(System.in); + int i = 0; + + System.out.print("dice-lang-" + i + "> "); + String ln = scn.nextLine(); + + DiceASTParser dap = new DiceASTParser(); + + DiceExpressionParser dep = new DiceExpressionParser(); + Map<String, DiceASTExpression> env = new HashMap<>(); + DiceASTLanguageState state = new DiceASTLanguageState(dep, env); + + while (!ln.equalsIgnoreCase("quit")) { + String header = ln.split(" ")[0]; + + if (acts.containsKey(header)) { + acts.get(header).accept(ln, state); + } else { + + AST<IDiceASTNode> builtAST = dap.buildAST(ln); + DiceASTExpression exp = + new DiceASTExpression(builtAST, env); + + System.out.println("\tParsed: " + exp.toString()); + System.out.println("\tSample Roll: " + exp.roll()); + + GenHolder<Boolean> canUpdateLast = new GenHolder<>(false); + + exp.getAst().traverse(TreeLinearizationMethod.PREORDER, + new LastChecker(canUpdateLast)); + + if (canUpdateLast.unwrap((s) -> s)) { + env.put("last", exp); + } + } + + i++; + + System.out.print("dice-lang-" + i + "> "); + ln = scn.nextLine(); + } + + System.out.println("Bye."); + scn.close(); + } +} diff --git a/dice-lang/src/examples/java/bjc/dicelang/examples/DiceExpressionParserTest.java b/dice-lang/src/examples/java/bjc/dicelang/examples/DiceExpressionParserTest.java new file mode 100644 index 0000000..d2f947a --- /dev/null +++ b/dice-lang/src/examples/java/bjc/dicelang/examples/DiceExpressionParserTest.java @@ -0,0 +1,63 @@ +package bjc.dicelang.examples; + +import java.util.HashMap; +import java.util.Scanner; + +import bjc.dicelang.DiceExpressionParser; +import bjc.dicelang.IDiceExpression; + +/** + * Driver class for testing expression parser + * + * @author ben + * + */ +public class DiceExpressionParserTest { + /** + * Run the parser test + * + * @param args + * Unused CLI arguments + */ + public static void main(String[] args) { + /* + * Get a scanner for input + */ + Scanner scn = new Scanner(System.in); + + /* + * Ask to enter a expression + */ + System.out.print("Enter dice expression: "); + + String exp = scn.nextLine(); + + /* + * Enter amount of times to roll an expression + */ + System.out.print("Enter number of times to roll: "); + + int nTimes = Integer.parseInt(scn.nextLine()); + + /* + * Parse the string expression into a dice expression + */ + DiceExpressionParser dep = new DiceExpressionParser(); + + IDiceExpression dexp = dep.parse(exp, new HashMap<>()); + + /* + * Roll the dice a specified amount of times + */ + for (int i = 1; i <= nTimes; i++) { + int roll = dexp.roll(); + + System.out.println("Rolled " + roll); + } + + /* + * Clean up after ourselves + */ + scn.close(); + } +} diff --git a/dice-lang/src/examples/java/bjc/dicelang/examples/DiceLanguageState.java b/dice-lang/src/examples/java/bjc/dicelang/examples/DiceLanguageState.java new file mode 100644 index 0000000..0fb6a0f --- /dev/null +++ b/dice-lang/src/examples/java/bjc/dicelang/examples/DiceLanguageState.java @@ -0,0 +1,36 @@ +package bjc.dicelang.examples; + +import java.util.Map; + +import bjc.dicelang.DiceExpressionParser; +import bjc.dicelang.IDiceExpression; +import bjc.utils.data.Pair; + +/** + * Internal state of dice language + * + * @author ben + * + */ +public class DiceLanguageState + extends Pair<DiceExpressionParser, Map<String, IDiceExpression>> { + + /** + * Create a new state + */ + public DiceLanguageState() { + } + + /** + * Create a new state with the desired parameters + * + * @param left + * The parser to use + * @param right + * The enviroment to use + */ + public DiceLanguageState(DiceExpressionParser left, + Map<String, IDiceExpression> right) { + super(left, right); + } +} diff --git a/dice-lang/src/examples/java/bjc/dicelang/examples/DiceLanguageTest.java b/dice-lang/src/examples/java/bjc/dicelang/examples/DiceLanguageTest.java new file mode 100644 index 0000000..c832d6b --- /dev/null +++ b/dice-lang/src/examples/java/bjc/dicelang/examples/DiceLanguageTest.java @@ -0,0 +1,96 @@ +package bjc.dicelang.examples; + +import java.util.HashMap; +import java.util.Map; +import java.util.Scanner; +import java.util.function.BiConsumer; + +import bjc.dicelang.DiceExpressionParser; +import bjc.dicelang.IDiceExpression; + +/** + * Test of dice language + * + * @author ben + * + */ +public class DiceLanguageTest { + private static Map<String, BiConsumer<String, DiceLanguageState>> acts; + + static { + acts = new HashMap<>(); + + acts.put("roll", DiceLanguageTest::rollReference); + acts.put("env", DiceLanguageTest::printEnv); + } + + /** + * @param ln + * Unused parameter, kept to comply with expected type sig + */ + private static void printEnv(String ln, DiceLanguageState stat) { + System.out.println("Printing enviroment for debugging purposes."); + + stat.doWith((dep, env) -> env.forEach((key, exp) -> System.out + .println("\tKey: " + key + "\tExp: " + exp.toString()))); + } + + private static void rollReference(String ln, DiceLanguageState stat) { + String[] strangs = ln.split(" "); + + System.out.println("\tRolling dice expression " + strangs[1] + " " + + strangs[2] + " times."); + + int nRolls = Integer.parseInt(strangs[2]); + + IDiceExpression dexp = + stat.merge((dep, env) -> env.get(strangs[1])); + + for (int i = 1; i <= nRolls; i++) { + int roll = dexp.roll(); + + System.out.println("\tRolled " + roll); + } + } + + /** + * Main method + * + * @param args + * Unused CLI args + */ + public static void main(String[] args) { + Scanner scn = new Scanner(System.in); + int i = 0; + + System.out.print("dice-lang-" + i + "> "); + String ln = scn.nextLine(); + + DiceExpressionParser dep = new DiceExpressionParser(); + Map<String, IDiceExpression> env = new HashMap<>(); + DiceLanguageState state = new DiceLanguageState(dep, env); + + while (!ln.equalsIgnoreCase("quit")) { + String header = ln.split(" ")[0]; + + if (acts.containsKey(header)) { + acts.get(header).accept(ln, state); + } else { + IDiceExpression exp = dep.parse(ln, env); + + System.out.println("\tParsed: " + exp.toString()); + System.out.println("\tSample Roll: " + exp.roll()); + + env.put("last", exp); + } + + i++; + + System.out.print("dice-lang-" + i + "> "); + ln = scn.nextLine(); + } + + System.out.println("Bye."); + scn.close(); + } +} |