From: adam Date: Sat, 8 Sep 2007 22:30:29 +0000 (-0400) Subject: use Sequence.Pos rather than Sequence.Position wherever possible X-Git-Url: http://git.megacz.com/?p=sbp.git;a=commitdiff_plain;h=93b9f1a57460257f71a4cef17419a723e294550d;ds=sidebyside use Sequence.Pos rather than Sequence.Position wherever possible darcs-hash:20070908223029-5007d-572944708f6aa09327257fa1c86567e5fce2b94b.gz --- diff --git a/src/edu/berkeley/sbp/GSS.java b/src/edu/berkeley/sbp/GSS.java index 32ce6fc..7c1fb19 100644 --- a/src/edu/berkeley/sbp/GSS.java +++ b/src/edu/berkeley/sbp/GSS.java @@ -4,7 +4,7 @@ package edu.berkeley.sbp; import edu.berkeley.sbp.*; import edu.berkeley.sbp.util.*; import edu.berkeley.sbp.Parser.Table.*; -import edu.berkeley.sbp.Sequence.Position; +import edu.berkeley.sbp.Sequence.Pos; import edu.berkeley.sbp.Sequence.Pos; import java.io.*; import java.util.*; diff --git a/src/edu/berkeley/sbp/Grammar.java b/src/edu/berkeley/sbp/Grammar.java index 6174b36..d04ec0a 100644 --- a/src/edu/berkeley/sbp/Grammar.java +++ b/src/edu/berkeley/sbp/Grammar.java @@ -2,7 +2,7 @@ package edu.berkeley.sbp; import edu.berkeley.sbp.util.*; -import edu.berkeley.sbp.Sequence.Position; +import edu.berkeley.sbp.Sequence.Pos; import java.io.*; import java.util.*; @@ -47,7 +47,7 @@ abstract class Grammar { follow.put(seq, old); if (eof) followEof.add(seq); - for(Position p = seq.firstp().last().prev(); p!=null; p = p.prev()) { + for(Pos p = seq.firstp().last().prev(); p!=null; p = p.prev()) { all.add(p.element()); if (p.element() instanceof Union) for(Sequence s2 : ((Union)p.element())) { @@ -73,7 +73,7 @@ abstract class Grammar { Topology ret = seq.follow==null ? emptyTopology().complement() : seq.follow.getTokenTopology(); if (seen.contains(seq)) return ret; seen.add(seq); - for(Position p = seq.firstp(); p!=null && !p.isLast(); p = p.next()) { + for(Pos p = seq.firstp(); p!=null && !p.isLast(); p = p.next()) { if (!(p.element() instanceof Union)) continue; Topology t = emptyTopology(); for(Sequence s : ((Union)p.element())) @@ -93,7 +93,7 @@ abstract class Grammar { Sequence seq = (Sequence)e; if (seen.contains(seq)) return emptyTopology(); seen.add(seq); - for(Position p = seq.firstp(); p!=null && !p.isLast(); p = p.next()) { + for(Pos p = seq.firstp(); p!=null && !p.isLast(); p = p.next()) { ret = ret.union(first(p.element(), seen)); if (!possiblyEpsilon(p.element())) break; } @@ -120,14 +120,14 @@ abstract class Grammar { else if (e instanceof Sequence) { ret = true; Sequence s = (Sequence)e; - for(Position p = s.firstp(); p!=null && !p.isLast(); p = p.next()) + for(Pos p = s.firstp(); p!=null && !p.isLast(); p = p.next()) ret &= possiblyEpsilon(p.element(), hm); } hm.put(e, ret); return ret; } - public boolean isRightNullable(Position p) { + public boolean isRightNullable(Pos p) { if (p.isLast()) return true; if (!possiblyEpsilon(p.element())) return false; return isRightNullable(p.next()); @@ -141,7 +141,7 @@ abstract class Grammar { private void gatherNulledSubsequences(Sequence seq, HashSet eq) { if (eq.contains(seq)) return; eq.add(seq); - Position p = seq.firstp(); + Pos p = seq.firstp(); for(; !p.isLast(); p = p.next()) { if (!p.isLast() && isRightNullable(p.next()) && p.element() instanceof Union) for(Sequence s : ((Union)p.element())) @@ -150,9 +150,9 @@ abstract class Grammar { } } - // Position Ordinality Comparisons ////////////////////////////////////////////////////////////////////////////// + // Pos Ordinality Comparisons ////////////////////////////////////////////////////////////////////////////// - public boolean canKill(Position mep, Position himp) { + public boolean canKill(Pos mep, Pos himp) { if (!isRightNullable(mep)) return false; if (!isRightNullable(himp)) return false; Sequence me = mep.owner(); @@ -166,7 +166,7 @@ abstract class Grammar { return false; } - public boolean canNeed(Position mep, Position himp) { + public boolean canNeed(Pos mep, Pos himp) { if (!isRightNullable(mep)) return false; if (!isRightNullable(himp)) return false; Sequence me = mep.owner(); @@ -180,7 +180,7 @@ abstract class Grammar { return false; } - public int comparePositions(Position position, Position rposition) { + public int comparePositions(Pos position, Pos rposition) { int ret = 0; if (canKill(position, rposition) && canKill(rposition, position)) throw new Error(); if (canKill(position, rposition)) ret = -1; diff --git a/src/edu/berkeley/sbp/Node.java b/src/edu/berkeley/sbp/Node.java index 9210e75..93548fe 100644 --- a/src/edu/berkeley/sbp/Node.java +++ b/src/edu/berkeley/sbp/Node.java @@ -4,7 +4,7 @@ package edu.berkeley.sbp; import edu.berkeley.sbp.*; import edu.berkeley.sbp.util.*; import edu.berkeley.sbp.Parser.Table.*; -import edu.berkeley.sbp.Sequence.Position; +import edu.berkeley.sbp.Sequence.Pos; import edu.berkeley.sbp.Sequence.Pos; import java.io.*; import java.util.*; diff --git a/src/edu/berkeley/sbp/ParseFailed.java b/src/edu/berkeley/sbp/ParseFailed.java index 8936184..7a3416e 100644 --- a/src/edu/berkeley/sbp/ParseFailed.java +++ b/src/edu/berkeley/sbp/ParseFailed.java @@ -2,7 +2,7 @@ package edu.berkeley.sbp; import edu.berkeley.sbp.*; -import edu.berkeley.sbp.Sequence.Position; +import edu.berkeley.sbp.Sequence.Pos; import edu.berkeley.sbp.Sequence.Pos; import edu.berkeley.sbp.GSS.Phase; import edu.berkeley.sbp.Node; @@ -35,7 +35,7 @@ public class ParseFailed extends Exception { return ret.toString(); } - private static boolean important(Position p) { + private static boolean important(Pos p) { if (p.isLast()) return false; if (p.element() == null) return false; if (!(p.element() instanceof Union)) return false; @@ -69,7 +69,7 @@ public class ParseFailed extends Exception { boolean go = false; boolean force = false; for(Pos pp : (Iterable)parent.state().positions()) { - Position p = (Position)pp; + Pos p = (Pos)pp; if (skip) p = p.next(); int raise = 0; done = false; @@ -106,7 +106,7 @@ public class ParseFailed extends Exception { static void complain(Node n, HashMap> errors, boolean force, int indent) { if (touched.contains(n)) return; touched.add(n); - for(Position p : (Iterable)n.state()) { + for(Pos p : (Iterable)n.state()) { //if (!p.isLast() && !p.next().isLast()) continue; if (((p.isFirst() || p.isLast()) && !force)/* || p.owner().name==null*/ || !important(p)) { diff --git a/src/edu/berkeley/sbp/Parser.java b/src/edu/berkeley/sbp/Parser.java index 422bdc1..c37d1a8 100644 --- a/src/edu/berkeley/sbp/Parser.java +++ b/src/edu/berkeley/sbp/Parser.java @@ -3,7 +3,7 @@ package edu.berkeley.sbp; import edu.berkeley.sbp.util.*; import edu.berkeley.sbp.Sequence.Position; -import edu.berkeley.sbp.Sequence.Pos; +import edu.berkeley.sbp.Sequence.Position; import java.io.*; import java.util.*; @@ -279,7 +279,7 @@ public abstract class Parser { private boolean accept = false; private VisitableMap> oshifts = null; - private VisitableMap oreductions = null; + private VisitableMap oreductions = null; public final boolean doomed; // Interface Methods ////////////////////////////////////////////////////////////////////////////// @@ -294,11 +294,11 @@ public abstract class Parser { boolean canReduce(Token t) { return oreductions != null && (t==null ? eofReductions.size()>0 : oreductions.contains(t)); } void invokeEpsilonReductions(Token t, Node node) { - if (t==null) for(Pos r : eofReductions) node.invoke(r, null); + if (t==null) for(Position r : eofReductions) node.invoke(r, null); else oreductions.invoke(t, node, null); } void invokeReductions(Token t, Node node, Result b) { - if (t==null) for(Pos r : eofReductions) node.invoke(r, b); + if (t==null) for(Position r : eofReductions) node.invoke(r, b); else oreductions.invoke(t, node, b); } diff --git a/src/edu/berkeley/sbp/Reduction.java b/src/edu/berkeley/sbp/Reduction.java index 71abf53..cdf681d 100644 --- a/src/edu/berkeley/sbp/Reduction.java +++ b/src/edu/berkeley/sbp/Reduction.java @@ -1,7 +1,7 @@ // Copyright 2006-2007 all rights reserved; see LICENSE file for BSD-style license package edu.berkeley.sbp; -import edu.berkeley.sbp.Sequence.Position; +import edu.berkeley.sbp.Sequence.Pos; import edu.berkeley.sbp.Sequence.Pos; final class Reduction implements Comparable { diff --git a/src/edu/berkeley/sbp/Result.java b/src/edu/berkeley/sbp/Result.java index de46cca..6054fa1 100644 --- a/src/edu/berkeley/sbp/Result.java +++ b/src/edu/berkeley/sbp/Result.java @@ -2,7 +2,7 @@ package edu.berkeley.sbp; import edu.berkeley.sbp.util.*; -import edu.berkeley.sbp.Sequence.Position; +import edu.berkeley.sbp.Sequence.Pos; import edu.berkeley.sbp.Sequence.Pos; import java.util.*; diff --git a/src/edu/berkeley/sbp/Sequence.java b/src/edu/berkeley/sbp/Sequence.java index 79854c6..eff94a4 100644 --- a/src/edu/berkeley/sbp/Sequence.java +++ b/src/edu/berkeley/sbp/Sequence.java @@ -115,8 +115,8 @@ public abstract class Sequence implements Iterable, SequenceOrElement { Iterable needs() { return needs; } Iterable hates() { return hates; } - Position firstp() { return firstp; } - Position lastp() { return firstp().last(); } + Pos firstp() { return firstp; } + Pos lastp() { return firstp().last(); } public Iterator iterator() { return new ArrayIterator(elements); } protected Sequence(Element[] elements) { @@ -124,18 +124,23 @@ public abstract class Sequence implements Iterable, SequenceOrElement { for(int i=0; i Forest postReduce(Input.Region loc, Forest[] args, Position p); + protected abstract Forest postReduce(Input.Region loc, Forest[] args, Pos p); // Position ////////////////////////////////////////////////////////////////////////////// static abstract class Pos implements IntegerMappable, Comparable, Serializable { + + public int ord = -1; + public int ord() { return ord; } + final Forest[] holder; + Pos(int len) { this.holder = new Forest[len]; } public abstract int provides(); @@ -143,12 +148,21 @@ public abstract class Sequence implements Iterable, SequenceOrElement { public abstract int[] hates(); public abstract boolean owner_needed_or_hated(); + public abstract boolean isFirst(); + public abstract boolean isLast(); + public abstract Pos last(); + public abstract Pos prev(); + public abstract Pos next(); + + abstract Sequence owner(); + abstract Element element(); + public abstract int numPops(); public abstract Forest rewrite(Input.Region loc, Grammar cache); } /** the imaginary position before or after an element of a sequence; corresponds to an "LR item" */ - class Position extends Pos implements IntegerMappable { + private static class Position extends Pos implements IntegerMappable { /* public Pos getPos() { return new DumbPos(elements.length, provides(), needs(), hates(), owner_needed_or_hated(), numPops(), @@ -165,19 +179,21 @@ public abstract class Sequence implements Iterable, SequenceOrElement { public int ord() { return ord; } public int numPops() { return pos; } - final int pos; - private final Position next; - private final Position prev; + final int pos; + private final Position next; + private final Position prev; + private transient Sequence owner; public int provides() { return owner().sernum; } public int[] needs() { return owner().needs_int(); } public int[] hates() { return owner().hates_int(); } public boolean owner_needed_or_hated() { return owner().needed_or_hated; } - private Position(int pos, Position prev) { - super(elements.length); + private Position(Sequence owner, int pos, Position prev) { + super(owner.elements.length); + this.owner = owner; this.pos = pos; - this.next = pos==elements.length ? null : new Position(pos+1, this); + this.next = pos==owner.elements.length ? null : new Position(owner, pos+1, this); this.prev = prev; } @@ -185,14 +201,14 @@ public abstract class Sequence implements Iterable, SequenceOrElement { return ord - ((Position)p).ord; } - boolean isFirst() { return pos==0; } + public boolean isFirst() { return pos==0; } public int pos() { return pos; } /** the element immediately after this Position, or null if this is the last Position */ - public Element element() { return pos>=elements.length ? null : elements[pos]; } + public Element element() { return pos>=owner().elements.length ? null : owner().elements[pos]; } /** the element which produces the sequence to which this Position belongs */ - public Sequence owner() { return Sequence.this; } + public Sequence owner() { return owner; } /** the next Position (the Position after this.element()) */ public Position next() { return next; } @@ -217,7 +233,7 @@ public abstract class Sequence implements Iterable, SequenceOrElement { public String toString() { StringBuffer ret = new StringBuffer(); ret.append("<{"); - for(Position p = Sequence.this.firstp(); p != null; p = p.next()) { + for(Position p = (Position)owner().firstp(); p != null; p = p.next()) { ret.append(' '); if (p==this) ret.append(" | "); if (p.element()!=null) ret.append(p.element());