public abstract Element build(Context cx, NonTerminalNode cnt, boolean dropall);
}
+ /** a union, produced by a ( .. | .. | .. ) construct */
private class UnionNode extends ElementNode {
+
+ /** each component of a union is a sequence */
public Seq[][] sequences;
- public String sep = null;
+
+ /** if the union is a NonTerminal specified as Foo*=..., this is true */
public boolean rep;
+
+ /** if the union is a NonTerminal specified as Foo* /ws=..., then this is "ws" */
+ public String sep = null;
+
public UnionNode(Seq seq) { this(new Seq[][] { new Seq[] { seq } }); }
public UnionNode(Seq[][] sequences) { this(sequences, false, null); }
public UnionNode(Seq[][] sequences, boolean rep, String sep) {
}
}
+ /** a NonTerminal is always a union at the top level */
private class NonTerminalNode extends UnionNode {
public boolean alwaysDrop;
public String name = null;
public Element build(Context cx, NonTerminalNode cnt, boolean dropall) { return cx.get(name); }
}
+ /** a sequence */
private class Seq {
+ /** elements of the sequence */
+ ElementNode[] elements;
+ /** follow-set, if explicit */
+ ElementNode follow;
+ /** tag to add when building the AST */
+ String tag = null;
+ /** positive conjuncts */
+ HashSet<Seq> and = new HashSet<Seq>();
+ /** negative conjuncts */
+ HashSet<Seq> not = new HashSet<Seq>();
public boolean alwaysDrop = false;
public boolean isDropped(Context cx) {
if (alwaysDrop) return true;
return false;
return true;
}
- HashSet<Seq> and = new HashSet<Seq>();
- HashSet<Seq> not = new HashSet<Seq>();
- ElementNode[] elements;
- ElementNode follow;
- String tag = null;
public Seq(ElementNode e) { this(new ElementNode[] { e }); }
public Seq(ElementNode[] elements) { this(elements, true); }
public Seq(ElementNode[] el, boolean check) {
}
}
+ /** reference to a NonTerminal by name */
private class ReferenceNode extends ElementNode {
public String nonTerminal;
public boolean parenthesized;
}
}
+ /** a literal string */
private class LiteralNode extends ElementNode {
private String string;
private final String thePrefix = prefix;
public Element build(Context cx, NonTerminalNode cnt, boolean dropall) { return CharAtom.string(string); }
}
+ /** an atom (usually a character class) */
private class AtomNode extends ElementNode {
char[][] ranges;
public AtomNode() { this(new char[0][]); }
}
}
+ /** a repetition */
private class RepeatNode extends ElementNode {
public ElementNode e, sep;
public final boolean zero, many, max;
}
}
+ /** helper class for syntactic constructs that wrap another construct */
private abstract class ElementNodeWrapper extends ElementNode {
protected ElementNode _e;
public ElementNodeWrapper(ElementNode e) { this._e = e; }
public Element build(Context cx, NonTerminalNode cnt, boolean dropall) { return _e.build(cx, cnt, dropall); }
}
+ /** a backtick node indicating that, when building the AST, the node's children should be inserted here */
private class BacktickNode extends ElementNodeWrapper {
public BacktickNode(ElementNode e) { super(e); }
public boolean isLifted() { return true; }
}
+ /** negation */
private class TildeNode extends ElementNodeWrapper {
public TildeNode(ElementNode e) { super(e); }
public Atom toAtom(Context cx) { return (Atom)((Topology<Character>)_e.toAtom(cx).complement()); }