From 15a2b29e48f134bc93cfd0a3d8512001e9242f3d Mon Sep 17 00:00:00 2001 From: Benjamin Culkin Date: Mon, 3 Jun 2024 17:33:53 -0400 Subject: Rename package to new domain Rename the package to the new domain --- .../pratt/commands/AbstractInitialCommand.java | 45 ++++ .../ashardalon/pratt/commands/BinaryCommand.java | 55 +++++ .../pratt/commands/BinaryPostCommand.java | 36 +++ .../pratt/commands/BranchInitialCommand.java | 39 ++++ .../ashardalon/pratt/commands/CommandResult.java | 113 ++++++++++ .../ashardalon/pratt/commands/InitialCommand.java | 40 ++++ .../pratt/commands/MetaInitialCommand.java | 27 +++ .../pratt/commands/MetaNonInitialCommand.java | 28 +++ .../pratt/commands/NonInitialCommand.java | 66 ++++++ .../pratt/commands/impls/BlockInitialCommand.java | 43 ++++ .../pratt/commands/impls/ChainCommand.java | 83 +++++++ .../pratt/commands/impls/ConstantCommand.java | 43 ++++ .../commands/impls/DefaultInitialCommand.java | 30 +++ .../commands/impls/DefaultNonInitialCommand.java | 35 +++ .../pratt/commands/impls/DenestingCommand.java | 50 +++++ .../pratt/commands/impls/GroupingCommand.java | 55 +++++ .../pratt/commands/impls/InitialCommands.java | 242 +++++++++++++++++++++ .../pratt/commands/impls/LeafCommand.java | 31 +++ .../pratt/commands/impls/LeftBinaryCommand.java | 34 +++ .../pratt/commands/impls/NonBinaryCommand.java | 39 ++++ .../pratt/commands/impls/NonInitialCommands.java | 167 ++++++++++++++ .../pratt/commands/impls/PanfixCommand.java | 55 +++++ .../pratt/commands/impls/PostCircumfixCommand.java | 64 ++++++ .../pratt/commands/impls/PostfixCommand.java | 43 ++++ .../pratt/commands/impls/PreTernaryCommand.java | 85 ++++++++ .../pratt/commands/impls/RightBinaryCommand.java | 32 +++ .../pratt/commands/impls/TernaryCommand.java | 78 +++++++ .../commands/impls/TransformingInitialCommand.java | 59 +++++ .../pratt/commands/impls/UnaryCommand.java | 52 +++++ 29 files changed, 1769 insertions(+) create mode 100644 JPratt/src/main/java/com/ashardalon/pratt/commands/AbstractInitialCommand.java create mode 100644 JPratt/src/main/java/com/ashardalon/pratt/commands/BinaryCommand.java create mode 100644 JPratt/src/main/java/com/ashardalon/pratt/commands/BinaryPostCommand.java create mode 100644 JPratt/src/main/java/com/ashardalon/pratt/commands/BranchInitialCommand.java create mode 100644 JPratt/src/main/java/com/ashardalon/pratt/commands/CommandResult.java create mode 100644 JPratt/src/main/java/com/ashardalon/pratt/commands/InitialCommand.java create mode 100644 JPratt/src/main/java/com/ashardalon/pratt/commands/MetaInitialCommand.java create mode 100644 JPratt/src/main/java/com/ashardalon/pratt/commands/MetaNonInitialCommand.java create mode 100644 JPratt/src/main/java/com/ashardalon/pratt/commands/NonInitialCommand.java create mode 100644 JPratt/src/main/java/com/ashardalon/pratt/commands/impls/BlockInitialCommand.java create mode 100644 JPratt/src/main/java/com/ashardalon/pratt/commands/impls/ChainCommand.java create mode 100644 JPratt/src/main/java/com/ashardalon/pratt/commands/impls/ConstantCommand.java create mode 100644 JPratt/src/main/java/com/ashardalon/pratt/commands/impls/DefaultInitialCommand.java create mode 100644 JPratt/src/main/java/com/ashardalon/pratt/commands/impls/DefaultNonInitialCommand.java create mode 100644 JPratt/src/main/java/com/ashardalon/pratt/commands/impls/DenestingCommand.java create mode 100644 JPratt/src/main/java/com/ashardalon/pratt/commands/impls/GroupingCommand.java create mode 100644 JPratt/src/main/java/com/ashardalon/pratt/commands/impls/InitialCommands.java create mode 100644 JPratt/src/main/java/com/ashardalon/pratt/commands/impls/LeafCommand.java create mode 100644 JPratt/src/main/java/com/ashardalon/pratt/commands/impls/LeftBinaryCommand.java create mode 100644 JPratt/src/main/java/com/ashardalon/pratt/commands/impls/NonBinaryCommand.java create mode 100644 JPratt/src/main/java/com/ashardalon/pratt/commands/impls/NonInitialCommands.java create mode 100644 JPratt/src/main/java/com/ashardalon/pratt/commands/impls/PanfixCommand.java create mode 100644 JPratt/src/main/java/com/ashardalon/pratt/commands/impls/PostCircumfixCommand.java create mode 100644 JPratt/src/main/java/com/ashardalon/pratt/commands/impls/PostfixCommand.java create mode 100644 JPratt/src/main/java/com/ashardalon/pratt/commands/impls/PreTernaryCommand.java create mode 100644 JPratt/src/main/java/com/ashardalon/pratt/commands/impls/RightBinaryCommand.java create mode 100644 JPratt/src/main/java/com/ashardalon/pratt/commands/impls/TernaryCommand.java create mode 100644 JPratt/src/main/java/com/ashardalon/pratt/commands/impls/TransformingInitialCommand.java create mode 100644 JPratt/src/main/java/com/ashardalon/pratt/commands/impls/UnaryCommand.java (limited to 'JPratt/src/main/java/com/ashardalon/pratt/commands') diff --git a/JPratt/src/main/java/com/ashardalon/pratt/commands/AbstractInitialCommand.java b/JPratt/src/main/java/com/ashardalon/pratt/commands/AbstractInitialCommand.java new file mode 100644 index 0000000..c38aa9b --- /dev/null +++ b/JPratt/src/main/java/com/ashardalon/pratt/commands/AbstractInitialCommand.java @@ -0,0 +1,45 @@ +package com.ashardalon.pratt.commands; + +import com.ashardalon.pratt.ParserContext; +import com.ashardalon.pratt.tokens.Token; + +import bjc.utils.parserutils.ParserException; + +/** + * Abstract base for initial commands. + * + * @author bjculkin + * + * @param + * The key type of the tokens. + * + * @param + * The value type of the tokens. + * + * @param + * The state type of the parser. + */ +public abstract class AbstractInitialCommand implements InitialCommand { + @Override + public CommandResult denote(final Token operator, + final ParserContext ctx) throws ParserException { + return intNullDenotation(operator, ctx); + } + + /** + * Internal null denotation method. + * + * @param operator + * The operator that was parsed. + * @param ctx + * The parser context at this point. + * + * @return The tree that this method parsed. + * + * @throws ParserException + * If something went wrong while parsing. + */ + protected abstract CommandResult intNullDenotation(Token operator, + ParserContext ctx) throws ParserException; + +} \ No newline at end of file diff --git a/JPratt/src/main/java/com/ashardalon/pratt/commands/BinaryCommand.java b/JPratt/src/main/java/com/ashardalon/pratt/commands/BinaryCommand.java new file mode 100644 index 0000000..739cb44 --- /dev/null +++ b/JPratt/src/main/java/com/ashardalon/pratt/commands/BinaryCommand.java @@ -0,0 +1,55 @@ +package com.ashardalon.pratt.commands; + +import bjc.data.Tree; + +import com.ashardalon.pratt.ParserContext; +import com.ashardalon.pratt.commands.CommandResult.Status; +import com.ashardalon.pratt.tokens.Token; + +import bjc.data.SimpleTree; +import bjc.utils.parserutils.ParserException; + +/** + * A binary operator. + * + * @author bjculkin + * + * @param + * The key type of the tokens. + * + * @param + * The value type of the tokens. + * + * @param + * The state type of the parser. + */ +public abstract class BinaryCommand extends BinaryPostCommand { + /** + * Create a new binary operator with the specified precedence. + * + * @param precedence + * The precedence of the operator. + */ + public BinaryCommand(final int precedence) { + super(precedence); + } + + /** + * The right-binding power (right-precedence) of this command. + * + * @return The right binding power of this command. + */ + protected abstract int rightBinding(); + + @Override + public CommandResult denote(final Tree> operand, + final Token operator, final ParserContext ctx) + throws ParserException { + final CommandResult opr + = ctx.parse.parseExpression(rightBinding(), ctx.tokens, ctx.state, false); + + if (opr.status != Status.SUCCESS) return opr; + + return CommandResult.success(new SimpleTree<>(operator, operand, opr.success())); + } +} \ No newline at end of file diff --git a/JPratt/src/main/java/com/ashardalon/pratt/commands/BinaryPostCommand.java b/JPratt/src/main/java/com/ashardalon/pratt/commands/BinaryPostCommand.java new file mode 100644 index 0000000..bacab23 --- /dev/null +++ b/JPratt/src/main/java/com/ashardalon/pratt/commands/BinaryPostCommand.java @@ -0,0 +1,36 @@ +package com.ashardalon.pratt.commands; + +/** + * A operator with fixed precedence. + * + * @author bjculkin + * + * @param + * The key type of the tokens. + * + * @param + * The value type of the tokens. + * + * @param + * The state type of the parser. + */ +public abstract class BinaryPostCommand extends NonInitialCommand { + private final int leftPower; + + /** + * Create a new operator with fixed precedence. + * + * @param precedence + * The precedence of the operator. + */ + public BinaryPostCommand(final int precedence) { + if(precedence < 0) throw new IllegalArgumentException("Precedence must be non-negative"); + + leftPower = precedence; + } + + @Override + public int leftBinding() { + return leftPower; + } +} \ No newline at end of file diff --git a/JPratt/src/main/java/com/ashardalon/pratt/commands/BranchInitialCommand.java b/JPratt/src/main/java/com/ashardalon/pratt/commands/BranchInitialCommand.java new file mode 100644 index 0000000..0e17287 --- /dev/null +++ b/JPratt/src/main/java/com/ashardalon/pratt/commands/BranchInitialCommand.java @@ -0,0 +1,39 @@ +package com.ashardalon.pratt.commands; + +import java.util.Map; + +import com.ashardalon.pratt.ParserContext; +import com.ashardalon.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/com/ashardalon/pratt/commands/CommandResult.java b/JPratt/src/main/java/com/ashardalon/pratt/commands/CommandResult.java new file mode 100644 index 0000000..45c1788 --- /dev/null +++ b/JPratt/src/main/java/com/ashardalon/pratt/commands/CommandResult.java @@ -0,0 +1,113 @@ +package com.ashardalon.pratt.commands; + +import com.ashardalon.pratt.tokens.Token; + +import bjc.data.Tree; + +/** + * Represents the result of executing a command. + * + * @author bjcul + * + * @param The key type of the tokens + * @param The value type of the tokens + */ +public class CommandResult { + /** + * Represents the status of a command execution + * + * @author bjcul + * + */ + public static enum Status { + /** + * The command successfully parsed. + */ + SUCCESS, + /** + * The command failed, in a non-recoverable way + */ + FAIL, + /** + * The command failed. Attempt recovery via backtracking + */ + BACKTRACK + } + + /** + * The status of this command. + */ + public final Status status; + + private Tree> success; + + private CommandResult(Status status) { + this.status = status; + } + + /** + * Get the success value of this command, or null if it failed. + * + * @return The success value of the command + */ + public Tree> success() { + return success; + } + + /** + * Create a success result + * + * @param The key type of the token + * @param The value type of the token + * + * @param succ The tree produced by the command + * + * @return A command result representing a success + */ + public static CommandResult success(Tree> succ) { + CommandResult result = new CommandResult<>(Status.SUCCESS); + result.success = succ; + return result; + } + + /** + * Create a non-backtracking failure result. + * + * @param The key type of the token + * @param The value type of the token + * + * @return A command result representing a non-backtracking fail + */ + public static CommandResult fail() { + CommandResult result = new CommandResult<>(Status.FAIL); + return result; + } + + /** + * Create a backtracking failure result. + * + * @param The key type of the token + * @param The value type of the token + * + * @return A command result representing a backtracking fail + */ + public static CommandResult backtrack() { + 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/com/ashardalon/pratt/commands/InitialCommand.java b/JPratt/src/main/java/com/ashardalon/pratt/commands/InitialCommand.java new file mode 100644 index 0000000..3b613a3 --- /dev/null +++ b/JPratt/src/main/java/com/ashardalon/pratt/commands/InitialCommand.java @@ -0,0 +1,40 @@ +package com.ashardalon.pratt.commands; + +import com.ashardalon.pratt.ParserContext; +import com.ashardalon.pratt.tokens.Token; + +import bjc.utils.parserutils.ParserException; + +/** + * Represents an initial command in parsing. + * + * @author EVE + * + * @param + * The key type for the tokens. + * + * @param + * The value type for the tokens. + * + * @param + * The state type of the parser. + * + * + */ +@FunctionalInterface +public interface InitialCommand { + /** + * Construct the null denotation of this command. + * + * @param operator + * The operator for this command. + * @param ctx + * The context for the command. + * + * @return The result of executing the command. + * + * @throws ParserException + * If something goes wrong during parsing. + */ + CommandResult denote(Token operator, ParserContext ctx) throws ParserException; +} diff --git a/JPratt/src/main/java/com/ashardalon/pratt/commands/MetaInitialCommand.java b/JPratt/src/main/java/com/ashardalon/pratt/commands/MetaInitialCommand.java new file mode 100644 index 0000000..7b9aae0 --- /dev/null +++ b/JPratt/src/main/java/com/ashardalon/pratt/commands/MetaInitialCommand.java @@ -0,0 +1,27 @@ +package com.ashardalon.pratt.commands; + +import com.ashardalon.pratt.ParserContext; + +/** + * A 'meta-command' that yields the actual command to use. + * + * @author bjculkin + * + * @param + * The key type of the context. + * @param + * The value type of the context. + * @param + * The storage type of the context. + * + */ +public interface MetaInitialCommand { + /** + * Get the command to use. + * + * @param ctx + * The current parser context. + * @return The command to use. + */ + InitialCommand getCommand(ParserContext ctx); +} diff --git a/JPratt/src/main/java/com/ashardalon/pratt/commands/MetaNonInitialCommand.java b/JPratt/src/main/java/com/ashardalon/pratt/commands/MetaNonInitialCommand.java new file mode 100644 index 0000000..4aa5120 --- /dev/null +++ b/JPratt/src/main/java/com/ashardalon/pratt/commands/MetaNonInitialCommand.java @@ -0,0 +1,28 @@ +package com.ashardalon.pratt.commands; + +import com.ashardalon.pratt.ParserContext; + +/** + * A 'meta-command' for non-initial commands. + * + * @author bjculkin + * + * @param + * The token key type. + * + * @param + * The token value type. + * + * @param + * The parser state type. + */ +public interface MetaNonInitialCommand { + /** + * Get the command to use. + * + * @param ctx + * The context to use. + * @return The command to use. + */ + NonInitialCommand getCommand(ParserContext ctx); +} diff --git a/JPratt/src/main/java/com/ashardalon/pratt/commands/NonInitialCommand.java b/JPratt/src/main/java/com/ashardalon/pratt/commands/NonInitialCommand.java new file mode 100644 index 0000000..a521e5c --- /dev/null +++ b/JPratt/src/main/java/com/ashardalon/pratt/commands/NonInitialCommand.java @@ -0,0 +1,66 @@ +package com.ashardalon.pratt.commands; + +import com.ashardalon.pratt.ParserContext; +import com.ashardalon.pratt.tokens.Token; + +import bjc.data.Tree; +import bjc.utils.parserutils.ParserException; + +/** + * Represents a non-initial command in parsing. + * + * @author EVE + * + * @param + * The key type for the tokens. + * + * @param + * The value type for the tokens. + * + * @param + * The state type of the parser. + * + */ +public abstract class NonInitialCommand { + /** + * Construct the left denotation of this command. + * + * @param operand + * The left-hand operand of this command. + * @param operator + * The operator for this command. + * + * @param ctx + * The state needed for commands. + * + * @return The result of executing the command. + * + * @throws ParserException + * If something went wrong during parsing. + */ + public abstract CommandResult denote(Tree> operand, Token operator, + ParserContext ctx) throws ParserException; + + /** + * Get the left-binding power of this command. + * + * This represents the general precedence of this command. + * + * @return The left-binding power of this command. + */ + public abstract int leftBinding(); + + /** + * Get the next-binding power of this command. + * + * This represents the highest precedence of command this command can be + * the left operand of. + * + * This is the same as the left-binding power by default. + * + * @return The next-binding power of this command. + */ + public int nextBinding() { + return leftBinding(); + } +} diff --git a/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/BlockInitialCommand.java b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/BlockInitialCommand.java new file mode 100644 index 0000000..612167a --- /dev/null +++ b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/BlockInitialCommand.java @@ -0,0 +1,43 @@ +package com.ashardalon.pratt.commands.impls; + +import com.ashardalon.pratt.ParserContext; +import com.ashardalon.pratt.blocks.ParseBlock; +import com.ashardalon.pratt.commands.AbstractInitialCommand; +import com.ashardalon.pratt.commands.CommandResult; +import com.ashardalon.pratt.tokens.Token; + +import bjc.utils.parserutils.ParserException; + +/** + * An initial command that delegates all the work to a {@link ParseBlock} + * + * @author bjculkin + * @param + * The token key type. + * + * @param + * The token value type. + * + * @param + * The parser state type. + * + */ +public class BlockInitialCommand extends AbstractInitialCommand { + private final ParseBlock blck; + + /** + * Create a new block initial command. + * + * @param block + * The block to delegate to. + */ + public BlockInitialCommand(final ParseBlock block) { + blck = block; + } + + @Override + protected CommandResult intNullDenotation(final Token operator, final ParserContext ctx) + throws ParserException { + return blck.parse(ctx); + } +} \ No newline at end of file diff --git a/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/ChainCommand.java b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/ChainCommand.java new file mode 100644 index 0000000..5ba84ef --- /dev/null +++ b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/ChainCommand.java @@ -0,0 +1,83 @@ +package com.ashardalon.pratt.commands.impls; + +import java.util.Set; + +import com.ashardalon.pratt.ParserContext; +import com.ashardalon.pratt.commands.BinaryPostCommand; +import com.ashardalon.pratt.commands.CommandResult; +import com.ashardalon.pratt.commands.CommandResult.Status; +import com.ashardalon.pratt.tokens.Token; + +import bjc.data.Tree; +import bjc.data.SimpleTree; +import bjc.utils.parserutils.ParserException; + +/** + * Create a new chained operator. + * + * @author bjculkin + * + * @param + * The key type of the tokens. + * + * @param + * The value type of the tokens. + * + * @param + * The state type of the parser. + */ +public class ChainCommand extends BinaryPostCommand { + private final Set chainWith; + + private final Token chain; + + /** + * Create a new chained operator. + * + * @param precedence + * The precedence of this operator. + * + * @param chainSet + * The operators to chain with. + * + * @param chainMarker + * The token to use as the node in the AST. + */ + public ChainCommand(final int precedence, final Set chainSet, final Token chainMarker) { + super(precedence); + + chainWith = chainSet; + chain = chainMarker; + } + + @Override + public CommandResult denote(final Tree> operand, final Token operator, + final ParserContext ctx) throws ParserException { + CommandResult resOuter = ctx.parse.parseExpression(1 + leftBinding(), ctx.tokens, ctx.state, + false); + if (resOuter.status != Status.SUCCESS) return resOuter; + final Tree> tree = resOuter.success(); + + final Tree> res = new SimpleTree<>(operator, operand, tree); + + if(chainWith.contains(ctx.tokens.current().getKey())) { + final Token tok = ctx.tokens.current(); + ctx.tokens.next(); + + CommandResult resOther = denote(tree, tok, + new ParserContext<>(ctx.tokens, ctx.parse, ctx.state)); + if (resOther.status != Status.SUCCESS) return resOther; + + final Tree> other = resOther.success(); + + return CommandResult.success(new SimpleTree<>(chain, res, other)); + } + + return CommandResult.success(res); + } + + @Override + public int nextBinding() { + return leftBinding() - 1; + } +} \ No newline at end of file diff --git a/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/ConstantCommand.java b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/ConstantCommand.java new file mode 100644 index 0000000..dd80205 --- /dev/null +++ b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/ConstantCommand.java @@ -0,0 +1,43 @@ +package com.ashardalon.pratt.commands.impls; + +import com.ashardalon.pratt.ParserContext; +import com.ashardalon.pratt.commands.CommandResult; +import com.ashardalon.pratt.commands.InitialCommand; +import com.ashardalon.pratt.tokens.Token; + +import bjc.data.Tree; +import bjc.utils.parserutils.ParserException; + +/** + * A command that represents a specific tree. + * + * @author bjculkin + * + * @param + * The key type of the tokens. + * + * @param + * The value type of the tokens. + * + * @param + * The state type of the parser. + */ +public class ConstantCommand implements InitialCommand { + private final Tree> val; + + /** + * Create a new constant. + * + * @param con + * The tree this constant represents. + */ + public ConstantCommand(final Tree> con) { + val = con; + } + + @Override + public CommandResult denote(final Token operator, final ParserContext ctx) + throws ParserException { + return CommandResult.success(val); + } +} \ No newline at end of file diff --git a/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/DefaultInitialCommand.java b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/DefaultInitialCommand.java new file mode 100644 index 0000000..1c218c9 --- /dev/null +++ b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/DefaultInitialCommand.java @@ -0,0 +1,30 @@ +package com.ashardalon.pratt.commands.impls; + +import com.ashardalon.pratt.ParserContext; +import com.ashardalon.pratt.commands.CommandResult; +import com.ashardalon.pratt.commands.InitialCommand; +import com.ashardalon.pratt.tokens.Token; + +import bjc.utils.parserutils.ParserException; + +/** + * Default implementation of an initial command. + * + * @author EVE + * + * @param + * The key type of the token. + * + * @param + * The value type of the token. + * + * @param + * The state type of the parser. + */ +public class DefaultInitialCommand implements InitialCommand { + @Override + public CommandResult denote(final Token operator, final ParserContext ctx) + throws ParserException { + throw new ParserException("Unexpected token " + operator); + } +} diff --git a/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/DefaultNonInitialCommand.java b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/DefaultNonInitialCommand.java new file mode 100644 index 0000000..8666713 --- /dev/null +++ b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/DefaultNonInitialCommand.java @@ -0,0 +1,35 @@ +package com.ashardalon.pratt.commands.impls; + +import com.ashardalon.pratt.ParserContext; +import com.ashardalon.pratt.commands.CommandResult; +import com.ashardalon.pratt.commands.NonInitialCommand; +import com.ashardalon.pratt.tokens.Token; + +import bjc.data.Tree; + +/** + * Default implementation of a non-initial command. + * + * @author EVE + * + * @param + * The key type of the tokens. + * + * @param + * The value type of the tokens. + * + * @param + * The state type of the parser. + */ +public class DefaultNonInitialCommand extends NonInitialCommand { + @Override + public CommandResult denote(final Tree> operand, final Token operator, + final ParserContext ctx) { + throw new UnsupportedOperationException("Default command has no left denotation"); + } + + @Override + public int leftBinding() { + return -1; + } +} diff --git a/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/DenestingCommand.java b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/DenestingCommand.java new file mode 100644 index 0000000..438101e --- /dev/null +++ b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/DenestingCommand.java @@ -0,0 +1,50 @@ +package com.ashardalon.pratt.commands.impls; + +import com.ashardalon.pratt.ParserContext; +import com.ashardalon.pratt.commands.AbstractInitialCommand; +import com.ashardalon.pratt.commands.CommandResult; +import com.ashardalon.pratt.commands.InitialCommand; +import com.ashardalon.pratt.commands.CommandResult.Status; +import com.ashardalon.pratt.tokens.Token; + +import bjc.utils.parserutils.ParserException; + +/** + * A command that denests a input tree. + * + * Useful for processing the result of passing a complex parse group to a + * command. + * + * @author bjculkin + * + * @param + * The key type of the tokens. + * + * @param + * The value type of the tokens. + * + * @param + * The state type of the parser. + * + */ +public class DenestingCommand extends AbstractInitialCommand { + private final InitialCommand wrapped; + + /** + * Create a new transforming initial command. + * + * @param internal + * The initial command to delegate to. + */ + public DenestingCommand(final InitialCommand internal) { + wrapped = internal; + } + + @Override + protected CommandResult intNullDenotation(final Token operator, final ParserContext ctx) + throws ParserException { + CommandResult res = wrapped.denote(operator, ctx); + if (res.status != Status.SUCCESS) return res; + return CommandResult.success(res.success().getChild(0)); + } +} \ No newline at end of file diff --git a/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/GroupingCommand.java b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/GroupingCommand.java new file mode 100644 index 0000000..284c1e9 --- /dev/null +++ b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/GroupingCommand.java @@ -0,0 +1,55 @@ +package com.ashardalon.pratt.commands.impls; + +import bjc.data.Tree; + +import com.ashardalon.pratt.ParserContext; +import com.ashardalon.pratt.blocks.ParseBlock; +import com.ashardalon.pratt.commands.AbstractInitialCommand; +import com.ashardalon.pratt.commands.CommandResult; +import com.ashardalon.pratt.tokens.Token; + +import bjc.data.SimpleTree; +import bjc.utils.parserutils.ParserException; + +/** + * A grouping operator. + * + * @author bjculkin + * + * @param + * The key type of the tokens. + * + * @param + * The value type of the tokens. + * + * @param + * The state type of the parser. + */ +public class GroupingCommand extends AbstractInitialCommand { + private final ParseBlock innerBlock; + + private final Token mark; + + /** + * Create a new grouping command. + * + * @param inner + * The inner block. + * + * @param marker + * The token to use as the node in the AST. + */ + public GroupingCommand(final ParseBlock inner, final Token marker) { + innerBlock = inner; + + mark = marker; + } + + @Override + protected CommandResult intNullDenotation(final Token operator, final ParserContext ctx) + throws ParserException { + final CommandResult resOpr = innerBlock.parse(ctx); + Tree> opr = resOpr.success(); + return CommandResult.success(new SimpleTree<>(mark, opr)); + } +} \ No newline at end of file diff --git a/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/InitialCommands.java b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/InitialCommands.java new file mode 100644 index 0000000..f4b0bbe --- /dev/null +++ b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/InitialCommands.java @@ -0,0 +1,242 @@ +package com.ashardalon.pratt.commands.impls; + +import static com.ashardalon.pratt.blocks.ParseBlocks.repeating; +import static com.ashardalon.pratt.blocks.ParseBlocks.simple; +import static com.ashardalon.pratt.blocks.ParseBlocks.trigger; + +import java.util.function.UnaryOperator; + +import com.ashardalon.pratt.blocks.ParseBlock; +import com.ashardalon.pratt.commands.*; +import com.ashardalon.pratt.tokens.Token; + +import bjc.data.Tree; +import bjc.functypes.MapBuilder; + +/** + * * Contains factory methods for producing common implementations of + * {@link InitialCommand} + * + * @author EVE + * + */ +public class InitialCommands { + /** + * Create a new unary operator. + * + * @param The key type for the tokens. + * @param The value type for the tokens. + * @param The context type for the tokens. + * + * @param precedence + * The precedence of the operator. + * + * @return A command implementing that operator. + */ + public static InitialCommand unary(final int precedence) { + return new UnaryCommand<>(precedence); + } + + /** + * Create a new grouping operator. + * + * @param The key type for the tokens. + * @param The value type for the tokens. + * @param The context type for the tokens. + * + * @param precedence + * The precedence of the expression in the operator. + * + * @param term + * The type that closes the group. + * + * @param mark + * The token for the AST node of the group. + * + * @return A command implementing the operator. + */ + public static InitialCommand grouping(final int precedence, final K term, + final Token mark) { + final ParseBlock innerBlock = simple(precedence, term, null); + + return new GroupingCommand<>(innerBlock, mark); + } + + /** + * Create a new leaf operator. + * + * @param The key type for the tokens. + * @param The value type for the tokens. + * @param The context type for the tokens. + * + * @return A command implementing the operator. + */ + public static InitialCommand leaf() { + return new LeafCommand<>(); + } + + /** + * Create a new pre-ternary operator, like an if-then-else statement. + * + * @param The key type for the tokens. + * @param The value type for the tokens. + * @param The context type for the tokens. + * + * @param cond1 + * The priority of the first block. + * + * @param block1 + * The priority of the second block. + * + * @param block2 + * The priority of the third block. + * + * @param mark1 + * The marker that ends the first block. + * + * @param mark2 + * The marker that ends the second block. + * + * @param term + * The token for the AST node of the group. + * + * @return A command implementing the operator. + */ + public static InitialCommand preTernary(final int cond1, final int block1, final int block2, + final K mark1, final K mark2, final Token term) { + final ParseBlock condBlock = simple(cond1, mark1, null); + final ParseBlock opblock1 = simple(block1, mark2, null); + final ParseBlock opblock2 = simple(block2, null, null); + + return new PreTernaryCommand<>(condBlock, opblock1, opblock2, term); + } + + /** + * Create a new named constant. + * + * @param The key type for the tokens. + * @param The value type for the tokens. + * @param The context type for the tokens. + * + * @param val + * The value of the constant. + * + * @return A command implementing the constant. + */ + public static InitialCommand constant(final Tree> val) { + return new ConstantCommand<>(val); + } + + /** + * Create a new delimited command. This is for block-like constructs. + * + * @param The key type for the tokens. + * @param The value type for the tokens. + * @param The context type for the tokens. + * + * @param inner + * The precedence of the inner blocks. + * + * @param delim + * The marker between sub-blocks. + * + * @param mark + * The block terminator. + * + * @param term + * The token for the AST node of the group. + * + * @param onEnter + * The function to apply to the state on entering the block. + * + * @param onDelim + * The function to apply to the state on finishing a sub-block. + * + * @param onExit + * The function to apply to the state on exiting the block. + * + * @param statement + * Whether or not the sub-blocks are statements or expressions. + * + * @return A command implementing the operator. + */ + public static InitialCommand delimited(final int inner, final K delim, final K mark, + final Token term, final UnaryOperator onEnter, final UnaryOperator onDelim, + final UnaryOperator onExit, final boolean statement) { + final ParseBlock innerBlock = simple(inner, null, null); + final ParseBlock delimsBlock = repeating(innerBlock, delim, mark, term, onDelim); + final ParseBlock scopedBlock = trigger(delimsBlock, onEnter, onExit); + + final GroupingCommand command = new GroupingCommand<>(scopedBlock, term); + + /* + * Remove the wrapper layer from grouping-command on top of + * RepeatingParseBlock. + */ + return denest(command); + } + + /** + * Create a new denesting command. + * + * This removes one tree-level, and is useful when combining complex + * parse blocks with commands. + * + * @param The key type for the tokens. + * @param The value type for the tokens. + * @param The context type for the tokens. + * + * @param comm + * The command to denest. + * + * @return A command that denests the result of the provided command. + */ + public static InitialCommand denest(final InitialCommand comm) { + return new DenestingCommand<>(comm); + } + + /** + * Create a new 'panfix' command. + * + * Form is + * + * @param The key type for the tokens. + * @param The value type for the tokens. + * @param The context type for the tokens. + * + * @param precedence The precedence for this operator + * @param term The indicator for the operator + * @param marker The token to mark this tree + * + * @return A command that implements a panfix operator + */ + 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/com/ashardalon/pratt/commands/impls/LeafCommand.java b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/LeafCommand.java new file mode 100644 index 0000000..886a377 --- /dev/null +++ b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/LeafCommand.java @@ -0,0 +1,31 @@ +package com.ashardalon.pratt.commands.impls; + +import com.ashardalon.pratt.ParserContext; +import com.ashardalon.pratt.commands.CommandResult; +import com.ashardalon.pratt.commands.InitialCommand; +import com.ashardalon.pratt.tokens.Token; + +import bjc.data.SimpleTree; +import bjc.utils.parserutils.ParserException; + +/** + * A operator that stands for itself. + * + * @author bjculkin + * + * @param + * The key type of the tokens. + * + * @param + * The value type of the tokens. + * + * @param + * The state type of the parser. + */ +public class LeafCommand implements InitialCommand { + @Override + public CommandResult denote(final Token operator, final ParserContext ctx) + throws ParserException { + return CommandResult.success(new SimpleTree<>(operator)); + } +} \ No newline at end of file diff --git a/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/LeftBinaryCommand.java b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/LeftBinaryCommand.java new file mode 100644 index 0000000..c5408d6 --- /dev/null +++ b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/LeftBinaryCommand.java @@ -0,0 +1,34 @@ +package com.ashardalon.pratt.commands.impls; + +import com.ashardalon.pratt.commands.BinaryCommand; + +/** + * A left-associative operator. + * + * @author bjculkin + * + * @param + * The key type of the tokens. + * + * @param + * The value type of the tokens. + * + * @param + * The state type of the parser. + */ +public class LeftBinaryCommand extends BinaryCommand { + /** + * Create a new left-associative operator. + * + * @param precedence + * The precedence of the operator. + */ + public LeftBinaryCommand(final int precedence) { + super(precedence); + } + + @Override + protected int rightBinding() { + return 1 + leftBinding(); + } +} \ No newline at end of file diff --git a/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/NonBinaryCommand.java b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/NonBinaryCommand.java new file mode 100644 index 0000000..aca3784 --- /dev/null +++ b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/NonBinaryCommand.java @@ -0,0 +1,39 @@ +package com.ashardalon.pratt.commands.impls; + +import com.ashardalon.pratt.commands.BinaryCommand; + +/** + * A non-associative operator. + * + * @author bjculkin + * + * @param + * The key type of the tokens. + * + * @param + * The value type of the tokens. + * + * @param + * The state type of the parser. + */ +public class NonBinaryCommand extends BinaryCommand { + /** + * Create a new non-associative operator. + * + * @param precedence + * The precedence of the operator. + */ + public NonBinaryCommand(final int precedence) { + super(precedence); + } + + @Override + protected int rightBinding() { + return 1 + leftBinding(); + } + + @Override + public int nextBinding() { + return leftBinding() - 1; + } +} \ No newline at end of file diff --git a/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/NonInitialCommands.java b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/NonInitialCommands.java new file mode 100644 index 0000000..41f0bab --- /dev/null +++ b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/NonInitialCommands.java @@ -0,0 +1,167 @@ +package com.ashardalon.pratt.commands.impls; + +import java.util.Set; + +import com.ashardalon.pratt.blocks.ParseBlock; +import com.ashardalon.pratt.blocks.SimpleParseBlock; +import com.ashardalon.pratt.commands.NonInitialCommand; +import com.ashardalon.pratt.tokens.Token; + +/** + * Contains factory methods for producing common implementations of + * {@link NonInitialCommand} + * + * @author EVE + * + */ +public class NonInitialCommands { + /** + * Create a left-associative infix operator. + * + * @param The key type for the tokens. + * @param The value type for the tokens. + * @param The context type for the tokens. + * + * @param precedence + * The precedence of the operator. + * + * @return A command implementing that operator. + */ + public static NonInitialCommand infixLeft(final int precedence) { + return new LeftBinaryCommand<>(precedence); + } + + /** + * Create a right-associative infix operator. + * + * @param The key type for the tokens. + * @param The value type for the tokens. + * @param The context type for the tokens. + * + * @param precedence + * The precedence of the operator. + * + * @return A command implementing that operator. + */ + public static NonInitialCommand infixRight(final int precedence) { + return new RightBinaryCommand<>(precedence); + } + + /** + * Create a non-associative infix operator. + * + * @param The key type for the tokens. + * @param The value type for the tokens. + * @param The context type for the tokens. + * + * @param precedence + * The precedence of the operator. + * + * @return A command implementing that operator. + */ + public static NonInitialCommand infixNon(final int precedence) { + return new NonBinaryCommand<>(precedence); + } + + /** + * Create a chained operator. + * + * @param The key type for the tokens. + * @param The value type for the tokens. + * @param The context type for the tokens. + * + * @param precedence + * The precedence of the operator. + * + * @param chainSet + * The operators it forms a chain with. + * + * @param marker + * The token to use as the AST node for the chained operators. + * + * @return A command implementing that operator. + */ + public static NonInitialCommand chain(final int precedence, final Set chainSet, + final Token marker) { + return new ChainCommand<>(precedence, chainSet, marker); + } + + /** + * Create a postfix operator. + * + * @param The key type for the tokens. + * @param The value type for the tokens. + * @param The context type for the tokens. + * + * @param precedence + * The precedence of the operator. + * + * @return A command implementing that operator. + */ + public static NonInitialCommand postfix(final int precedence) { + return new PostfixCommand<>(precedence); + } + + /** + * Create a post-circumfix operator. + * + * This is an operator in form similar to array indexing. + * + * @param The key type for the tokens. + * @param The value type for the tokens. + * @param The context type for the tokens. + * + * @param precedence + * The precedence of this operator + * + * @param insidePrecedence + * The precedence of the expression inside the operator + * + * @param closer + * The token that closes the circumfix. + * + * @param marker + * The token to use as the AST node for the operator. + * + * @return A command implementing that operator. + */ + public static NonInitialCommand postCircumfix(final int precedence, + final int insidePrecedence, final K closer, final Token marker) { + final ParseBlock innerBlock = new SimpleParseBlock<>(insidePrecedence, null, closer); + + return new PostCircumfixCommand<>(precedence, innerBlock, marker); + } + + /** + * Create a ternary operator. + * + * This is like C's ?: operator. + * + * @param The key type for the tokens. + * @param The value type for the tokens. + * @param The context type for the tokens. + * + * @param precedence + * The precedence of the operator. + * + * @param insidePrecedence + * The precedence of the inner section of the operator. + * + * @param closer + * The token that marks the end of the inner section. + * + * @param marker + * The token to use as the AST node for the operator. + * + * @param nonassoc + * True if the command is non-associative, false otherwise. + * + * @return A command implementing this operator. + */ + public static NonInitialCommand ternary(final int precedence, final int insidePrecedence, + final K closer, final Token marker, final boolean nonassoc) { + final ParseBlock innerBlock = new SimpleParseBlock<>(insidePrecedence, null, closer); + + return new TernaryCommand<>(precedence, innerBlock, marker, nonassoc); + } +} diff --git a/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/PanfixCommand.java b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/PanfixCommand.java new file mode 100644 index 0000000..99d43c8 --- /dev/null +++ b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/PanfixCommand.java @@ -0,0 +1,55 @@ +package com.ashardalon.pratt.commands.impls; + +import com.ashardalon.pratt.ParserContext; +import com.ashardalon.pratt.commands.CommandResult; +import com.ashardalon.pratt.commands.InitialCommand; +import com.ashardalon.pratt.commands.CommandResult.Status; +import com.ashardalon.pratt.tokens.Token; + +import bjc.data.SimpleTree; +import bjc.data.Tree; +import bjc.utils.parserutils.ParserException; + +/** + * Represents a 'panfix' command, one where the operator is repeated prefix, infix and postfix. + * @author bjcul + * + * @param The key type of the token + * @param The value type of the token + * @param The context type of the parser + */ +public final class PanfixCommand implements InitialCommand { + private final Token marker; + private final K term; + private final int precedence; + + /** + * Create a new panfix command. + * + * @param marker The marker token. + * @param term The value to use as the root of the result-tree + * @param precedence The precedence for this command + */ + public PanfixCommand(Token marker, K term, int precedence) { + this.marker = marker; + this.term = term; + this.precedence = precedence; + } + + @Override + public CommandResult denote(Token operator, ParserContext ctx) throws ParserException { + CommandResult resLeftSide = ctx.parse.parseExpression(precedence + 1, ctx.tokens, ctx.state, false); + if (resLeftSide.status != Status.SUCCESS) return resLeftSide; + Tree> leftSide = resLeftSide.success(); + ctx.tokens.expect(term); + ctx.tokens.next(); + + CommandResult resRightSide = ctx.parse.parseExpression(precedence + 1, ctx.tokens, ctx.state, false); + if (resLeftSide.status != Status.SUCCESS) return resRightSide; + Tree> rightSide = resRightSide.success(); + ctx.tokens.expect(term); + ctx.tokens.next(); + + return CommandResult.success(new SimpleTree<>(marker, leftSide, rightSide)); + } +} \ No newline at end of file diff --git a/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/PostCircumfixCommand.java b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/PostCircumfixCommand.java new file mode 100644 index 0000000..c5b60a1 --- /dev/null +++ b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/PostCircumfixCommand.java @@ -0,0 +1,64 @@ +package com.ashardalon.pratt.commands.impls; + +import bjc.data.Tree; + +import com.ashardalon.pratt.ParserContext; +import com.ashardalon.pratt.blocks.ParseBlock; +import com.ashardalon.pratt.commands.BinaryPostCommand; +import com.ashardalon.pratt.commands.CommandResult; +import com.ashardalon.pratt.commands.CommandResult.Status; +import com.ashardalon.pratt.tokens.Token; + +import bjc.data.SimpleTree; +import bjc.utils.parserutils.ParserException; + +/** + * A post-circumfix operator, like array indexing. + * + * @author bjculkin + * + * @param + * The key type of the tokens. + * + * @param + * The value type of the tokens. + * + * @param + * The state type of the parser. + */ +public class PostCircumfixCommand extends BinaryPostCommand { + private final ParseBlock innerBlock; + + private final Token mark; + + /** + * Create a new post-circumfix operator. + * + * @param precedence + * The precedence of the operator. + * + * @param inner + * The block inside the expression. + * + * @param marker + * The token to use as the node for the AST. + */ + public PostCircumfixCommand(final int precedence, final ParseBlock inner, final Token marker) { + super(precedence); + + if(inner == null) throw new NullPointerException("Inner block must not be null"); + + innerBlock = inner; + + mark = marker; + } + + @Override + public CommandResult denote(final Tree> operand, final Token operator, + final ParserContext ctx) throws ParserException { + final CommandResult insideRes = innerBlock.parse(ctx); + if (insideRes.status != Status.SUCCESS) return insideRes; + Tree> inside = insideRes.success(); + return CommandResult.success(new SimpleTree<>(mark, operand, inside)); + } +} \ No newline at end of file diff --git a/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/PostfixCommand.java b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/PostfixCommand.java new file mode 100644 index 0000000..84ac61d --- /dev/null +++ b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/PostfixCommand.java @@ -0,0 +1,43 @@ +package com.ashardalon.pratt.commands.impls; + +import bjc.data.Tree; + +import com.ashardalon.pratt.ParserContext; +import com.ashardalon.pratt.commands.BinaryPostCommand; +import com.ashardalon.pratt.commands.CommandResult; +import com.ashardalon.pratt.tokens.Token; + +import bjc.data.SimpleTree; +import bjc.utils.parserutils.ParserException; + +/** + * A postfix operator. + * + * @author bjculkin + * + * @param + * The key type of the tokens. + * + * @param + * The value type of the tokens. + * + * @param + * The state type of the parser. + */ +public class PostfixCommand extends BinaryPostCommand { + /** + * Create a new postfix operator. + * + * @param precedence + * The precedence of the operator. + */ + public PostfixCommand(final int precedence) { + super(precedence); + } + + @Override + public CommandResult denote(final Tree> operand, final Token operator, + final ParserContext ctx) throws ParserException { + return CommandResult.success(new SimpleTree<>(operator, operand)); + } +} \ No newline at end of file diff --git a/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/PreTernaryCommand.java b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/PreTernaryCommand.java new file mode 100644 index 0000000..cd01333 --- /dev/null +++ b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/PreTernaryCommand.java @@ -0,0 +1,85 @@ +package com.ashardalon.pratt.commands.impls; + +import bjc.data.Tree; + +import com.ashardalon.pratt.ParserContext; +import com.ashardalon.pratt.blocks.ParseBlock; +import com.ashardalon.pratt.commands.AbstractInitialCommand; +import com.ashardalon.pratt.commands.CommandResult; +import com.ashardalon.pratt.commands.CommandResult.Status; +import com.ashardalon.pratt.tokens.Token; + +import bjc.data.SimpleTree; +import bjc.utils.parserutils.ParserException; + +/** + * A prefix ternary operator, like an if/then/else group. + * + * @author bjculkin + * + * @param + * The key type of the tokens. + * + * @param + * The value type of the tokens. + * + * @param + * The state type of the parser. + */ +public class PreTernaryCommand extends AbstractInitialCommand { + private final Token trm; + + private final ParseBlock condBlock; + + private final ParseBlock opblock1; + private final ParseBlock opblock2; + + /** + * Create a new ternary statement. + * + * @param cond + * The block for handling the condition. + * + * @param op1 + * The block for handling the first operator. + * + * @param op2 + * The block for handling the second operator. + * + * @param term + * The token to use as the node for the AST. + */ + public PreTernaryCommand(final ParseBlock cond, final ParseBlock op1, + final ParseBlock op2, final Token term) { + super(); + + if(cond == null) + throw new NullPointerException("Cond block must not be null"); + else if(op1 == null) + throw new NullPointerException("Op block #1 must not be null"); + else if(op2 == null) throw new NullPointerException("Op block #2 must not be null"); + + condBlock = cond; + opblock1 = op1; + opblock2 = op2; + + trm = term; + } + + @Override + protected CommandResult intNullDenotation(final Token operator, final ParserContext ctx) + throws ParserException { + final CommandResult condRes = condBlock.parse(ctx); + if (condRes.status != Status.SUCCESS) return condRes; + Tree> cond = condRes.success(); + + final CommandResult op1Res = opblock1.parse(ctx); + if (op1Res.status != Status.SUCCESS) return op1Res; + Tree> op1 = op1Res.success(); + + final CommandResult op2Res = opblock2.parse(ctx); + if (op2Res.status != Status.SUCCESS) return op2Res; + Tree> op2 = op2Res.success(); + return CommandResult.success(new SimpleTree<>(trm, cond, op1, op2)); + } +} \ No newline at end of file diff --git a/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/RightBinaryCommand.java b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/RightBinaryCommand.java new file mode 100644 index 0000000..9145fd6 --- /dev/null +++ b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/RightBinaryCommand.java @@ -0,0 +1,32 @@ +package com.ashardalon.pratt.commands.impls; + +import com.ashardalon.pratt.commands.BinaryCommand; + +/** + * A right-associative binary operator. + * + * @author bjculkin + * + * @param + * The key type of the tokens. + * @param + * The value type of the tokens. + * @param + * The state type of the parser. + */ +public class RightBinaryCommand extends BinaryCommand { + /** + * Create a new right-associative operator. + * + * @param precedence + * The precedence of the operator. + */ + public RightBinaryCommand(final int precedence) { + super(precedence); + } + + @Override + protected int rightBinding() { + return leftBinding(); + } +} \ No newline at end of file diff --git a/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/TernaryCommand.java b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/TernaryCommand.java new file mode 100644 index 0000000..b52107f --- /dev/null +++ b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/TernaryCommand.java @@ -0,0 +1,78 @@ +package com.ashardalon.pratt.commands.impls; + +import bjc.data.Tree; + +import com.ashardalon.pratt.ParserContext; +import com.ashardalon.pratt.blocks.ParseBlock; +import com.ashardalon.pratt.commands.BinaryPostCommand; +import com.ashardalon.pratt.commands.CommandResult; +import com.ashardalon.pratt.commands.CommandResult.Status; +import com.ashardalon.pratt.tokens.Token; + +import bjc.data.SimpleTree; +import bjc.utils.parserutils.ParserException; + +/** + * A ternary command, like C's ?: + * + * @author bjculkin + * + * @param The key type of the tokens. + * + * @param The value type of the tokens. + * + * @param The state type of the parser. + */ +public class TernaryCommand extends BinaryPostCommand { + private final ParseBlock innerBlck; + + private final Token mark; + + private final boolean nonassoc; + + /** + * Create a new ternary command. + * + * @param precedence The precedence of this operator. + * + * @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 isNonassoc Whether or not the conditional is associative. + */ + public TernaryCommand(final int precedence, final ParseBlock innerBlock, final Token marker, + final boolean isNonassoc) { + super(precedence); + + if (innerBlock == null) + throw new NullPointerException("Inner block must not be null"); + else if (marker == null) + throw new NullPointerException("Marker must not be null"); + + innerBlck = innerBlock; + mark = marker; + nonassoc = isNonassoc; + } + + @Override + public CommandResult denote(final Tree> operand, final Token operator, + final ParserContext ctx) throws ParserException { + final CommandResult innerRes = innerBlck.parse(ctx); + if (innerRes.status != Status.SUCCESS) return innerRes; + Tree> inner = innerRes.success(); + + final CommandResult outerRes = ctx.parse.parseExpression(1 + leftBinding(), ctx.tokens, ctx.state, false); + if (outerRes.status != Status.SUCCESS) return outerRes; + Tree> outer = outerRes.success(); + return CommandResult.success(new SimpleTree<>(mark, inner, operand, outer)); + } + + @Override + public int nextBinding() { + if (nonassoc) + return leftBinding() - 1; + + return leftBinding(); + } +} \ No newline at end of file diff --git a/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/TransformingInitialCommand.java b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/TransformingInitialCommand.java new file mode 100644 index 0000000..9a08c44 --- /dev/null +++ b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/TransformingInitialCommand.java @@ -0,0 +1,59 @@ +package com.ashardalon.pratt.commands.impls; + +import java.util.function.UnaryOperator; + +import com.ashardalon.pratt.ParserContext; +import com.ashardalon.pratt.commands.AbstractInitialCommand; +import com.ashardalon.pratt.commands.CommandResult; +import com.ashardalon.pratt.commands.InitialCommand; +import com.ashardalon.pratt.commands.CommandResult.Status; +import com.ashardalon.pratt.tokens.Token; + +import bjc.data.Tree; +import bjc.utils.parserutils.ParserException; + +/** + * An initial command that transforms the result of another command. + * + * @author bjculkin + * + * @param + * The key type of the tokens. + * + * @param + * The value type of the tokens. + * + * @param + * The state type of the parser. + */ +public class TransformingInitialCommand extends AbstractInitialCommand { + private final InitialCommand internl; + + private final UnaryOperator>> transfrm; + + /** + * Create a new transforming initial command. + * + * @param internal + * The initial command to delegate to. + * + * @param transform + * The transform to apply to the returned tree. + */ + public TransformingInitialCommand(final InitialCommand internal, + final UnaryOperator>> transform) { + super(); + internl = internal; + transfrm = transform; + } + + @Override + protected CommandResult intNullDenotation(final Token operator, final ParserContext ctx) + throws ParserException { + CommandResult result = internl.denote(operator, ctx); + if (result.status != Status.SUCCESS) return result; + + return CommandResult.success(transfrm.apply(result.success())); + } + +} diff --git a/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/UnaryCommand.java b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/UnaryCommand.java new file mode 100644 index 0000000..a7efdc3 --- /dev/null +++ b/JPratt/src/main/java/com/ashardalon/pratt/commands/impls/UnaryCommand.java @@ -0,0 +1,52 @@ +package com.ashardalon.pratt.commands.impls; + +import bjc.data.Tree; + +import com.ashardalon.pratt.ParserContext; +import com.ashardalon.pratt.commands.AbstractInitialCommand; +import com.ashardalon.pratt.commands.CommandResult; +import com.ashardalon.pratt.commands.CommandResult.Status; +import com.ashardalon.pratt.tokens.Token; + +import bjc.data.SimpleTree; +import bjc.utils.parserutils.ParserException; + +/** + * A unary operator. + * + * @author bjculkin + * + * @param + * The key type of the tokens. + * + * @param + * The value type of the tokens. + * + * @param + * The state type of the parser. + */ +public class UnaryCommand extends AbstractInitialCommand { + private final int nullPwer; + + /** + * Create a new unary command. + * + * @param precedence + * The precedence of this operator. + */ + public UnaryCommand(final int precedence) { + if(precedence < 0) throw new IllegalArgumentException("Precedence must be non-negative"); + + nullPwer = precedence; + } + + @Override + protected CommandResult intNullDenotation(final Token operator, final ParserContext ctx) + throws ParserException { + CommandResult result = ctx.parse.parseExpression(nullPwer, ctx.tokens, ctx.state, false); + if (result.status != Status.SUCCESS) return result; + final Tree> opr = result.success(); + + return CommandResult.success(new SimpleTree<>(operator, opr)); + } +} \ No newline at end of file -- cgit v1.2.3