Minor code changes

2 files changed, 104 insertions, 20 deletions

diff --git a/BJC-Utils2/src/examples/java/bjc/utils/examples/parsing/ShuntTester.java b/BJC-Utils2/src/examples/java/bjc/utils/examples/parsing/ShuntTester.java
index 1af5e30..6c1374e 100644
--- a/BJC-Utils2/src/examples/java/bjc/utils/examples/parsing/ShuntTester.java
+++ b/BJC-Utils2/src/examples/java/bjc/utils/examples/parsing/ShuntTester.java
@@ -25,7 +25,7 @@ public class ShuntTester {
 		System.out.print("Enter a expression to shunt: ");
 		String line = inputSource.nextLine();
 
-		ShuntingYard<String> yard = new ShuntingYard<>();
+		ShuntingYard<String> yard = new ShuntingYard<>(true);
 
 		IFunctionalList<String> shuntedTokens =
 				yard.postfix(new FunctionalStringTokenizer(line)
diff --git a/BJC-Utils2/src/examples/java/bjc/utils/examples/parsing/TreeConstructTest.java b/BJC-Utils2/src/examples/java/bjc/utils/examples/parsing/TreeConstructTest.java
index ef081d2..320c4a4 100644
--- a/BJC-Utils2/src/examples/java/bjc/utils/examples/parsing/TreeConstructTest.java
+++ b/BJC-Utils2/src/examples/java/bjc/utils/examples/parsing/TreeConstructTest.java
@@ -1,11 +1,21 @@
 package bjc.utils.examples.parsing;
 
+import java.util.Deque;
+import java.util.LinkedList;
 import java.util.Scanner;
+import java.util.function.Function;
 import java.util.function.Predicate;
 
+import bjc.utils.data.IPair;
+import bjc.utils.data.Pair;
+import bjc.utils.funcdata.FunctionalMap;
 import bjc.utils.funcdata.FunctionalStringTokenizer;
 import bjc.utils.funcdata.IFunctionalList;
+import bjc.utils.funcdata.IFunctionalMap;
 import bjc.utils.funcdata.ITree;
+import bjc.utils.funcdata.Tree;
+import bjc.utils.funcutils.ListUtils;
+import bjc.utils.funcutils.StringUtils;
 import bjc.utils.parserutils.ShuntingYard;
 import bjc.utils.parserutils.TreeConstructor;
 
@@ -16,41 +26,115 @@ import bjc.utils.parserutils.TreeConstructor;
  *
  */
 public class TreeConstructTest {
+	private static final class OperatorPicker
+			implements Predicate<String> {
+		@Override
+		public boolean test(String token) {
+			if (StringUtils.containsOnly(token, "\\[")) {
+				return true;
+			} else if (StringUtils.containsOnly(token, "\\]")) {
+				return true;
+			}
+
+			switch (token) {
+				case "+":
+				case "-":
+				case "*":
+				case "/":
+					return true;
+				default:
+					return false;
+			}
+		}
+	}
+
 	/**
 	 * Main method
 	 * 
 	 * @param args
 	 *            Unused CLI args
 	 */
+	@SuppressWarnings("resource")
 	public static void main(String[] args) {
 		Scanner inputSource = new Scanner(System.in);
 
 		System.out.print("Enter a expression to parse: ");
 		String line = inputSource.nextLine();
 
-		ShuntingYard<String> yard = new ShuntingYard<>();
+		IFunctionalList<String> tokens =
+				new FunctionalStringTokenizer(line).toList();
+
+		ShuntingYard<String> yard = new ShuntingYard<>(true);
+
+		Deque<IPair<String, String>> ops = new LinkedList<>();
+
+		ops.add(new Pair<>("+", "\\+"));
+		ops.add(new Pair<>("-", "-"));
+		ops.add(new Pair<>("*", "\\*"));
+		ops.add(new Pair<>("/", "/"));
+		ops.add(new Pair<>(":=", ":="));
+		ops.add(new Pair<>("=>", "=>"));
+
+		IFunctionalList<String> semiExpandedTokens =
+				ListUtils.splitTokens(tokens, ops);
+
+		ops = new LinkedList<>();
+
+		ops.add(new Pair<>("(", "\\("));
+		ops.add(new Pair<>(")", "\\)"));
+		ops.add(new Pair<>("[", "\\["));
+		ops.add(new Pair<>("]", "\\]"));
+
+		IFunctionalList<String> fullyExpandedTokens =
+				ListUtils.deAffixTokens(semiExpandedTokens, ops);
+
+		fullyExpandedTokens.removeIf((strang) -> strang.equals(""));
 
-		IFunctionalList<String> shuntedTokens = yard
-				.postfix(new FunctionalStringTokenizer(line)
-						.toList((strang) -> strang), (s) -> s);
+		IFunctionalList<String> shuntedTokens =
+				yard.postfix(fullyExpandedTokens, (token) -> token);
 
 		System.out.println("Shunted: " + shuntedTokens.toString());
 
-		ITree<String> constructedTree = TreeConstructor
-				.constructTree(shuntedTokens, new Predicate<String>() {
-					@Override
-					public boolean test(String token) {
-						switch (token) {
-							case "+":
-							case "-":
-							case "*":
-							case "/":
-								return true;
-							default:
-								return false;
-						}
-					}
-				}, (operator) -> false, null);
+		Predicate<String> specialPicker = (operator) -> {
+			if (StringUtils.containsOnly(operator, "\\[")) {
+				return true;
+			} else if (StringUtils.containsOnly(operator, "\\]")) {
+				return true;
+			}
+
+			return false;
+		};
+
+		IFunctionalMap<String, Function<Deque<ITree<String>>, ITree<String>>> operators =
+				new FunctionalMap<>();
+
+		operators.put("[", (queuedTrees) -> {
+			return null;
+		});
+
+		operators.put("[", (queuedTrees) -> {
+			Tree<String> openTree = new Tree<>("[");
+
+			queuedTrees.push(openTree);
+
+			return openTree;
+		});
+
+		operators.put("]", (queuedTrees) -> {
+			ITree<String> arrayTree = new Tree<>("[]");
+
+			while (!queuedTrees.peek().getHead().equals("[")) {
+				arrayTree.addChild(queuedTrees.pop());
+			}
+
+			queuedTrees.push(arrayTree);
+
+			return arrayTree;
+		});
+
+		ITree<String> constructedTree = TreeConstructor.constructTree(
+				shuntedTokens, new OperatorPicker(), specialPicker,
+				operators::get);
 
 		System.out.println("AST: " + constructedTree.toString());