From 61fd71f69e080790da722e0e03b71ecd7c2538a2 Mon Sep 17 00:00:00 2001 From: bculkin2442 Date: Tue, 10 May 2016 16:02:45 -0400 Subject: General update --- .../utils/parserutils/RuleBasedReaderPragmas.java | 81 ++++++++++++++++++++++ .../java/bjc/utils/parserutils/ShuntingYard.java | 16 ++--- .../bjc/utils/parserutils/TreeConstructor.java | 6 +- 3 files changed, 92 insertions(+), 11 deletions(-) create mode 100644 BJC-Utils2/src/main/java/bjc/utils/parserutils/RuleBasedReaderPragmas.java (limited to 'BJC-Utils2/src/main/java/bjc/utils/parserutils') diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/RuleBasedReaderPragmas.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/RuleBasedReaderPragmas.java new file mode 100644 index 0000000..9d9d1b1 --- /dev/null +++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/RuleBasedReaderPragmas.java @@ -0,0 +1,81 @@ +package bjc.utils.parserutils; + +import java.util.function.BiConsumer; + +import bjc.utils.exceptions.PragmaFormatException; +import bjc.utils.funcdata.FunctionalStringTokenizer; +import bjc.utils.funcutils.ListUtils; + +/** + * Contains factory methods for common pragma types + * + * @author ben + * + */ +public class RuleBasedReaderPragmas { + + /** + * Creates a pragma that takes any number of arguments and collapses + * them all into a single string + * + * @param + * The type of state that goes along with this pragma + * @param name + * The name of this pragma, for error message purpose + * @param consumer + * The function to invoke with the parsed string + * @return A pragma that functions as described above. + */ + public static + BiConsumer + buildStringCollapser(String name, + BiConsumer consumer) { + return (tokenizer, state) -> { + if (!tokenizer.hasMoreTokens()) { + throw new PragmaFormatException("Pragma " + name + + " requires one string argument"); + } + + consumer.accept(ListUtils.collapseTokens( + tokenizer.toList((strang) -> strang)), state); + }; + } + + /** + * Creates a pragma that takes a single integer argument + * + * @param + * The type of state that goes along with this pragma + * @param name + * The name of this pragma, for error message purpose + * @param consumer + * The function to invoke with the parsed integer + * @return A pragma that functions as described above. + */ + public static + BiConsumer buildInteger( + String name, BiConsumer consumer) { + return (tokenizer, state) -> { + if (!tokenizer.hasMoreTokens()) { + throw new PragmaFormatException("Pragma " + name + + " requires one integer argument"); + } + + String token = tokenizer.nextToken(); + + try { + consumer.accept(Integer.parseInt(token), state); + } catch (NumberFormatException nfex) { + PragmaFormatException pfex = + new PragmaFormatException("Argument " + token + + " to version pragma isn't a valid integer. " + + "This pragma requires a integer argument"); + + pfex.initCause(nfex); + + throw pfex; + } + }; + } + +} diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/ShuntingYard.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/ShuntingYard.java index 2ea23c6..8118faa 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/ShuntingYard.java +++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/ShuntingYard.java @@ -7,8 +7,8 @@ import java.util.function.Function; import bjc.utils.funcdata.FunctionalList; import bjc.utils.funcdata.FunctionalMap; -import bjc.utils.funcdata.IFunctionalList; -import bjc.utils.funcdata.IFunctionalMap; +import bjc.utils.funcdata.IList; +import bjc.utils.funcdata.IMap; import bjc.utils.funcutils.StringUtils; /** @@ -63,11 +63,11 @@ public class ShuntingYard { } private final class TokenShunter implements Consumer { - private IFunctionalList output; + private IList output; private Deque stack; private Function transform; - public TokenShunter(IFunctionalList outpt, + public TokenShunter(IList outpt, Deque stack, Function transform) { this.output = outpt; @@ -105,7 +105,7 @@ public class ShuntingYard { /** * Holds all the shuntable operations */ - private IFunctionalMap operators; + private IMap operators; /** * Create a new shunting yard with a default set of operators @@ -176,8 +176,8 @@ public class ShuntingYard { * The function to use to transform strings to tokens * @return A list of tokens in postfix notation */ - public IFunctionalList postfix( - IFunctionalList input, + public IList postfix( + IList input, Function tokenTransformer) { if (input == null) { throw new NullPointerException("Input must not be null"); @@ -185,7 +185,7 @@ public class ShuntingYard { throw new NullPointerException("Transformer must not be null"); } - IFunctionalList output = new FunctionalList<>(); + IList output = new FunctionalList<>(); Deque stack = new LinkedList<>(); diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/TreeConstructor.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/TreeConstructor.java index 283d16e..c703a72 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/TreeConstructor.java +++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/TreeConstructor.java @@ -9,7 +9,7 @@ import bjc.utils.data.IHolder; import bjc.utils.data.IPair; import bjc.utils.data.Identity; import bjc.utils.data.Pair; -import bjc.utils.funcdata.IFunctionalList; +import bjc.utils.funcdata.IList; import bjc.utils.funcdata.ITree; /** @@ -34,7 +34,7 @@ public class TreeConstructor { * @return A AST from the expression */ public static ITree constructTree( - IFunctionalList tokens, + IList tokens, Predicate operatorPredicate) { return constructTree(tokens, operatorPredicate, (op) -> false, null); @@ -65,7 +65,7 @@ public class TreeConstructor { * works */ public static ITree constructTree( - IFunctionalList tokens, + IList tokens, Predicate operatorPredicate, Predicate isSpecialOperator, Function>, ITree>> handleSpecialOperator) { -- cgit v1.2.3