From 56f07e9a3aaa873fe385d224f088f048dbafa8f7 Mon Sep 17 00:00:00 2001 From: bculkin2442 Date: Mon, 10 Apr 2017 16:49:54 -0400 Subject: Cleanup --- .../java/bjc/pratt/examples/AssignCommand.java | 11 +- .../java/bjc/pratt/examples/BlockEnter.java | 12 +- .../java/bjc/pratt/examples/BlockExit.java | 2 +- .../java/bjc/pratt/examples/PrattParserTest.java | 144 +++++++++++---------- .../java/bjc/pratt/examples/SwitchCommand.java | 8 +- .../java/bjc/pratt/examples/TestContext.java | 2 +- .../java/bjc/pratt/examples/Tokenizer.java | 43 +++--- .../java/bjc/pratt/examples/VarCommand.java | 10 +- 8 files changed, 128 insertions(+), 104 deletions(-) (limited to 'JPratt/src/examples/java/bjc/pratt') diff --git a/JPratt/src/examples/java/bjc/pratt/examples/AssignCommand.java b/JPratt/src/examples/java/bjc/pratt/examples/AssignCommand.java index 45aac1a..f3cc003 100644 --- a/JPratt/src/examples/java/bjc/pratt/examples/AssignCommand.java +++ b/JPratt/src/examples/java/bjc/pratt/examples/AssignCommand.java @@ -9,14 +9,15 @@ import bjc.utils.data.Tree; import bjc.utils.parserutils.ParserException; class AssignCommand extends NonBinaryCommand { - public AssignCommand(int prec) { + public AssignCommand(final int prec) { super(prec); } @Override - public ITree> denote(ITree> operand, Token operator, - ParserContext ctx) throws ParserException { - Token name = operand.getHead(); + public ITree> denote(final ITree> operand, + final Token operator, final ParserContext ctx) + throws ParserException { + final Token name = operand.getHead(); switch (name.getKey()) { case "(literal)": @@ -26,7 +27,7 @@ class AssignCommand extends NonBinaryCommand { throw new ParserException("Variable name must be simple"); } - ITree> body = ctx.parse.parseExpression(0, ctx.tokens, ctx.state, false); + final ITree> body = ctx.parse.parseExpression(0, ctx.tokens, ctx.state, false); ctx.state.scopes.top().putKey(name.getValue(), body); diff --git a/JPratt/src/examples/java/bjc/pratt/examples/BlockEnter.java b/JPratt/src/examples/java/bjc/pratt/examples/BlockEnter.java index 67e560c..092c6b2 100644 --- a/JPratt/src/examples/java/bjc/pratt/examples/BlockEnter.java +++ b/JPratt/src/examples/java/bjc/pratt/examples/BlockEnter.java @@ -1,19 +1,19 @@ package bjc.pratt.examples; +import java.util.function.UnaryOperator; + import bjc.pratt.Token; import bjc.utils.data.ITree; import bjc.utils.esodata.Directory; import bjc.utils.esodata.Stack; -import java.util.function.UnaryOperator; - final class BlockEnter implements UnaryOperator { @Override - public TestContext apply(TestContext state) { - Directory>> enclosing = state.scopes.top(); - Stack blockCount = state.blockCount; + public TestContext apply(final TestContext state) { + final Directory>> enclosing = state.scopes.top(); + final Stack blockCount = state.blockCount; - int currBlockNumber = blockCount.pop(); + final int currBlockNumber = blockCount.pop(); state.scopes.push(enclosing.newSubdirectory("block" + currBlockNumber)); diff --git a/JPratt/src/examples/java/bjc/pratt/examples/BlockExit.java b/JPratt/src/examples/java/bjc/pratt/examples/BlockExit.java index 1cca6d5..ea9526d 100644 --- a/JPratt/src/examples/java/bjc/pratt/examples/BlockExit.java +++ b/JPratt/src/examples/java/bjc/pratt/examples/BlockExit.java @@ -4,7 +4,7 @@ import java.util.function.UnaryOperator; final class BlockExit implements UnaryOperator { @Override - public TestContext apply(TestContext state) { + public TestContext apply(final TestContext state) { state.scopes.pop(); state.blockCount.pop(); diff --git a/JPratt/src/examples/java/bjc/pratt/examples/PrattParserTest.java b/JPratt/src/examples/java/bjc/pratt/examples/PrattParserTest.java index b7d31eb..e504048 100644 --- a/JPratt/src/examples/java/bjc/pratt/examples/PrattParserTest.java +++ b/JPratt/src/examples/java/bjc/pratt/examples/PrattParserTest.java @@ -1,5 +1,30 @@ package bjc.pratt.examples; +import static bjc.pratt.commands.InitialCommands.delimited; +import static bjc.pratt.commands.InitialCommands.grouping; +import static bjc.pratt.commands.InitialCommands.leaf; +import static bjc.pratt.commands.InitialCommands.preTernary; +import static bjc.pratt.commands.InitialCommands.unary; +import static bjc.pratt.commands.NonInitialCommands.chain; +import static bjc.pratt.commands.NonInitialCommands.infixLeft; +import static bjc.pratt.commands.NonInitialCommands.infixNon; +import static bjc.pratt.commands.NonInitialCommands.infixRight; +import static bjc.pratt.commands.NonInitialCommands.postCircumfix; +import static bjc.pratt.commands.NonInitialCommands.postfix; +import static bjc.pratt.commands.NonInitialCommands.ternary; +import static bjc.pratt.tokens.StringToken.litToken; +import static bjc.utils.functypes.ID.id; + +import java.util.Arrays; +import java.util.HashSet; +import java.util.Iterator; +import java.util.LinkedHashSet; +import java.util.LinkedList; +import java.util.List; +import java.util.Scanner; +import java.util.Set; +import java.util.function.UnaryOperator; + import bjc.pratt.InitialCommand; import bjc.pratt.NonInitialCommand; import bjc.pratt.PrattParser; @@ -14,39 +39,24 @@ import bjc.utils.parserutils.splitterv2.ConfigurableTokenSplitter; import bjc.utils.parserutils.splitterv2.ExcludingTokenSplitter; import bjc.utils.parserutils.splitterv2.TokenSplitter; -import java.util.Arrays; -import java.util.HashSet; -import java.util.Iterator; -import java.util.LinkedHashSet; -import java.util.LinkedList; -import java.util.List; -import java.util.Scanner; -import java.util.Set; -import java.util.function.UnaryOperator; - -import static bjc.pratt.commands.InitialCommands.*; -import static bjc.pratt.commands.NonInitialCommands.*; -import static bjc.pratt.tokens.StringToken.litToken; -import static bjc.utils.functypes.ID.id; - /** * Simple test for Pratt parser. - * + * * @author EVE * */ public class PrattParserTest { /** * Main method. - * + * * @param args * Unused CLI arguments. */ - public static void main(String[] args) { + public static void main(final String[] args) { /* * Use a linked hash set to preserve insertion order. */ - Set ops = new LinkedHashSet<>(); + final Set ops = new LinkedHashSet<>(); ops.add("!!!"); @@ -55,7 +65,7 @@ public class PrattParserTest { ops.addAll(Arrays.asList("||", "&&")); ops.addAll(Arrays.asList("<=", ">=")); - ops.addAll(Arrays.asList("±")); + ops.addAll(Arrays.asList("�")); ops.addAll(Arrays.asList(".", ",", ";", ":")); ops.addAll(Arrays.asList("=", "<", ">")); ops.addAll(Arrays.asList("+", "-", "*", "/")); @@ -67,7 +77,7 @@ public class PrattParserTest { /* * Reserved words that represent themselves, not literals. */ - Set reserved = new LinkedHashSet<>(); + final Set reserved = new LinkedHashSet<>(); reserved.addAll(Arrays.asList("if", "then", "else")); reserved.addAll(Arrays.asList("and", "or")); reserved.addAll(Arrays.asList("begin", "end")); @@ -75,17 +85,17 @@ public class PrattParserTest { reserved.addAll(Arrays.asList("sqrt", "cbrt", "root")); reserved.add("var"); - ChainTokenSplitter nsplit = new ChainTokenSplitter(); + final ChainTokenSplitter nsplit = new ChainTokenSplitter(); - ConfigurableTokenSplitter hi = new ConfigurableTokenSplitter(true); - ConfigurableTokenSplitter lo = new ConfigurableTokenSplitter(true); + final ConfigurableTokenSplitter hi = new ConfigurableTokenSplitter(true); + final ConfigurableTokenSplitter lo = new ConfigurableTokenSplitter(true); hi.addSimpleDelimiters("->"); hi.addSimpleDelimiters(":="); hi.addSimpleDelimiters("||", "&&"); hi.addSimpleDelimiters("<=", ">="); - lo.addSimpleDelimiters("±"); + lo.addSimpleDelimiters("�"); lo.addSimpleDelimiters(".", ",", ";", ":"); lo.addSimpleDelimiters("=", "<", ">"); lo.addSimpleDelimiters("+", "-", "*", "/"); @@ -101,38 +111,40 @@ public class PrattParserTest { nsplit.appendSplitters(hi, lo); - ExcludingTokenSplitter excluder = new ExcludingTokenSplitter(nsplit); + final ExcludingTokenSplitter excluder = new ExcludingTokenSplitter(nsplit); excluder.addLiteralExclusions(reserved.toArray(new String[0])); - PrattParser parser = createParser(); + final PrattParser parser = createParser(); - TestContext ctx = new TestContext(); + final TestContext ctx = new TestContext(); - Scanner scn = new Scanner(System.in); + final Scanner scn = new Scanner(System.in); System.out.print("Enter a command (blank line to exit): "); String ln = scn.nextLine(); while (!ln.trim().equals("")) { - Iterator> tokens = preprocessInput(ops, excluder, ln, reserved, ctx); + final Iterator> tokens = preprocessInput(ops, excluder, ln, reserved, + ctx); try { - StringTokenStream tokenStream = new StringTokenStream(tokens); + final StringTokenStream tokenStream = new StringTokenStream(tokens); /* * Prime stream. */ tokenStream.next(); - ITree> tree = parser.parseExpression(0, tokenStream, ctx, true); + final ITree> tree = parser.parseExpression(0, tokenStream, ctx, + true); if (!tokenStream.headIs("(end)")) { System.out.println("\nMultiple expressions on line"); } System.out.println("\nParsed expression:\n" + tree); - } catch (ParserException pex) { + } catch (final ParserException pex) { pex.printStackTrace(); } @@ -146,16 +158,16 @@ public class PrattParserTest { scn.close(); } - private static Iterator> preprocessInput(Set ops, TokenSplitter split, String ln, - Set reserved, TestContext ctx) { - String[] rawTokens = ln.split("\\s+"); + private static Iterator> preprocessInput(final Set ops, final TokenSplitter split, + final String ln, final Set reserved, final TestContext ctx) { + final String[] rawTokens = ln.split("\\s+"); - List splitTokens = new LinkedList<>(); + final List splitTokens = new LinkedList<>(); - for (String raw : rawTokens) { + for (final String raw : rawTokens) { boolean doSplit = false; - for (String op : ops) { + for (final String op : ops) { if (raw.contains(op)) { doSplit = true; break; @@ -163,7 +175,7 @@ public class PrattParserTest { } if (doSplit) { - String[] strangs = split.split(raw).toArray(new String[0]); + final String[] strangs = split.split(raw).toArray(new String[0]); splitTokens.addAll(Arrays.asList(strangs)); } else { @@ -173,11 +185,11 @@ public class PrattParserTest { System.out.println("\nSplit string: " + splitTokens); - Iterator source = splitTokens.iterator(); + final Iterator source = splitTokens.iterator(); - Tokenizer tokenzer = new Tokenizer(ops, reserved, ctx); + final Tokenizer tokenzer = new Tokenizer(ops, reserved, ctx); - Iterator> tokens = new TransformIterator<>(source, tokenzer); + final Iterator> tokens = new TransformIterator<>(source, tokenzer); return tokens; } @@ -186,86 +198,88 @@ public class PrattParserTest { /* * Set of which relational operators chain with each other. */ - HashSet relChain = new HashSet<>(); + final HashSet relChain = new HashSet<>(); relChain.addAll(Arrays.asList("=", "<", ">", "<=", ">=")); /* * Token for marking chains. */ - StringToken chainToken = litToken("and"); + final StringToken chainToken = litToken("and"); /* * ID function. */ - UnaryOperator idfun = id(); + final UnaryOperator idfun = id(); - PrattParser parser = new PrattParser<>(); + final PrattParser parser = new PrattParser<>(); parser.addNonInitialCommand("!!!", postfix(0)); parser.addNonInitialCommand(":", infixNon(3)); - NonInitialCommand ifElse = ternary(5, 0, "else", litToken("cond"), false); + final NonInitialCommand ifElse = ternary(5, 0, "else", litToken("cond"), + false); parser.addNonInitialCommand("if", ifElse); parser.addNonInitialCommand(":=", new AssignCommand(10)); parser.addNonInitialCommand("->", infixRight(11)); - NonInitialCommand nonSSRelJoin = infixLeft(13); + final NonInitialCommand nonSSRelJoin = infixLeft(13); parser.addNonInitialCommand("and", nonSSRelJoin); parser.addNonInitialCommand("or", nonSSRelJoin); - NonInitialCommand chainRelOp = chain(15, relChain, chainToken); + final NonInitialCommand chainRelOp = chain(15, relChain, chainToken); parser.addNonInitialCommand("=", chainRelOp); parser.addNonInitialCommand("<", chainRelOp); parser.addNonInitialCommand(">", chainRelOp); parser.addNonInitialCommand("<=", chainRelOp); parser.addNonInitialCommand(">=", chainRelOp); - NonInitialCommand ssRelJoin = infixRight(17); + final NonInitialCommand ssRelJoin = infixRight(17); parser.addNonInitialCommand("&&", ssRelJoin); parser.addNonInitialCommand("||", ssRelJoin); - NonInitialCommand addSub = infixLeft(20); + final NonInitialCommand addSub = infixLeft(20); parser.addNonInitialCommand("+", addSub); parser.addNonInitialCommand("-", addSub); - parser.addNonInitialCommand("±", addSub); + parser.addNonInitialCommand("�", addSub); - NonInitialCommand mulDiv = infixLeft(30); + final NonInitialCommand mulDiv = infixLeft(30); parser.addNonInitialCommand("*", mulDiv); parser.addNonInitialCommand("/", mulDiv); parser.addNonInitialCommand("!", postfix(40)); - NonInitialCommand expon = infixRight(50); + final NonInitialCommand expon = infixRight(50); parser.addNonInitialCommand("^", expon); parser.addNonInitialCommand("root", expon); - NonInitialCommand superexpon = postfix(50); + final NonInitialCommand superexpon = postfix(50); parser.addNonInitialCommand("(superexp)", superexpon); parser.addNonInitialCommand(".", infixLeft(60)); - NonInitialCommand arrayIdx = postCircumfix(60, 0, "]", litToken("idx")); + final NonInitialCommand arrayIdx = postCircumfix(60, 0, "]", + litToken("idx")); parser.addNonInitialCommand("[", arrayIdx); - InitialCommand ifThenElse = preTernary(0, 0, 0, "then", "else", + final InitialCommand ifThenElse = preTernary(0, 0, 0, "then", "else", litToken("ifelse")); parser.addInitialCommand("if", ifThenElse); - InitialCommand parens = grouping(0, ")", litToken("parens")); + final InitialCommand parens = grouping(0, ")", litToken("parens")); parser.addInitialCommand("(", parens); - InitialCommand scoper = delimited(0, ";", "end", litToken("block"), + final InitialCommand scoper = delimited(0, ";", "end", litToken("block"), new BlockEnter(), idfun, new BlockExit(), true); parser.addInitialCommand("begin", scoper); - InitialCommand arrayLiteral = delimited(0, ",", "]", litToken("array"), - idfun, idfun, idfun, false); + final InitialCommand arrayLiteral = delimited(0, ",", "]", + litToken("array"), idfun, idfun, idfun, false); parser.addInitialCommand("[", arrayLiteral); - InitialCommand jsonLiteral = delimited(0, ",", "}", litToken("json"), + final InitialCommand jsonLiteral = delimited(0, ",", "}", litToken("json"), idfun, idfun, idfun, false); parser.addInitialCommand("{", jsonLiteral); @@ -273,11 +287,11 @@ public class PrattParserTest { parser.addInitialCommand("-", unary(30)); - InitialCommand root = unary(50); + final InitialCommand root = unary(50); parser.addInitialCommand("sqrt", root); parser.addInitialCommand("cbrt", root); - InitialCommand leaf = leaf(); + final InitialCommand leaf = leaf(); parser.addInitialCommand("(literal)", leaf); parser.addInitialCommand("(vref)", leaf); diff --git a/JPratt/src/examples/java/bjc/pratt/examples/SwitchCommand.java b/JPratt/src/examples/java/bjc/pratt/examples/SwitchCommand.java index 4a5bd22..6c4e2b6 100644 --- a/JPratt/src/examples/java/bjc/pratt/examples/SwitchCommand.java +++ b/JPratt/src/examples/java/bjc/pratt/examples/SwitchCommand.java @@ -10,11 +10,11 @@ import bjc.utils.parserutils.ParserException; class SwitchCommand implements InitialCommand { @Override - public ITree> denote(Token operator, - ParserContext ctx) throws ParserException { - ITree> object = ctx.parse.parseExpression(0, ctx.tokens, ctx.state, false); + public ITree> denote(final Token operator, + final ParserContext ctx) throws ParserException { + final ITree> object = ctx.parse.parseExpression(0, ctx.tokens, ctx.state, false); - ITree> body = ctx.parse.parseExpression(0, ctx.tokens, ctx.state, false); + final ITree> body = ctx.parse.parseExpression(0, ctx.tokens, ctx.state, false); return new Tree<>(new StringToken("switch", "switch"), object, body); } diff --git a/JPratt/src/examples/java/bjc/pratt/examples/TestContext.java b/JPratt/src/examples/java/bjc/pratt/examples/TestContext.java index b5e8448..e5583b4 100644 --- a/JPratt/src/examples/java/bjc/pratt/examples/TestContext.java +++ b/JPratt/src/examples/java/bjc/pratt/examples/TestContext.java @@ -9,7 +9,7 @@ import bjc.utils.esodata.Stack; /** * Simple context for the parser. - * + * * @author EVE * */ diff --git a/JPratt/src/examples/java/bjc/pratt/examples/Tokenizer.java b/JPratt/src/examples/java/bjc/pratt/examples/Tokenizer.java index 0fccc60..9b3fa74 100644 --- a/JPratt/src/examples/java/bjc/pratt/examples/Tokenizer.java +++ b/JPratt/src/examples/java/bjc/pratt/examples/Tokenizer.java @@ -1,37 +1,46 @@ package bjc.pratt.examples; -import bjc.pratt.Token; -import bjc.pratt.tokens.StringToken; +import static bjc.pratt.tokens.StringToken.litToken; import java.util.Set; import java.util.function.Function; -import static bjc.pratt.tokens.StringToken.litToken; +import bjc.pratt.Token; +import bjc.pratt.tokens.StringToken; final class Tokenizer implements Function> { - private Set ops; - private Set reserved; - private TestContext ctx; + private final Set ops; + private final Set reserved; + private final TestContext ctx; - public Tokenizer(Set operators, Set reservedWords, TestContext context) { + public Tokenizer(final Set operators, final Set reservedWords, final TestContext context) { ops = operators; reserved = reservedWords; ctx = context; } @Override - public Token apply(String strang) { - if (ops.contains(strang) || reserved.contains(strang)) { + public Token apply(final String strang) { + if (ops.contains(strang) || reserved.contains(strang)) return litToken(strang); - } else if (ctx.scopes.top().containsKey(strang)) { + else if (ctx.scopes.top().containsKey(strang)) return new StringToken("(vref)", strang); - } else if(strang.matches("(?:[\\u00B2\\u00B3\\u00B9\\u2070]|[\\u2074-\\u2079])+")) { - /* - * This regular expression matches series of unicode super-scripts 1-9. - */ + else if (strang.matches("(?:[\\u00B2\\u00B3\\u00B9\\u2070]|[\\u2074-\\u2079])+")) /* + * This + * regular + * expression + * matches + * series + * of + * unicode + * super + * - + * scripts + * 1 + * - + * 9. + */ return new StringToken("(superexp)", strang); - } else { - return new StringToken("(literal)", strang); - } + else return new StringToken("(literal)", strang); } } diff --git a/JPratt/src/examples/java/bjc/pratt/examples/VarCommand.java b/JPratt/src/examples/java/bjc/pratt/examples/VarCommand.java index dd04a59..a194b72 100644 --- a/JPratt/src/examples/java/bjc/pratt/examples/VarCommand.java +++ b/JPratt/src/examples/java/bjc/pratt/examples/VarCommand.java @@ -11,11 +11,11 @@ import bjc.utils.parserutils.ParserException; class VarCommand extends AbstractInitialCommand { @Override - protected ITree> intNullDenotation(Token operator, - ParserContext ctx) throws ParserException { - Token name = ctx.tokens.current(); + protected ITree> intNullDenotation(final Token operator, + final ParserContext ctx) throws ParserException { + final Token name = ctx.tokens.current(); - switch(name.getKey()) { + switch (name.getKey()) { case "(literal)": case "(vref)": ctx.tokens.next(); @@ -26,7 +26,7 @@ class VarCommand extends AbstractInitialCommand { ctx.tokens.expect("="); - ITree> body = ctx.parse.parseExpression(0, ctx.tokens, ctx.state, false); + final ITree> body = ctx.parse.parseExpression(0, ctx.tokens, ctx.state, false); ctx.state.scopes.top().putKey(name.getValue(), body); -- cgit v1.2.3