Refactor to add backtracking support

This probably doesn't help w/ error messages, but it enables some cool
ideas where syntax can be reused in cases where it would otherwise be
invalid

1 files changed, 23 insertions, 24 deletions

diff --git a/JPratt/src/main/java/bjc/pratt/commands/impls/TernaryCommand.java b/JPratt/src/main/java/bjc/pratt/commands/impls/TernaryCommand.java
index 174f6fb..786dfec 100644
--- a/JPratt/src/main/java/bjc/pratt/commands/impls/TernaryCommand.java
+++ b/JPratt/src/main/java/bjc/pratt/commands/impls/TernaryCommand.java
@@ -3,6 +3,8 @@ package bjc.pratt.commands.impls;
 import bjc.pratt.ParserContext;
 import bjc.pratt.blocks.ParseBlock;
 import bjc.pratt.commands.BinaryPostCommand;
+import bjc.pratt.commands.CommandResult;
+import bjc.pratt.commands.CommandResult.Status;
 import bjc.pratt.tokens.Token;
 import bjc.data.Tree;
 import bjc.data.SimpleTree;
@@ -13,14 +15,11 @@ import bjc.utils.parserutils.ParserException;
  *
  * @author bjculkin
  *
- * @param <K>
- *        The key type of the tokens.
+ * @param <K> The key type of the tokens.
  *
- * @param <V>
- *        The value type of the tokens.
+ * @param <V> The value type of the tokens.
  *
- * @param <C>
- *        The state type of the parser.
+ * @param <C> The state type of the parser.
  */
 public class TernaryCommand<K, V, C> extends BinaryPostCommand<K, V, C> {
 	private final ParseBlock<K, V, C> innerBlck;
@@ -32,25 +31,22 @@ public class TernaryCommand<K, V, C> extends BinaryPostCommand<K, V, C> {
 	/**
 	 * Create a new ternary command.
 	 *
-	 * @param precedence
-	 *        The precedence of this operator.
+	 * @param precedence The precedence of this operator.
 	 *
-	 * @param innerBlock
-	 *        The representation of the inner block of the expression.
+	 * @param innerBlock The representation of the inner block of the expression.
 	 *
-	 * @param marker
-	 *        The token to use as the root of the AST node.
+	 * @param marker     The token to use as the root of the AST node.
 	 *
-	 * @param isNonassoc
-	 *        Whether or not the conditional is associative.
+	 * @param isNonassoc Whether or not the conditional is associative.
 	 */
 	public TernaryCommand(final int precedence, final ParseBlock<K, V, C> innerBlock, final Token<K, V> marker,
 			final boolean isNonassoc) {
 		super(precedence);
 
-		if(innerBlock == null)
+		if (innerBlock == null)
 			throw new NullPointerException("Inner block must not be null");
-		else if(marker == null) throw new NullPointerException("Marker must not be null");
+		else if (marker == null)
+			throw new NullPointerException("Marker must not be null");
 
 		innerBlck = innerBlock;
 		mark = marker;
@@ -58,19 +54,22 @@ public class TernaryCommand<K, V, C> extends BinaryPostCommand<K, V, C> {
 	}
 
 	@Override
-	public Tree<Token<K, V>> denote(final Tree<Token<K, V>> operand, final Token<K, V> operator,
+	public CommandResult<K, V> denote(final Tree<Token<K, V>> operand, final Token<K, V> operator,
 			final ParserContext<K, V, C> ctx) throws ParserException {
-		final Tree<Token<K, V>> inner = innerBlck.parse(ctx);
-
-		final Tree<Token<K, V>> outer = ctx.parse.parseExpression(1 + leftBinding(), ctx.tokens, ctx.state,
-				false);
-
-		return new SimpleTree<>(mark, inner, operand, outer);
+		final CommandResult<K, V> innerRes = innerBlck.parse(ctx);
+		if (innerRes.status != Status.SUCCESS) return innerRes;
+		Tree<Token<K, V>> inner = innerRes.success();
+		
+		final CommandResult<K,V> outerRes = ctx.parse.parseExpression(1 + leftBinding(), ctx.tokens, ctx.state, false);
+		if (outerRes.status != Status.SUCCESS) return outerRes;
+		Tree<Token<K, V>> outer = outerRes.success();
+		return CommandResult.success(new SimpleTree<>(mark, inner, operand, outer));
 	}
 
 	@Override
 	public int nextBinding() {
-		if(nonassoc) return leftBinding() - 1;
+		if (nonassoc)
+			return leftBinding() - 1;
 
 		return leftBinding();
 	}