1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
|
package bjc.pratt.blocks;
import java.util.function.Predicate;
import bjc.pratt.ParseBlock;
import bjc.pratt.ParserContext;
import bjc.pratt.Token;
import bjc.utils.data.ITree;
import bjc.utils.parserutils.ParserException;
/**
* Simple implementation of {@link ParseBlock}
*
* @author bjculkin
*
* @param <K>
* The key type of the tokens.
*
* @param <V>
* The value type of the tokens.
*
* @param <C>
* The state type of the parser.
*/
public class SimpleParseBlock<K, V, C> implements ParseBlock<K, V, C> {
private final int pow;
private final K term;
private final Predicate<ITree<Token<K, V>>> 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(final int precedence, final K terminator,
final Predicate<ITree<Token<K, V>>> validator) {
if (precedence < 0) throw new IllegalArgumentException("Precedence must be non-negative");
pow = precedence;
term = terminator;
validatr = validator;
}
@Override
public ITree<Token<K, V>> parse(final ParserContext<K, V, C> ctx) throws ParserException {
final ITree<Token<K, V>> 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(final Object obj) {
if (this == obj) return true;
if (obj == null) return false;
if (!(obj instanceof SimpleParseBlock)) return false;
final 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);
}
}
|
