From 694bed833470393ee00eae0a85bff0c6c90e692a Mon Sep 17 00:00:00 2001 From: bjculkin Date: Wed, 12 Apr 2017 10:45:46 -0400 Subject: Add support for meta-commands Meta-commands allow you to implement meta-operators, whose behavior changes based off of tokens that follow. --- JPratt/src/main/java/bjc/pratt/PrattParser.java | 119 ++++++++++++++++++------ 1 file changed, 91 insertions(+), 28 deletions(-) (limited to 'JPratt/src/main/java/bjc/pratt/PrattParser.java') diff --git a/JPratt/src/main/java/bjc/pratt/PrattParser.java b/JPratt/src/main/java/bjc/pratt/PrattParser.java index b3ce4a7..e2654f7 100644 --- a/JPratt/src/main/java/bjc/pratt/PrattParser.java +++ b/JPratt/src/main/java/bjc/pratt/PrattParser.java @@ -35,20 +35,25 @@ public class PrattParser { /* * Left-commands that depend on what the null command was. */ - private final Map>> dependantLeftCommands; - + private final Map>> dependantLeftCommands; + private final Map>> dependantMetaLeftCommands; /* * The left commands. */ - private final Map> leftCommands; + private final Map> leftCommands; + private final Map> metaLeftCommands; + /* * The initial commands. */ - private final Map> nullCommands; + private final Map> nullCommands; + private final Map> metaNullCommands; + /* * Initial commands only checked for statements. */ - private final Map> statementCommands; + private final Map> statementCommands; + private final Map> metaStatementCommands; /** * Create a new Pratt parser. @@ -56,10 +61,16 @@ public class PrattParser { */ public PrattParser() { dependantLeftCommands = new HashMap<>(); + dependantMetaLeftCommands = new HashMap<>(); leftCommands = new HashMap<>(); + metaLeftCommands = new HashMap<>(); + nullCommands = new HashMap<>(); + metaNullCommands = new HashMap<>(); + statementCommands = new HashMap<>(); + metaStatementCommands = new HashMap<>(); } /** @@ -84,22 +95,20 @@ public class PrattParser { */ public ITree> parseExpression(final int precedence, final TokenStream tokens, final C state, final boolean isStatement) throws ParserException { - if (precedence < 0) throw new IllegalArgumentException("Precedence must be greater than zero"); + if (precedence < 0) + throw new IllegalArgumentException("Precedence must be greater than zero"); + + ParserContext parserContext = new ParserContext<>(tokens, this, state); final Token initToken = tokens.current(); tokens.next(); final K initKey = initToken.getKey(); - ITree> ast; + InitialCommand nullCommand = getInitialCommand(isStatement, initKey, parserContext); + ITree> ast = nullCommand.denote(initToken, parserContext); - if (isStatement && statementCommands.containsKey(initKey)) { - ast = statementCommands.getOrDefault(initKey, DEFAULT_NULL_COMMAND).denote(initToken, - new ParserContext<>(tokens, this, state)); - } else { - ast = nullCommands.getOrDefault(initKey, DEFAULT_NULL_COMMAND).denote(initToken, - new ParserContext<>(tokens, this, state)); - } + parserContext.initial = initKey; int rightPrec = Integer.MAX_VALUE; @@ -108,19 +117,15 @@ public class PrattParser { final K key = tok.getKey(); - NonInitialCommand command = leftCommands.getOrDefault(key, DEFAULT_LEFT_COMMAND); + NonInitialCommand leftCommand = getNonInitialCommand(key, parserContext); - if (dependantLeftCommands.containsKey(initKey)) { - command = dependantLeftCommands.get(initKey).getOrDefault(key, command); - } - - final int leftBind = command.leftBinding(); + final int leftBind = leftCommand.leftBinding(); if (NumberUtils.between(precedence, rightPrec, leftBind)) { tokens.next(); - ast = command.denote(ast, tok, new ParserContext<>(tokens, this, state)); - rightPrec = command.nextBinding(); + ast = leftCommand.denote(ast, tok, parserContext); + rightPrec = leftCommand.nextBinding(); } else { break; } @@ -184,14 +189,72 @@ public class PrattParser { * The command. */ public void addDependantCommand(final K dependant, final K marker, final NonInitialCommand comm) { - if (dependantLeftCommands.containsKey(dependant)) { - dependantLeftCommands.get(dependant).put(marker, comm); - } else { - final Map> comms = new HashMap<>(); + Map> dependantMap = dependantLeftCommands.getOrDefault(dependant, + new HashMap<>()); + + dependantMap.put(marker, comm); + } + + /** + * Lookup an initial command. + * + * @param isStatement + * Whether to look for statement commands or not. + * + * @param key + * The key of the command. + * + * @param ctx + * The context for meta-commands. + * + * @return A command attached to that key, or a default implementation. + */ + public InitialCommand getInitialCommand(boolean isStatement, K key, ParserContext ctx) { + if (isStatement) { + if (metaStatementCommands.containsKey(key)) + return metaStatementCommands.get(key).getCommand(ctx); + else if (statementCommands.containsKey(key)) + return statementCommands.get(key); + } - comms.put(marker, comm); + if (metaNullCommands.containsKey(key)) + return metaNullCommands.get(key).getCommand(ctx); + else + return nullCommands.getOrDefault(key, DEFAULT_NULL_COMMAND); + } + + /** + * Lookup a non-initial command. + * + * @param key + * The key of the command. + * + * @param ctx + * The context for meta-commands. + * + * @return A command attached to that key, or a default implementation. + */ + public NonInitialCommand getNonInitialCommand(K key, ParserContext ctx) { + if (dependantMetaLeftCommands.containsKey(ctx.initial)) { + Map> dependantCommands = dependantMetaLeftCommands + .get(ctx.initial); - dependantLeftCommands.put(dependant, comms); + if (dependantCommands.containsKey(key)) { + return dependantCommands.get(key).getCommand(ctx); + } + } + + if (dependantLeftCommands.containsKey(ctx.initial)) { + Map> dependantCommands = dependantLeftCommands.get(ctx.initial); + + if (dependantCommands.containsKey(key)) { + return dependantCommands.getOrDefault(key, DEFAULT_LEFT_COMMAND); + } } + + if (metaLeftCommands.containsKey(key)) { + return metaLeftCommands.get(key).getCommand(ctx); + } else + return leftCommands.getOrDefault(key, DEFAULT_LEFT_COMMAND); } } \ No newline at end of file -- cgit v1.2.3