From f2037af115d8459aeaed003bb7c4aa0557a040b9 Mon Sep 17 00:00:00 2001 From: Ben Culkin Date: Wed, 25 Oct 2023 19:33:51 -0400 Subject: Tweak --- .../bjc/pratt/commands/BranchInitialCommand.java | 38 ++++++++++ .../java/bjc/pratt/commands/CommandResult.java | 15 ++++ .../bjc/pratt/commands/impls/InitialCommands.java | 29 +++++++- .../main/java/bjc/pratt/tokens/SimpleToken.java | 60 ++++++++++++++++ .../java/bjc/pratt/tokens/SimpleTokenStream.java | 82 ++++++++++++++++++++++ JPratt/src/main/java/module-info.java | 12 ++++ 6 files changed, 235 insertions(+), 1 deletion(-) create mode 100644 JPratt/src/main/java/bjc/pratt/commands/BranchInitialCommand.java create mode 100644 JPratt/src/main/java/bjc/pratt/tokens/SimpleToken.java create mode 100644 JPratt/src/main/java/bjc/pratt/tokens/SimpleTokenStream.java create mode 100644 JPratt/src/main/java/module-info.java (limited to 'JPratt/src/main') diff --git a/JPratt/src/main/java/bjc/pratt/commands/BranchInitialCommand.java b/JPratt/src/main/java/bjc/pratt/commands/BranchInitialCommand.java new file mode 100644 index 0000000..3f3093e --- /dev/null +++ b/JPratt/src/main/java/bjc/pratt/commands/BranchInitialCommand.java @@ -0,0 +1,38 @@ +package bjc.pratt.commands; + +import java.util.Map; + +import bjc.pratt.ParserContext; +import bjc.pratt.tokens.Token; +import bjc.utils.parserutils.ParserException; + +/** + * Represents a initial command that has a number of 'sub-commands' in the way that Go/Git CLI does. + * + * @author bjcul + * + * @param Token key type + * @param Token value type + * @param Parser context type + */ +public class BranchInitialCommand implements InitialCommand { + private Map> comMap; + + /** + * Create a new branch initial command + * + * @param mep The map containing the commands + */ + public BranchInitialCommand(Map> mep) { + this.comMap = mep; + } + + @Override + public CommandResult denote(Token operator, ParserContext ctx) throws ParserException { + Token curToken = ctx.tokens.current(); + ctx.tokens.expect(comMap.keySet()); + + return comMap.get(curToken.getKey()).denote(curToken, ctx); + } + +} diff --git a/JPratt/src/main/java/bjc/pratt/commands/CommandResult.java b/JPratt/src/main/java/bjc/pratt/commands/CommandResult.java index d27400f..38a55ae 100644 --- a/JPratt/src/main/java/bjc/pratt/commands/CommandResult.java +++ b/JPratt/src/main/java/bjc/pratt/commands/CommandResult.java @@ -94,4 +94,19 @@ public class CommandResult { CommandResult result = new CommandResult<>(Status.BACKTRACK); return result; } + + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + builder.append("CommandResult [status="); + builder.append(status); + if (status == Status.SUCCESS) { + builder.append(", success="); + builder.append(success); + } + builder.append("]"); + return builder.toString(); + } + + } diff --git a/JPratt/src/main/java/bjc/pratt/commands/impls/InitialCommands.java b/JPratt/src/main/java/bjc/pratt/commands/impls/InitialCommands.java index bfc4e4f..6af6954 100644 --- a/JPratt/src/main/java/bjc/pratt/commands/impls/InitialCommands.java +++ b/JPratt/src/main/java/bjc/pratt/commands/impls/InitialCommands.java @@ -7,9 +7,10 @@ import static bjc.pratt.blocks.ParseBlocks.trigger; import java.util.function.UnaryOperator; import bjc.pratt.blocks.ParseBlock; -import bjc.pratt.commands.InitialCommand; +import bjc.pratt.commands.*; import bjc.pratt.tokens.Token; import bjc.data.Tree; +import bjc.functypes.MapBuilder; /** * * Contains factory methods for producing common implementations of @@ -211,4 +212,30 @@ public class InitialCommands { public static InitialCommand panfix(final int precedence, final K term, final Token marker) { return new PanfixCommand<>(marker, term, precedence); } + + /** + * Create a command that unconditionally returns a failure result. + * + * @param Token key type + * @param Token value type + * @param Context type + * + * @return A command that unconditionally fails + */ + public static InitialCommand fail() { + return (operator, ctx) -> CommandResult.fail(); + } + + /** + * Create a new builder for branching/sub-command style commands. + * + * @param Token key type + * @param Value key type + * @param Context type + * + * @return A builder for branching/sub-command style commands + */ + public static MapBuilder, InitialCommand> branch() { + return MapBuilder.from(BranchInitialCommand::new); + } } \ No newline at end of file diff --git a/JPratt/src/main/java/bjc/pratt/tokens/SimpleToken.java b/JPratt/src/main/java/bjc/pratt/tokens/SimpleToken.java new file mode 100644 index 0000000..18e2e5a --- /dev/null +++ b/JPratt/src/main/java/bjc/pratt/tokens/SimpleToken.java @@ -0,0 +1,60 @@ +package bjc.pratt.tokens; + +import java.util.Objects; + +/** + * Simple token implementation + * + * @author bjcul + * + * @param The key type + * @param The value type + * + */ +public class SimpleToken implements Token { + private K key; + private V value; + + /** + * Create a new token + * @param key The key + * @param value The value + */ + public SimpleToken(K key, V value) { + super(); + this.key = key; + this.value = value; + } + + @Override + public K getKey() { + return key; + } + + @Override + public V getValue() { + return value; + } + + @Override + public int hashCode() { + return Objects.hash(key, value); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + SimpleToken other = (SimpleToken) obj; + return Objects.equals(key, other.key) && Objects.equals(value, other.value); + } + + @Override + public String toString() { + return "SimpleToken [key=" + key + ", value=" + value + "]"; + } +} diff --git a/JPratt/src/main/java/bjc/pratt/tokens/SimpleTokenStream.java b/JPratt/src/main/java/bjc/pratt/tokens/SimpleTokenStream.java new file mode 100644 index 0000000..fba38bb --- /dev/null +++ b/JPratt/src/main/java/bjc/pratt/tokens/SimpleTokenStream.java @@ -0,0 +1,82 @@ +package bjc.pratt.tokens; + +import java.util.Iterator; + +import bjc.data.MarkListIterator; + +/** + * Simple token stream implementation + * @author bjcul + * + * @param The key type + * @param The value type + */ +public class SimpleTokenStream extends TokenStream { + private final MarkListIterator> iter; + + private Token curr; + + private Token terminal; + /** + * Create a new token stream from a iterator. + * + * @param itr The iterator to use. + * @param terminal The terminal token to use for end-of-stream + * + */ + public SimpleTokenStream(final Iterator> itr, Token terminal) { + this.iter = new MarkListIterator<>(itr); + this.terminal = terminal; + } + + @Override + public Token current() { + // Prime stream if necessary + if (curr == null) + return next(); + return curr; + } + + @Override + public Token next() { + if (iter.hasNext()) { + curr = iter.next(); + } else { + curr = terminal; + } + + return curr; + } + + @Override + public boolean hasNext() { + return iter.hasNext(); + } + + @Override + public void mark() { + iter.mark(); + } + + @Override + public void commit() { + iter.commit(); + + if (!iter.hasMark()) { + // No marks outstanding; we can release the previous state + iter.reset(); + } + } + + @Override + public void rollback() { + iter.rollback(); + + curr = iter.current(); + } + + @Override + public boolean hasMark() { + return iter.hasMark(); + } +} diff --git a/JPratt/src/main/java/module-info.java b/JPratt/src/main/java/module-info.java new file mode 100644 index 0000000..8bed9b1 --- /dev/null +++ b/JPratt/src/main/java/module-info.java @@ -0,0 +1,12 @@ +module jpratt { + exports bjc.pratt.tokens; + exports bjc.pratt.commands; + exports bjc.pratt.blocks; + exports bjc.pratt.commands.impls; + exports bjc.pratt; + exports bjc.pratt.parsing; + + requires bjc.utils; + requires esodata; + requires junit; +} \ No newline at end of file -- cgit v1.2.3