/** create a parser to parse the grammar with start symbol <tt>u</tt> */
protected Parser(Union u) { this.pt = new Table(u, top()); }
- //protected Parser(Table pt) { this.pt = pt; }
+ protected Parser(Table pt) { this.pt = pt; }
/** implement this method to create the output forest corresponding to a lone shifted input token */
public abstract Forest<R> shiftedToken(T t, Token.Location loc);
/** this method must return an empty topology of the input token type */
public abstract Topology<T> top();
- /** parse <tt>input</tt> for a exactly one unique result, throwing <tt>Ambiguous</tt> if not unique or <tt>ParseFailed</tt> if none */
- public Tree<R> parse1(Token.Stream<T> input) throws IOException, ParseFailed, Ambiguous {
- Forest<R> ret = parse(input);
- try { return ret.expand1(); }
- catch (Ambiguous a) {
- System.out.println("while expanding:");
- System.out.println(ret);
- throw a;
- }
- }
-
/** parse <tt>input</tt>, using the table <tt>pt</tt> to drive the parser */
public Forest<R> parse(Token.Stream<T> input) throws IOException, ParseFailed {
GSS gss = new GSS();
current = next;
}
}
-
-
- // Exceptions //////////////////////////////////////////////////////////////////////////////
-
// Table //////////////////////////////////////////////////////////////////////////////
public final Walk.Cache cache = this;
- public HashMapBag<Position,State> byPosition = new HashMapBag<Position,State>();
-
private void walk(Element e, HashSet<Element> hs) {
if (e==null) return;
if (hs.contains(e)) return;
HashSet<Element> all_elements = new HashSet<Element>();
walk(start0, all_elements);
for(Element e : all_elements)
- cache.ys.put(e, new Walk.YieldSet(e, cache).walk());
+ cache.ys.addAll(e, new Walk.YieldSet(e, cache).walk());
HashSet<Position> hp = new HashSet<Position>();
reachable(start0, hp);
this.start = new State(hp, all_states, all_elements);
// register ourselves in the all_states hash so that no
// two states are ever created with an identical position set
all_states.put(hs, this);
- for(Position p : hs) byPosition.add(p,this);
// Step 1a: examine all Position's in this state and compute the mappings from
// sets of follow tokens (tokens which could follow this position) to sets
// "yields" [in one or more step] is used instead of "produces" [in exactly one step]
// to avoid having to iteratively construct our set of States as shown in most
// expositions of the algorithm (ie "keep doing XYZ until things stop changing").
- /*
- for(Element e : all_elements) {
- if (e instanceof Atom) continue;
- HashSet<Position> h = new Walk.Closure(null, g.cache).closure(e, hs);
- State s = all_states.get(h) == null ? new State(h, all_states, all_elements) : all_states.get(h);
- if (gotoSetNonTerminals.get(e) != null)
- throw new Error("this should not happen");
- gotoSetNonTerminals.put(e, s);
- }
- */
HashMapBag<Element,Position> move = new HashMapBag<Element,Position>();
for(Position p : hs) {
Element e = p.element();
if (e==null) continue;
- HashSet<Element> ys = cache.ys.get(e);
- if (ys != null) {
- for(Element y : ys) {
- HashSet<Position> hp = new HashSet<Position>();
- reachable(p.next(), hp);
- move.addAll(y, hp);
- }
+ for(Element y : cache.ys.getAll(e)) {
+ HashSet<Position> hp = new HashSet<Position>();
+ reachable(p.next(), hp);
+ move.addAll(y, hp);
}
}
for(Element y : move) {
package edu.berkeley.sbp;
-import edu.berkeley.sbp.util.*;
-import edu.berkeley.sbp.*;
import edu.berkeley.sbp.*;
+import edu.berkeley.sbp.util.*;
import edu.berkeley.sbp.Sequence.Position;
import java.io.*;
import java.util.*;
if (top==null) continue;
if (!(top.containsAll(((Atom)e)))) continue;
} else {
- if (c.ys.get(pos.element()).contains(e)) good = true;
+ if (c.ys.contains(pos.element(),e)) good = true;
}
if (good) {
mp = pos;
public final HashMap<Element,Boolean> possiblyEpsilon = new HashMap<Element,Boolean>();
public HashMap<Element,Boolean> eof = new HashMap<Element,Boolean>();
public HashMap<Element,Topology> follow = new HashMap<Element,Topology>();
- public HashMap<Element,HashSet<Element>> ys = new HashMap<Element,HashSet<Element>>();
+ //public HashMap<Element,HashSet<Element>> ys = new HashMap<Element,HashSet<Element>>();
+ public HashMapBag<Element,Element> ys = new HashMapBag<Element,Element>();
public HashMap<Element,Topology> atoms = new HashMap<Element,Topology>();
}
}
//MetaGrammar mg0 = new MetaGrammar();
//mg0.walk(MetaGrammar.meta);
//System.out.println(mg0);
- Tree<String> res = new CharToken.CharToStringParser(MetaGrammar.make()).parse1(new CharToken.Stream(new InputStreamReader(new FileInputStream(s[0]))));
+ Tree<String> res = new CharToken.CharToStringParser(MetaGrammar.make()).parse(new CharToken.Stream(new InputStreamReader(new FileInputStream(s[0])))).expand1();
MetaGrammar mg = (MetaGrammar)new MetaGrammar().walk(res);
//System.out.println(mg);
Union meta = mg.done();
SequenceInputStream sis = new SequenceInputStream(new FileInputStream(s[0]), new FileInputStream(s[1]));
- res = new CharToken.CharToStringParser(meta).parse1(new CharToken.Stream(new InputStreamReader(sis), "parsing " + s[1] + " using " + s[0]));
+ res = new CharToken.CharToStringParser(meta).parse(new CharToken.Stream(new InputStreamReader(sis), "parsing " + s[1] + " using " + s[0])).expand1();
Union testcasegrammar = ((MetaGrammar)new MetaGrammar("ts").walk(res)).done("ts");
if (testcasegrammar==null) return;
CharToken.Stream cs = new CharToken.Stream(new InputStreamReader(new FileInputStream(s[2])), "parsing " + s[2] + " using " + s[1]);
projects / sbp.git / commitdiff