From 3f74e1e25fd572adab34e53eb90edcf49404fbe5 Mon Sep 17 00:00:00 2001 From: bculkin2442 Date: Tue, 11 Apr 2017 21:57:37 -0400 Subject: Cleanup --- .../java/bjc/pratt/blocks/GrammarParseBlock.java | 59 +++++++++++----------- .../main/java/bjc/pratt/blocks/ParseBlocks.java | 4 -- .../bjc/pratt/commands/BlockInitialCommand.java | 14 ++--- .../bjc/pratt/commands/BlockNonInitialCommand.java | 31 ++++++------ 4 files changed, 53 insertions(+), 55 deletions(-) (limited to 'JPratt/src/main/java') diff --git a/JPratt/src/main/java/bjc/pratt/blocks/GrammarParseBlock.java b/JPratt/src/main/java/bjc/pratt/blocks/GrammarParseBlock.java index 459f83d..b714940 100644 --- a/JPratt/src/main/java/bjc/pratt/blocks/GrammarParseBlock.java +++ b/JPratt/src/main/java/bjc/pratt/blocks/GrammarParseBlock.java @@ -13,40 +13,40 @@ import bjc.utils.parserutils.ParserException; /** * A {@link ParseBlock} that parses an expression from a 'inner' grammar. - * + * * @author bjculkin * * @param * The key type of the outer tokens. - * + * * @param * The value type of the outer tokens. - * + * * @param * The state type of the outer parser. - * + * * @param * The key type of the inner tokens. - * + * * @param * The value type of the inner tokens. - * + * * @param * The state type of the outer parser. */ public class GrammarParseBlock implements ParseBlock { - private PrattParser inner; + private final PrattParser innr; - private int precedence; - private boolean isStatement; + private final int prcedence; + private final boolean isStatemnt; - private Function, TokenStream> tokenTransform; - private Isomorphism stateTransform; - private Function>, ITree>> expressionTransform; + private final Function, TokenStream> tkenTransform; + private final Isomorphism stteTransform; + private final Function>, ITree>> xpressionTransform; /** * Create a new grammar parser block. - * + * * @param inner * @param precedence * @param isStatement @@ -54,28 +54,29 @@ public class GrammarParseBlock implements ParseBlock inner, int precedence, boolean isStatement, - Function, TokenStream> tokenTransform, - Isomorphism stateTransform, - Function>, ITree>> expressionTransform) { - this.inner = inner; - this.precedence = precedence; - this.isStatement = isStatement; - this.tokenTransform = tokenTransform; - this.stateTransform = stateTransform; - this.expressionTransform = expressionTransform; + public GrammarParseBlock(final PrattParser inner, final int precedence, final boolean isStatement, + final Function, TokenStream> tokenTransform, + final Isomorphism stateTransform, + final Function>, ITree>> expressionTransform) { + innr = inner; + prcedence = precedence; + isStatemnt = isStatement; + tkenTransform = tokenTransform; + stteTransform = stateTransform; + xpressionTransform = expressionTransform; } @Override - public ITree> parse(ParserContext ctx) throws ParserException { - C2 newState = stateTransform.to(ctx.state); + public ITree> parse(final ParserContext ctx) throws ParserException { + final C2 newState = stteTransform.to(ctx.state); - TokenStream newTokens = tokenTransform.apply(ctx.tokens); + final TokenStream newTokens = tkenTransform.apply(ctx.tokens); - ITree> expression = inner.parseExpression(precedence, newTokens, newState, isStatement); + final ITree> expression = innr.parseExpression(prcedence, newTokens, newState, + isStatemnt); - ctx.state = stateTransform.from(newState); + ctx.state = stteTransform.from(newState); - return expressionTransform.apply(expression); + return xpressionTransform.apply(expression); } } \ No newline at end of file diff --git a/JPratt/src/main/java/bjc/pratt/blocks/ParseBlocks.java b/JPratt/src/main/java/bjc/pratt/blocks/ParseBlocks.java index a3e3147..44288d2 100644 --- a/JPratt/src/main/java/bjc/pratt/blocks/ParseBlocks.java +++ b/JPratt/src/main/java/bjc/pratt/blocks/ParseBlocks.java @@ -1,15 +1,11 @@ package bjc.pratt.blocks; -import java.util.function.Function; import java.util.function.Predicate; import java.util.function.UnaryOperator; import bjc.pratt.ParseBlock; -import bjc.pratt.PrattParser; import bjc.pratt.Token; -import bjc.pratt.TokenStream; import bjc.utils.data.ITree; -import bjc.utils.funcutils.Isomorphism; /** * Utility class for creating common implementations of {@link ParseBlock} diff --git a/JPratt/src/main/java/bjc/pratt/commands/BlockInitialCommand.java b/JPratt/src/main/java/bjc/pratt/commands/BlockInitialCommand.java index f0448f7..ca2d31a 100644 --- a/JPratt/src/main/java/bjc/pratt/commands/BlockInitialCommand.java +++ b/JPratt/src/main/java/bjc/pratt/commands/BlockInitialCommand.java @@ -8,33 +8,33 @@ 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 ParseBlock blck; + private final ParseBlock blck; /** * Create a new block initial command. - * + * * @param block * The block to delegate to. */ - public BlockInitialCommand(ParseBlock block) { + public BlockInitialCommand(final ParseBlock block) { blck = block; } @Override - protected ITree> intNullDenotation(Token operator, ParserContext ctx) + protected ITree> intNullDenotation(final Token operator, final ParserContext ctx) throws ParserException { return blck.parse(ctx); } diff --git a/JPratt/src/main/java/bjc/pratt/commands/BlockNonInitialCommand.java b/JPratt/src/main/java/bjc/pratt/commands/BlockNonInitialCommand.java index 9a5ffc9..c361c73 100644 --- a/JPratt/src/main/java/bjc/pratt/commands/BlockNonInitialCommand.java +++ b/JPratt/src/main/java/bjc/pratt/commands/BlockNonInitialCommand.java @@ -10,42 +10,43 @@ import bjc.utils.parserutils.ParserException; /** * A non-initial command that delegates all of 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 BlockNonInitialCommand extends NonInitialCommand { - private ParseBlock innr; + private final ParseBlock innr; - private int lftBind; - private int nxtBind; + private final int lftBind; + private final int nxtBind; - private Token trm; + private final Token trm; /** * Create a new non-initial command that delegates to a parse block. - * + * * @param inner * The parse block to delegate to. - * + * * @param leftBind * The left binding power (precedence). - * + * * @param rightBind * The right binding power (associativity control). - * + * * @param term * The token to use as the node in the AST. */ - public BlockNonInitialCommand(ParseBlock inner, int leftBind, int rightBind, Token term) { + public BlockNonInitialCommand(final ParseBlock inner, final int leftBind, final int rightBind, + final Token term) { innr = inner; lftBind = leftBind; @@ -55,9 +56,9 @@ public class BlockNonInitialCommand extends NonInitialCommand } @Override - public ITree> denote(ITree> operand, Token operator, ParserContext ctx) - throws ParserException { - ITree> expression = innr.parse(ctx); + public ITree> denote(final ITree> operand, final Token operator, + final ParserContext ctx) throws ParserException { + final ITree> expression = innr.parse(ctx); return new Tree<>(trm, expression); } -- cgit v1.2.3