/** a parser which translates streams of Tokens of type T into a Forest<R> */
public abstract class Parser<Tok, Result> {
- private final Table pt;
+ protected final Table<Tok> pt;
/** create a parser to parse the grammar with start symbol <tt>u</tt> */
protected Parser(Union u, Topology<Tok> top) { this.pt = new Table<Tok>(u, top); }
- protected Parser(Table pt) { this.pt = pt; }
+ protected Parser(Table<Tok> pt) { this.pt = pt; }
/** implement this method to create the output forest corresponding to a lone shifted input token */
- public abstract Forest<Result> shiftToken(Tok t, Token.Location loc);
+ public abstract Forest<Result> shiftToken(Tok t, Input.Location loc);
/** parse <tt>input</tt>, using the table <tt>pt</tt> to drive the parser */
- public Forest<Result> parse(Token.Stream<Tok> input) throws IOException, ParseFailed {
+ public Forest<Result> parse(Input<Tok> input) throws IOException, ParseFailed {
GSS gss = new GSS();
- Token.Location loc = input.getLocation();
+ Input.Location loc = input.getLocation();
GSS.Phase current = gss.new Phase<Tok>(null, this, null, input.next(1, 0, 0), loc, null);
current.newNode(null, Forest.leaf(null, null), pt.start, true);
int count = 1;
// Table //////////////////////////////////////////////////////////////////////////////
/** an SLR(1) parse table which may contain conflicts */
- static class Table<Tok> extends Walk.Cache {
+ public static class Table<Tok> extends Walk.Cache {
public final Walk.Cache cache = this;
/** used to generate unique values for State.idx */
private int master_state_idx = 0;
+ HashMap<HashSet<Position>,State<Tok>> all_states = new HashMap<HashSet<Position>,State<Tok>>();
/** construct a parse table for the given grammar */
public Table(Topology top) { this("s", top); }
cache.eof.put(start0, true);
// construct the set of states
- HashMap<HashSet<Position>,State<Tok>> all_states = new HashMap<HashSet<Position>,State<Tok>>();
HashSet<Element> all_elements = new HashSet<Element>();
walk(start0, all_elements);
for(Element e : all_elements)
if (p.element() != null && p.element() instanceof Atom)
state.shifts.addAll(state.gotoSetTerminals.subset(((Atom)p.element())));
}
- for(State<Tok> state : all_states.values()) {
- state.oreductions = state.reductions.optimize();
- state.oshifts = state.shifts.optimize();
- }
+ if (top instanceof IntegerTopology)
+ for(State<Tok> state : all_states.values()) {
+ state.oreductions = state.reductions.optimize(((IntegerTopology)top).functor());
+ state.oshifts = state.shifts.optimize(((IntegerTopology)top).functor());
+ }
}
private boolean isRightNullable(Position p) {