From 42990231fee502552b769b9af4c04ac0dcaeb195 Mon Sep 17 00:00:00 2001 From: bculkin2442 Date: Sat, 25 Mar 2017 19:13:42 -0400 Subject: Update Pratt parser --- .../parserutils/pratt/blocks/ParseBlocks.java | 13 +++ .../pratt/blocks/RepeatingParseBlock.java | 96 ++++++++++++++++++++ .../parserutils/pratt/blocks/SimpleParseBlock.java | 101 +++++++++++++++++++++ .../pratt/blocks/TriggeredParseBlock.java | 61 +++++++++++++ 4 files changed, 271 insertions(+) create mode 100644 BJC-Utils2/src/main/java/bjc/utils/parserutils/pratt/blocks/ParseBlocks.java create mode 100644 BJC-Utils2/src/main/java/bjc/utils/parserutils/pratt/blocks/RepeatingParseBlock.java create mode 100644 BJC-Utils2/src/main/java/bjc/utils/parserutils/pratt/blocks/SimpleParseBlock.java create mode 100644 BJC-Utils2/src/main/java/bjc/utils/parserutils/pratt/blocks/TriggeredParseBlock.java (limited to 'BJC-Utils2/src/main/java/bjc/utils/parserutils/pratt/blocks') diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/pratt/blocks/ParseBlocks.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/pratt/blocks/ParseBlocks.java new file mode 100644 index 0000000..43163e6 --- /dev/null +++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/pratt/blocks/ParseBlocks.java @@ -0,0 +1,13 @@ +package bjc.utils.parserutils.pratt.blocks; + +import bjc.utils.parserutils.pratt.ParseBlock; + +/** + * Utility class for creating common implementations of {@link ParseBlock} + * + * @author bjculkin + * + */ +public class ParseBlocks { + +} diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/pratt/blocks/RepeatingParseBlock.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/pratt/blocks/RepeatingParseBlock.java new file mode 100644 index 0000000..08a4bae --- /dev/null +++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/pratt/blocks/RepeatingParseBlock.java @@ -0,0 +1,96 @@ +package bjc.utils.parserutils.pratt.blocks; + +import java.util.function.UnaryOperator; + +import bjc.utils.data.ITree; +import bjc.utils.data.Tree; +import bjc.utils.parserutils.ParserException; +import bjc.utils.parserutils.pratt.ParseBlock; +import bjc.utils.parserutils.pratt.ParserContext; +import bjc.utils.parserutils.pratt.Token; + +/** + * A parse block that can parse a sequnce of zero or more occurances of another + * block. + * + * @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 RepeatingParseBlock implements ParseBlock { + private ParseBlock innerBlock; + + private K delim; + private K term; + + private UnaryOperator onDelim; + + private Token mark; + + /** + * Create a new repeating block. + * + * @param inner + * The inner block for elements. + * + * @param delimiter + * The token that delimits elements in the sequence. + * + * @param terminator + * The token that terminates the sequence. + * + * @param marker + * The token to use as the node in the AST. + * + * @param action + * The action to apply to the state after every + * delimiter. + */ + public RepeatingParseBlock(ParseBlock inner, K delimiter, K terminator, Token marker, + UnaryOperator action) { + super(); + + if (inner == null) + throw new NullPointerException("Inner block must not be null"); + else if (delimiter == null) + throw new NullPointerException("Delimiter must not be null"); + else if (terminator == null) throw new NullPointerException("Terminator must not be null"); + + innerBlock = inner; + + delim = delimiter; + term = terminator; + + mark = marker; + + onDelim = action; + } + + @Override + public ITree> parse(ParserContext ctx) throws ParserException { + ITree> ret = new Tree<>(mark); + + Token tok = ctx.tokens.current(); + + while (!tok.getKey().equals(term)) { + ITree> kid = innerBlock.parse(ctx); + ret.addChild(kid); + + tok = ctx.tokens.current(); + + ctx.tokens.expect(delim, term); + + if (onDelim != null) ctx.state = onDelim.apply(ctx.state); + } + + return ret; + } + +} diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/pratt/blocks/SimpleParseBlock.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/pratt/blocks/SimpleParseBlock.java new file mode 100644 index 0000000..c2e9e54 --- /dev/null +++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/pratt/blocks/SimpleParseBlock.java @@ -0,0 +1,101 @@ +package bjc.utils.parserutils.pratt.blocks; + +import java.util.function.Predicate; + +import bjc.utils.data.ITree; +import bjc.utils.parserutils.ParserException; +import bjc.utils.parserutils.pratt.ParseBlock; +import bjc.utils.parserutils.pratt.ParserContext; +import bjc.utils.parserutils.pratt.Token; + +/** + * Simple implementation of {@link ParseBlock} + * + * @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 SimpleParseBlock implements ParseBlock { + private int pow; + + private K term; + + private Predicate>> validatr; + + /** + * Create a new block. + * + * @param precedence + * The precedence of this block. + * + * @param terminator + * The token type that terminates the block. If this is + * null, don't check for a terminator. + * + * @param validator + * The predicate to apply to blocks. + */ + public SimpleParseBlock(int precedence, K terminator, Predicate>> validator) { + if (precedence < 0) throw new IllegalArgumentException("Precedence must be non-negative"); + + pow = precedence; + term = terminator; + validatr = validator; + } + + @Override + public ITree> parse(ParserContext ctx) throws ParserException { + ITree> res = ctx.parse.parseExpression(pow, ctx.tokens, ctx.state, false); + + if (term != null) { + ctx.tokens.expect(term); + } + + if (validatr == null || validatr.test(res)) { + return res; + } + + throw new ParserException("Block failed validation"); + } + + @Override + public int hashCode() { + final int prime = 31; + + int result = 1; + + result = prime * result + pow; + result = prime * result + ((term == null) ? 0 : term.hashCode()); + + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) return true; + if (obj == null) return false; + if (!(obj instanceof SimpleParseBlock)) return false; + + SimpleParseBlock other = (SimpleParseBlock) obj; + + if (pow != other.pow) return false; + + if (term == null) { + if (other.term != null) return false; + } else if (!term.equals(other.term)) return false; + + return true; + } + + @Override + public String toString() { + return String.format("ParseBlock [pow=%s, term='%s']", pow, term); + } +} \ No newline at end of file diff --git a/BJC-Utils2/src/main/java/bjc/utils/parserutils/pratt/blocks/TriggeredParseBlock.java b/BJC-Utils2/src/main/java/bjc/utils/parserutils/pratt/blocks/TriggeredParseBlock.java new file mode 100644 index 0000000..fbfc61b --- /dev/null +++ b/BJC-Utils2/src/main/java/bjc/utils/parserutils/pratt/blocks/TriggeredParseBlock.java @@ -0,0 +1,61 @@ +package bjc.utils.parserutils.pratt.blocks; + +import java.util.function.UnaryOperator; + +import bjc.utils.data.ITree; +import bjc.utils.parserutils.ParserException; +import bjc.utils.parserutils.pratt.ParseBlock; +import bjc.utils.parserutils.pratt.ParserContext; +import bjc.utils.parserutils.pratt.Token; + +/** + * A parse block that can adjust the state before handling its context. + * + * @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 TriggeredParseBlock implements ParseBlock { + private UnaryOperator onEnter; + private UnaryOperator onExit; + + private ParseBlock source; + + /** + * Create a new triggered parse block. + * + * @param onEnter + * The action to fire before parsing the block. + * + * @param onExit + * The action to fire after parsing the block. + * + * @param source + * The block to use for parsing. + */ + public TriggeredParseBlock(UnaryOperator onEnter, UnaryOperator onExit, ParseBlock source) { + super(); + this.onEnter = onEnter; + this.onExit = onExit; + this.source = source; + } + + @Override + public ITree> parse(ParserContext ctx) throws ParserException { + C newState = onEnter.apply(ctx.state); + + ParserContext newCtx = new ParserContext<>(ctx.tokens, ctx.parse, newState); + + ITree> res = source.parse(newCtx); + + ctx.state = onExit.apply(newState); + + return res; + } + +} -- cgit v1.2.3