Changed terminology to match common use

3 files changed, 163 insertions, 26 deletions

diff --git a/dice-lang/src/examples/java/bjc/dicelang/examples/DiceASTLanguagePragmaHandlers.java b/dice-lang/src/examples/java/bjc/dicelang/examples/DiceASTLanguagePragmaHandlers.java
index cbe060a..420391e 100644
--- a/dice-lang/src/examples/java/bjc/dicelang/examples/DiceASTLanguagePragmaHandlers.java
+++ b/dice-lang/src/examples/java/bjc/dicelang/examples/DiceASTLanguagePragmaHandlers.java
@@ -4,7 +4,7 @@ import java.util.Map;
 import java.util.function.BiConsumer;
 
 import bjc.dicelang.ast.DiceASTExpression;
-import bjc.dicelang.ast.DiceASTFreezer;
+import bjc.dicelang.ast.DiceASTInliner;
 import bjc.dicelang.ast.DiceASTParser;
 import bjc.dicelang.ast.nodes.IDiceASTNode;
 import bjc.utils.funcdata.FunctionalMap;
@@ -18,45 +18,45 @@ import bjc.utils.parserutils.AST;
  */
 public class DiceASTLanguagePragmaHandlers {
 	/**
-	 * Handles freezing a specified expression to a new name
+	 * Handles inlining a specified expression to a new name
 	 * 
 	 * @author ben
 	 *
 	 */
-	public static final class FreezeHandler implements
+	public static final class InlineHandler implements
 			BiConsumer<DiceASTParser, Map<String, DiceASTExpression>> {
-		private String	expressionToFreeze;
+		private String	expressionToInline;
 		private String	resultingVariable;
 
 		/**
-		 * Create a new freeze handler
+		 * Create a new inlining handler
 		 * 
-		 * @param expressionToFreeze
-		 *            The name of the expression to freeze
+		 * @param expressionToInline
+		 *            The name of the expression to inline
 		 * @param resultingVariable
-		 *            The name of the variable to bind the frozen
+		 *            The name of the variable to bind the inline
 		 *            expression to
 		 */
-		public FreezeHandler(String expressionToFreeze,
+		public InlineHandler(String expressionToInline,
 				String resultingVariable) {
-			this.expressionToFreeze = expressionToFreeze;
+			this.expressionToInline = expressionToInline;
 			this.resultingVariable = resultingVariable;
 		}
 
 		@Override
 		public void accept(DiceASTParser astParser,
 				Map<String, DiceASTExpression> enviroment) {
-			if (enviroment.containsKey(expressionToFreeze)) {
+			if (enviroment.containsKey(expressionToInline)) {
 				System.err.println(
 						"ERROR: There is no expression bound to the variable "
-								+ expressionToFreeze + ".");
+								+ expressionToInline + ".");
 			} else {
-				AST<IDiceASTNode> frozenAST = DiceASTFreezer.freezeAST(
-						enviroment.get(expressionToFreeze),
+				AST<IDiceASTNode> inlinedAST = DiceASTInliner.inlineAST(
+						enviroment.get(expressionToInline),
 						new FunctionalMap<>(enviroment));
 
 				enviroment.put(resultingVariable,
-						new DiceASTExpression(frozenAST, enviroment));
+						new DiceASTExpression(inlinedAST, enviroment));
 			}
 		}
 	}
diff --git a/dice-lang/src/examples/java/bjc/dicelang/examples/DiceASTLanguageTest.java b/dice-lang/src/examples/java/bjc/dicelang/examples/DiceASTLanguageTest.java
index 0607329..7bd85af 100644
--- a/dice-lang/src/examples/java/bjc/dicelang/examples/DiceASTLanguageTest.java
+++ b/dice-lang/src/examples/java/bjc/dicelang/examples/DiceASTLanguageTest.java
@@ -8,7 +8,7 @@ import java.util.function.BiConsumer;
 import bjc.dicelang.IDiceExpression;
 import bjc.dicelang.ast.DiceASTDefinedChecker;
 import bjc.dicelang.ast.DiceASTExpression;
-import bjc.dicelang.ast.DiceASTFreezer;
+import bjc.dicelang.ast.DiceASTInliner;
 import bjc.dicelang.ast.DiceASTParser;
 import bjc.dicelang.ast.DiceASTReferenceChecker;
 import bjc.dicelang.ast.nodes.IDiceASTNode;
@@ -40,11 +40,11 @@ public class DiceASTLanguageTest {
 		// Put all the defined special commands in place
 		specialCommands.put("roll", DiceASTLanguageTest::rollReference);
 		specialCommands.put("env", DiceASTLanguageTest::printEnv);
-		specialCommands.put("freeze", DiceASTLanguageTest::freezeVar);
+		specialCommands.put("inline", DiceASTLanguageTest::inlineVariable);
 	}
 
 	/**
-	 * Freeze the references in an expression.
+	 * Inline the references in an expression.
 	 * 
 	 * This means replace variable references with the current contents of
 	 * the variables they refer to
@@ -54,7 +54,7 @@ public class DiceASTLanguageTest {
 	 * @param languageState
 	 *            The state of the language at the moment
 	 */
-	private static void freezeVar(String command,
+	private static void inlineVariable(String command,
 			DiceASTLanguageState languageState) {
 		// Split the string into components
 		String[] args = command.split(" ");
@@ -62,21 +62,21 @@ public class DiceASTLanguageTest {
 		// Make sure we have the correct amount of arguments
 		if (args.length != 3) {
 			System.err.println(
-					"ERROR: Freeze requires you provide the name of expression"
-							+ " to freeze, as well as the name of the variable to bind"
+					"ERROR: Inline requires you provide the name of expression"
+							+ " to inline, as well as the name of the variable to bind"
 							+ " the result to.");
 			return;
 		}
 
-		String expressionToFreeze = args[1];
+		String expressionToInline = args[1];
 
 		String resultingVariable = args[2];
 
-		System.out.println("Freezing references in " + args[1]
+		System.out.println("Inlining references in " + args[1]
 				+ " and binding to " + resultingVariable);
 
 		languageState.doWith(
-				new FreezeHandler(expressionToFreeze, resultingVariable));
+				new InlineHandler(expressionToInline, resultingVariable));
 	}
 
 	/**
@@ -143,6 +143,7 @@ public class DiceASTLanguageTest {
 			System.err.println(
 					"ERROR: There is no expression bound to the variable "
 							+ expressionName + ".");
+			return;
 		}
 
 		for (int i = 1; i <= numberOfRolls; i++) {
@@ -297,8 +298,8 @@ public class DiceASTLanguageTest {
 				new FunctionalMap<>(enviroment)
 						.mapValues((expr) -> expr.getAst());
 
-		AST<IDiceASTNode> expressionSansLast = DiceASTFreezer
-				.selectiveFreeze(builtAST, transformedEnviroment, "last");
+		AST<IDiceASTNode> expressionSansLast = DiceASTInliner
+				.selectiveInline(builtAST, transformedEnviroment, "last");
 
 		return new DiceASTExpression(expressionSansLast, enviroment);
 	}
diff --git a/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTInliner.java b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTInliner.java
new file mode 100644
index 0000000..ef4a904
--- /dev/null
+++ b/dice-lang/src/main/java/bjc/dicelang/ast/DiceASTInliner.java
@@ -0,0 +1,136 @@
+package bjc.dicelang.ast;
+
+import java.util.function.Function;
+
+import bjc.dicelang.ast.nodes.DiceASTType;
+import bjc.dicelang.ast.nodes.IDiceASTNode;
+import bjc.dicelang.ast.nodes.VariableDiceNode;
+import bjc.utils.funcdata.FunctionalList;
+import bjc.utils.funcdata.FunctionalMap;
+import bjc.utils.parserutils.AST;
+
+/**
+ * Inline references in a dice AST, replacing variable references with what
+ * the variables refer to
+ * 
+ * @author ben
+ *
+ */
+public class DiceASTInliner {
+	private static class NodeInliner
+			implements Function<IDiceASTNode, AST<IDiceASTNode>> {
+		private FunctionalMap<String, AST<IDiceASTNode>> enviroment;
+
+		public NodeInliner(FunctionalMap<String, AST<IDiceASTNode>> env) {
+			enviroment = env;
+		}
+
+		@Override
+		public AST<IDiceASTNode> apply(IDiceASTNode nod) {
+			if (nod.getType() == DiceASTType.VARIABLE) {
+				return expandNode((VariableDiceNode) nod);
+			} else {
+				return new AST<>(nod);
+			}
+		}
+
+		protected AST<IDiceASTNode>
+				expandNode(VariableDiceNode variableNode) {
+			String varName = variableNode.getVariable();
+
+			if (!enviroment.containsKey(varName)) {
+				throw new IllegalArgumentException(
+						"Attempted to freeze reference"
+								+ " to an undefined variable " + varName);
+			}
+
+			return enviroment.get(varName);
+		}
+	}
+
+	private static final class SelectiveInliner extends NodeInliner {
+
+		private FunctionalList<String> variableNames;
+
+		public SelectiveInliner(
+				FunctionalMap<String, AST<IDiceASTNode>> env,
+				FunctionalList<String> varNames) {
+			super(env);
+
+			variableNames = varNames;
+		}
+
+		@Override
+		protected AST<IDiceASTNode>
+				expandNode(VariableDiceNode variableNode) {
+			if (variableNames.contains(variableNode.getVariable())) {
+				return super.expandNode(variableNode);
+			} else {
+				return new AST<>(variableNode);
+			}
+		}
+	}
+
+	/**
+	 * Inline the references in an AST
+	 * 
+	 * @param tree
+	 *            The tree to inline references in
+	 * @param env
+	 *            The enviroment to get reference values from
+	 * @return The tree with references inlined
+	 */
+	public static AST<IDiceASTNode> inlineAST(AST<IDiceASTNode> tree,
+			FunctionalMap<String, AST<IDiceASTNode>> env) {
+		return selectiveInline(tree, env);
+	}
+
+	/**
+	 * Inline the references in an expression backed by an AST
+	 * 
+	 * @param tree
+	 *            The tree-backed expression to inline references in
+	 * @param env
+	 *            The enviroment to get reference values from
+	 * @return The tree with references inlined
+	 */
+	public static AST<IDiceASTNode> inlineAST(DiceASTExpression tree,
+			FunctionalMap<String, DiceASTExpression> env) {
+		return inlineAST(tree.getAst(),
+				env.mapValues(expression -> expression.getAst()));
+	}
+
+	/**
+	 * Inline references to specified variables
+	 * 
+	 * @param tree
+	 *            The tree-backed expression to inline references in
+	 * @param env
+	 *            The enviroment to resolve variables against
+	 * @param varNames
+	 *            The names of the variables to inline
+	 * @return An AST with the specified variables inlined
+	 */
+	public static AST<IDiceASTNode> selectiveInline(AST<IDiceASTNode> tree,
+			FunctionalMap<String, AST<IDiceASTNode>> env,
+			String... varNames) {
+		return selectiveInline(tree, env, new FunctionalList<>(varNames));
+	}
+
+	/**
+	 * Inline references to specified variables
+	 * 
+	 * @param tree
+	 *            The tree-backed expression to inline references in
+	 * @param env
+	 *            The enviroment to resolve variables against
+	 * @param varNames
+	 *            The names of the variables to inline
+	 * @return An AST with the specified variables inline
+	 */
+	public static AST<IDiceASTNode> selectiveInline(AST<IDiceASTNode> tree,
+			FunctionalMap<String, AST<IDiceASTNode>> env,
+			FunctionalList<String> varNames) {
+		return tree.expand(new SelectiveInliner(env, varNames));
+	}
+}
\ No newline at end of file