diff options
Diffstat (limited to 'BJC-Utils2')
4 files changed, 167 insertions, 50 deletions
diff --git a/BJC-Utils2/src/examples/java/bjc/utils/examples/parsing/PrattParserTest.java b/BJC-Utils2/src/examples/java/bjc/utils/examples/parsing/PrattParserTest.java index 8634641..b4d40b2 100644 --- a/BJC-Utils2/src/examples/java/bjc/utils/examples/parsing/PrattParserTest.java +++ b/BJC-Utils2/src/examples/java/bjc/utils/examples/parsing/PrattParserTest.java @@ -32,7 +32,7 @@ public class PrattParserTest { * Main method. * * @param args - * Unused CLI arguments. + * Unused CLI arguments. */ public static void main(String[] args) { /* @@ -41,8 +41,10 @@ public class PrattParserTest { Set<String> ops = new LinkedHashSet<>(); ops.add(":="); + ops.addAll(Arrays.asList("||", "&&")); ops.addAll(Arrays.asList("<=", ">=")); + ops.add("."); ops.addAll(Arrays.asList("=", "<", ">")); ops.addAll(Arrays.asList("+", "-", "*", "/")); ops.addAll(Arrays.asList("^", "!")); @@ -53,9 +55,9 @@ public class PrattParserTest { * Reserved words that represent themselves, not literals. */ Set<String> reserved = new LinkedHashSet<>(); - reserved.add("if"); - reserved.add("else"); - + reserved.addAll(Arrays.asList("if", "then", "else")); + reserved.addAll(Arrays.asList("and", "or")); + TokenSplitter split = new TokenSplitter(); ops.forEach(split::addDelimiter); @@ -81,7 +83,7 @@ public class PrattParserTest { */ tokenStream.next(); - ITree<Token<String, String>> tree = parser.parseExpression(0, tokenStream, null); + ITree<Token<String, String>> tree = parser.parseExpression(0, tokenStream, null, true); if (!tokenStream.current().getKey().equals("(end)")) { System.out.println("Multipe expressions on line"); @@ -129,8 +131,8 @@ public class PrattParserTest { /* * Set of which relational operators chain with each other. */ - HashSet<String> chainSet = new HashSet<>(); - chainSet.addAll(Arrays.asList("=", "<", ">", "<=", ">=")); + HashSet<String> relChain = new HashSet<>(); + relChain.addAll(Arrays.asList("=", "<", ">", "<=", ">=")); /* * Token for marking chains. @@ -143,12 +145,18 @@ public class PrattParserTest { parser.addNonInitialCommand(":=", infixNon(10)); - parser.addNonInitialCommand("=", chain(10, chainSet, chainToken)); - parser.addNonInitialCommand("<", chain(10, chainSet, chainToken)); - parser.addNonInitialCommand(">", chain(10, chainSet, chainToken)); - parser.addNonInitialCommand("<=", chain(10, chainSet, chainToken)); - parser.addNonInitialCommand(">=", chain(10, chainSet, chainToken)); - + parser.addNonInitialCommand("and", infixLeft(13)); + parser.addNonInitialCommand("or", infixLeft(13)); + + parser.addNonInitialCommand("=", chain(15, relChain, chainToken)); + parser.addNonInitialCommand("<", chain(15, relChain, chainToken)); + parser.addNonInitialCommand(">", chain(15, relChain, chainToken)); + parser.addNonInitialCommand("<=", chain(15, relChain, chainToken)); + parser.addNonInitialCommand(">=", chain(15, relChain, chainToken)); + + parser.addNonInitialCommand("&&", infixRight(17)); + parser.addNonInitialCommand("||", infixRight(17)); + parser.addNonInitialCommand("+", infixLeft(20)); parser.addNonInitialCommand("-", infixLeft(20)); @@ -159,10 +167,18 @@ public class PrattParserTest { parser.addNonInitialCommand("^", infixRight(50)); + parser.addNonInitialCommand(".", infixLeft(60)); + parser.addNonInitialCommand("[", postCircumfix(60, 0, "]", new StringToken("idx", "idx"))); + parser.addInitialCommand("if", preTernary(0, 0, 0, "then", "else", new StringToken("ifelse", "ifelse"))); + parser.addInitialCommand("(", grouping(0, ")", new StringToken("()", "()"))); + + parser.addInitialCommand("-", unary(30)); + parser.addInitialCommand("(literal)", leaf()); + return parser; } } diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/pratt/LeftCommands.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/pratt/LeftCommands.java index 5844c49..82ec843 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/pratt/LeftCommands.java +++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/pratt/LeftCommands.java @@ -40,7 +40,7 @@ public class LeftCommands { @Override public ITree<Token<K, V>> leftDenote(ITree<Token<K, V>> operand, Token<K, V> operator, ParserContext<K, V, C> ctx) throws ParserException { - ITree<Token<K, V>> opr = ctx.parse.parseExpression(rightBinding(), ctx.tokens, ctx.state); + ITree<Token<K, V>> opr = ctx.parse.parseExpression(rightBinding(), ctx.tokens, ctx.state, false); return new Tree<>(operator, operand, opr); } @@ -101,7 +101,7 @@ public class LeftCommands { @Override public ITree<Token<K, V>> leftDenote(ITree<Token<K, V>> operand, Token<K, V> operator, ParserContext<K, V, C> ctx) throws ParserException { - ITree<Token<K, V>> inside = ctx.parse.parseExpression(insidePrec, ctx.tokens, ctx.state); + ITree<Token<K, V>> inside = ctx.parse.parseExpression(insidePrec, ctx.tokens, ctx.state, false); ctx.tokens.expect(term); @@ -142,11 +142,11 @@ public class LeftCommands { @Override public ITree<Token<K, V>> leftDenote(ITree<Token<K, V>> operand, Token<K, V> operator, ParserContext<K, V, C> ctx) throws ParserException { - ITree<Token<K, V>> inner = ctx.parse.parseExpression(innerExp, ctx.tokens, ctx.state); + ITree<Token<K, V>> inner = ctx.parse.parseExpression(innerExp, ctx.tokens, ctx.state, false); ctx.tokens.expect(term); - ITree<Token<K, V>> outer = ctx.parse.parseExpression(1 + leftBinding(), ctx.tokens, ctx.state); + ITree<Token<K, V>> outer = ctx.parse.parseExpression(1 + leftBinding(), ctx.tokens, ctx.state, false); return new Tree<>(mark, inner, operand, outer); } @@ -176,7 +176,7 @@ public class LeftCommands { @Override public ITree<Token<K, V>> leftDenote(ITree<Token<K, V>> operand, Token<K, V> operator, ParserContext<K, V, C> ctx) throws ParserException { - ITree<Token<K, V>> tree = ctx.parse.parseExpression(1 + leftBinding(), ctx.tokens, ctx.state); + ITree<Token<K, V>> tree = ctx.parse.parseExpression(1 + leftBinding(), ctx.tokens, ctx.state, false); ITree<Token<K, V>> res = new Tree<>(operator, operand, tree); diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/pratt/NullCommands.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/pratt/NullCommands.java index cf57241..f0c2a80 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/pratt/NullCommands.java +++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/pratt/NullCommands.java @@ -16,7 +16,7 @@ public class NullCommands { @Override public ITree<Token<K, V>> nullDenotation(Token<K, V> operator, ParserContext<K, V, C> ctx) throws ParserException { - //tokens.next(); + // tokens.next(); return intNullDenotation(operator, ctx); } @@ -36,16 +36,16 @@ public class NullCommands { @Override protected ITree<Token<K, V>> intNullDenotation(Token<K, V> operator, ParserContext<K, V, C> ctx) throws ParserException { - ITree<Token<K, V>> opr = ctx.parse.parseExpression(nullPwer, ctx.tokens, ctx.state); + ITree<Token<K, V>> opr = ctx.parse.parseExpression(nullPwer, ctx.tokens, ctx.state, false); return new Tree<>(operator, opr); } } private static class GroupingCommand<K, V, C> extends AbstractNullCommand<K, V, C> { - private K term; - private Token<K, V> mark; - private int inner; + private K term; + private Token<K, V> mark; + private int inner; public GroupingCommand(int innerPrec, K terminator, Token<K, V> marker) { inner = innerPrec; @@ -57,7 +57,7 @@ public class NullCommands { @Override protected ITree<Token<K, V>> intNullDenotation(Token<K, V> operator, ParserContext<K, V, C> ctx) throws ParserException { - ITree<Token<K, V>> opr = ctx.parse.parseExpression(inner, ctx.tokens, ctx.state); + ITree<Token<K, V>> opr = ctx.parse.parseExpression(inner, ctx.tokens, ctx.state, false); ctx.tokens.expect(term); @@ -74,11 +74,63 @@ public class NullCommands { } } + private static class ConstantCommand<K, V, C> extends NullCommand<K, V, C> { + private ITree<Token<K, V>> val; + + public ConstantCommand(ITree<Token<K, V>> con) { + val = con; + } + + @Override + public ITree<Token<K, V>> nullDenotation(Token<K, V> operator, ParserContext<K, V, C> ctx) + throws ParserException { + return val; + } + } + + private static class PreTernaryCommand<K, V, C> extends AbstractNullCommand<K, V, C> { + private int cond1; + private int block1; + private int block2; + + private K mark1; + private K mark2; + + private Token<K, V> term; + + public PreTernaryCommand(int cond1, int block1, int block2, K mark1, K mark2, Token<K, V> term) { + super(); + this.cond1 = cond1; + this.block1 = block1; + this.block2 = block2; + this.mark1 = mark1; + this.mark2 = mark2; + this.term = term; + } + + @SuppressWarnings("unchecked") + @Override + protected ITree<Token<K, V>> intNullDenotation(Token<K, V> operator, ParserContext<K, V, C> ctx) + throws ParserException { + ITree<Token<K, V>> cond = ctx.parse.parseExpression(cond1, ctx.tokens, ctx.state, false); + + ctx.tokens.expect(mark1); + + ITree<Token<K, V>> fstBlock = ctx.parse.parseExpression(block1, ctx.tokens, ctx.state, false); + + ctx.tokens.expect(mark2); + + ITree<Token<K, V>> sndBlock = ctx.parse.parseExpression(block2, ctx.tokens, ctx.state, false); + + return new Tree<>(term, cond, fstBlock, sndBlock); + } + } + /** * Create a new unary operator. * * @param precedence - * The precedence of the operator. + * The precedence of the operator. * * @return A command implementing that operator. */ @@ -90,13 +142,13 @@ public class NullCommands { * Create a new grouping operator. * * @param precedence - * The precedence of the expression in the operator. + * The precedence of the expression in the operator. * * @param term - * The type that closes the group. + * The type that closes the group. * * @param mark - * The token for the AST node of the group. + * The token for the AST node of the group. * * @return A command implementing the operator. */ @@ -112,4 +164,44 @@ public class NullCommands { public static <K, V, C> NullCommand<K, V, C> leaf() { return new LeafCommand<>(); } + + /** + * Create a new pre-ternary operator, like an if-then-else statement. + * + * @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 <K, V, C> NullCommand<K, V, C> preTernary(int cond1, int block1, int block2, K mark1, K mark2, + Token<K, V> term) { + return new PreTernaryCommand<>(cond1, block1, block2, mark1, mark2, term); + } + + /** + * Create a new named constant. + * + * @param val + * The value of the constant. + * + * @return A command implementing the constant. + */ + public static <K, V, C> NullCommand<K, V, C> constant(ITree<Token<K, V>> val) { + return new ConstantCommand<>(val); + } } diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/pratt/PrattParser.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/pratt/PrattParser.java index a2cefda..a8c273d 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/parserutils/pratt/PrattParser.java +++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/pratt/PrattParser.java @@ -13,66 +13,75 @@ import java.util.Map; * @author EVE * * @param <K> - * The key type for the tokens. + * The key type for the tokens. * * @param <V> - * The value type for the tokens. + * The value type for the tokens. * * @param <C> - * The state type of the parser. + * The state type of the parser. * * */ public class PrattParser<K, V, C> { - private final LeftCommand<K, V, C> DEFAULT_LEFT_COMMAND = new DefaultLeftCommand<>(); - private final NullCommand<K, V, C> DEFAULT_NULL_COMMAND = new DefaultNullCommand<>(); + private final LeftCommand<K, V, C> DEFAULT_LEFT_COMMAND = new DefaultLeftCommand<>(); + private final NullCommand<K, V, C> DEFAULT_NULL_COMMAND = new DefaultNullCommand<>(); - private Map<K, LeftCommand<K, V, C>> leftCommands; - private Map<K, NullCommand<K, V, C>> nullCommands; + private Map<K, LeftCommand<K, V, C>> leftCommands; + private Map<K, NullCommand<K, V, C>> nullCommands; + private Map<K, NullCommand<K, V, C>> statementCommands; /** * Create a new Pratt parser. * * @param terminal - * The terminal symbol. + * The terminal symbol. */ public PrattParser() { leftCommands = new HashMap<>(); nullCommands = new HashMap<>(); + statementCommands = new HashMap<>(); } /** * Parse an expression. * * @param precedence - * The initial precedence for the expression. + * The initial precedence for the expression. * * @param tokens - * The tokens for the expression. + * The tokens for the expression. * * @param state - * The state of the parser. + * The state of the parser. * * @return The expression as an AST. * * @throws ParserException - * If something goes wrong during parsing. + * If something goes wrong during parsing. */ - public ITree<Token<K, V>> parseExpression(int precedence, TokenStream<K, V> tokens, C state) + public ITree<Token<K, V>> parseExpression(int precedence, TokenStream<K, V> tokens, C state, boolean isStatement) throws ParserException { - if(precedence < 0) { + if (precedence < 0) { throw new IllegalArgumentException("Precedence must be greater than zero"); } Token<K, V> initToken = tokens.current(); tokens.next(); - ITree<Token<K, V>> ast = nullCommands.getOrDefault(initToken.getKey(), DEFAULT_NULL_COMMAND) - .nullDenotation(initToken, new ParserContext<>(tokens, this, state)); + ITree<Token<K, V>> ast; + + if (isStatement && statementCommands.containsKey(initToken.getKey())) { + ast = statementCommands.getOrDefault(initToken.getKey(), DEFAULT_NULL_COMMAND).nullDenotation(initToken, + new ParserContext<>(tokens, this, state)); + } else { + ast = nullCommands.getOrDefault(initToken.getKey(), DEFAULT_NULL_COMMAND).nullDenotation(initToken, + new ParserContext<>(tokens, this, state)); + } int rightPrec = Integer.MAX_VALUE; - while(true) { + while (true) { Token<K, V> tok = tokens.current(); K key = tok.getKey(); @@ -80,7 +89,7 @@ public class PrattParser<K, V, C> { LeftCommand<K, V, C> command = leftCommands.getOrDefault(key, DEFAULT_LEFT_COMMAND); int leftBind = command.leftBinding(); - if(NumberUtils.between(precedence, rightPrec, leftBind)) { + if (NumberUtils.between(precedence, rightPrec, leftBind)) { tokens.next(); ast = command.leftDenote(ast, tok, new ParserContext<>(tokens, this, state)); @@ -97,10 +106,10 @@ public class PrattParser<K, V, C> { * Add a non-initial command to this parser. * * @param marker - * The key that marks the command. + * The key that marks the command. * * @param comm - * The command. + * The command. */ public void addNonInitialCommand(K marker, LeftCommand<K, V, C> comm) { leftCommands.put(marker, comm); @@ -110,10 +119,10 @@ public class PrattParser<K, V, C> { * Add a initial command to this parser. * * @param marker - * The key that marks the command. + * The key that marks the command. * * @param comm - * The command. + * The command. */ public void addInitialCommand(K marker, NullCommand<K, V, C> comm) { nullCommands.put(marker, comm); |