projects
/
sbp.git
/ commitdiff
commit
grep
author
committer
pickaxe
?
search:
re
summary
|
shortlog
|
log
|
commit
| commitdiff |
tree
raw
|
patch
|
inline
| side by side (parent:
d27d65c
)
use Sequence.Pos rather than Sequence.Position wherever possible
author
adam
<adam@megacz.com>
Sat, 8 Sep 2007 22:30:29 +0000
(18:30 -0400)
committer
adam
<adam@megacz.com>
Sat, 8 Sep 2007 22:30:29 +0000
(18:30 -0400)
darcs-hash:
20070908223029
-5007d-
572944708f6aa09327257fa1c86567e5fce2b94b
.gz
src/edu/berkeley/sbp/GSS.java
patch
|
blob
|
history
src/edu/berkeley/sbp/Grammar.java
patch
|
blob
|
history
src/edu/berkeley/sbp/Node.java
patch
|
blob
|
history
src/edu/berkeley/sbp/ParseFailed.java
patch
|
blob
|
history
src/edu/berkeley/sbp/Parser.java
patch
|
blob
|
history
src/edu/berkeley/sbp/Reduction.java
patch
|
blob
|
history
src/edu/berkeley/sbp/Result.java
patch
|
blob
|
history
src/edu/berkeley/sbp/Sequence.java
patch
|
blob
|
history
diff --git
a/src/edu/berkeley/sbp/GSS.java
b/src/edu/berkeley/sbp/GSS.java
index
32ce6fc
..
7c1fb19
100644
(file)
--- 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.*;
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.*;
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
(file)
--- 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.*;
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.*;
import java.io.*;
import java.util.*;
@@
-47,7
+47,7
@@
abstract class Grammar<Token> {
follow.put(seq, old);
if (eof) followEof.add(seq);
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())) {
all.add(p.element());
if (p.element() instanceof Union)
for(Sequence s2 : ((Union)p.element())) {
@@
-73,7
+73,7
@@
abstract class Grammar<Token> {
Topology ret = seq.follow==null ? emptyTopology().complement() : seq.follow.getTokenTopology();
if (seen.contains(seq)) return ret;
seen.add(seq);
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()))
if (!(p.element() instanceof Union)) continue;
Topology t = emptyTopology();
for(Sequence s : ((Union)p.element()))
@@
-93,7
+93,7
@@
abstract class Grammar<Token> {
Sequence seq = (Sequence)e;
if (seen.contains(seq)) return emptyTopology();
seen.add(seq);
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;
}
ret = ret.union(first(p.element(), seen));
if (!possiblyEpsilon(p.element())) break;
}
@@
-120,14
+120,14
@@
abstract class Grammar<Token> {
else if (e instanceof Sequence) {
ret = true;
Sequence s = (Sequence)e;
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;
}
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());
if (p.isLast()) return true;
if (!possiblyEpsilon(p.element())) return false;
return isRightNullable(p.next());
@@
-141,7
+141,7
@@
abstract class Grammar<Token> {
private void gatherNulledSubsequences(Sequence seq, HashSet<Sequence> eq) {
if (eq.contains(seq)) return;
eq.add(seq);
private void gatherNulledSubsequences(Sequence seq, HashSet<Sequence> 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()))
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<Token> {
}
}
}
}
- // 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();
if (!isRightNullable(mep)) return false;
if (!isRightNullable(himp)) return false;
Sequence me = mep.owner();
@@
-166,7
+166,7
@@
abstract class Grammar<Token> {
return false;
}
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();
if (!isRightNullable(mep)) return false;
if (!isRightNullable(himp)) return false;
Sequence me = mep.owner();
@@
-180,7
+180,7
@@
abstract class Grammar<Token> {
return false;
}
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;
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
(file)
--- 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.*;
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.*;
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
(file)
--- 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.*;
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;
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();
}
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;
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<Pos>)parent.state().positions()) {
boolean go = false;
boolean force = false;
for(Pos pp : (Iterable<Pos>)parent.state().positions()) {
- Position p = (Position)pp;
+ Pos p = (Pos)pp;
if (skip) p = p.next();
int raise = 0;
done = false;
if (skip) p = p.next();
int raise = 0;
done = false;
@@
-106,7
+106,7
@@
public class ParseFailed extends Exception {
static <Tok> void complain(Node n, HashMap<String,HashSet<String>> errors, boolean force, int indent) {
if (touched.contains(n)) return;
touched.add(n);
static <Tok> void complain(Node n, HashMap<String,HashSet<String>> errors, boolean force, int indent) {
if (touched.contains(n)) return;
touched.add(n);
- for(Position p : (Iterable<Position>)n.state()) {
+ for(Pos p : (Iterable<Pos>)n.state()) {
//if (!p.isLast() && !p.next().isLast()) continue;
if (((p.isFirst() || p.isLast()) && !force)/* || p.owner().name==null*/ ||
!important(p)) {
//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
(file)
--- 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;
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.*;
import java.io.*;
import java.util.*;
@@
-279,7
+279,7
@@
public abstract class Parser<Token, NodeType> {
private boolean accept = false;
private VisitableMap<Token,State<Token>> oshifts = null;
private boolean accept = false;
private VisitableMap<Token,State<Token>> oshifts = null;
- private VisitableMap<Token,Pos> oreductions = null;
+ private VisitableMap<Token,Position> oreductions = null;
public final boolean doomed;
// Interface Methods //////////////////////////////////////////////////////////////////////////////
public final boolean doomed;
// Interface Methods //////////////////////////////////////////////////////////////////////////////
@@
-294,11
+294,11
@@
public abstract class Parser<Token, NodeType> {
boolean canReduce(Token t) {
return oreductions != null && (t==null ? eofReductions.size()>0 : oreductions.contains(t)); }
void invokeEpsilonReductions(Token t, Node node) {
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) {
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);
}
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
(file)
--- 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;
// 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<Reduction> {
import edu.berkeley.sbp.Sequence.Pos;
final class Reduction implements Comparable<Reduction> {
diff --git
a/src/edu/berkeley/sbp/Result.java
b/src/edu/berkeley/sbp/Result.java
index
de46cca
..
6054fa1
100644
(file)
--- 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.*;
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.*;
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
(file)
--- a/
src/edu/berkeley/sbp/Sequence.java
+++ b/
src/edu/berkeley/sbp/Sequence.java
@@
-115,8
+115,8
@@
public abstract class Sequence implements Iterable<Element>, SequenceOrElement {
Iterable<Sequence> needs() { return needs; }
Iterable<Sequence> hates() { return hates; }
Iterable<Sequence> needs() { return needs; }
Iterable<Sequence> hates() { return hates; }
- Position firstp() { return firstp; }
- Position lastp() { return firstp().last(); }
+ Pos firstp() { return firstp; }
+ Pos lastp() { return firstp().last(); }
public Iterator<Element> iterator() { return new ArrayIterator<Element>(elements); }
protected Sequence(Element[] elements) {
public Iterator<Element> iterator() { return new ArrayIterator<Element>(elements); }
protected Sequence(Element[] elements) {
@@
-124,18
+124,23
@@
public abstract class Sequence implements Iterable<Element>, SequenceOrElement {
for(int i=0; i<elements.length; i++)
if (elements[i]==null)
throw new RuntimeException("cannot have nulls in a sequence: " + this);
for(int i=0; i<elements.length; i++)
if (elements[i]==null)
throw new RuntimeException("cannot have nulls in a sequence: " + this);
- this.firstp = new Position(0, null);
+ this.firstp = new Position(this, 0, null);
}
abstract Forest epsilonForm(Input.Region loc, Grammar cache);
}
abstract Forest epsilonForm(Input.Region loc, Grammar cache);
- protected abstract <T> Forest<T> postReduce(Input.Region loc, Forest<T>[] args, Position p);
+ protected abstract <T> Forest<T> postReduce(Input.Region loc, Forest<T>[] args, Pos p);
// Position //////////////////////////////////////////////////////////////////////////////
static abstract class Pos implements IntegerMappable, Comparable<Pos>, Serializable {
// Position //////////////////////////////////////////////////////////////////////////////
static abstract class Pos implements IntegerMappable, Comparable<Pos>, Serializable {
+
+ public int ord = -1;
+ public int ord() { return ord; }
+
final Forest[] holder;
final Forest[] holder;
+
Pos(int len) { this.holder = new Forest[len]; }
public abstract int provides();
Pos(int len) { this.holder = new Forest[len]; }
public abstract int provides();
@@
-143,12
+148,21
@@
public abstract class Sequence implements Iterable<Element>, SequenceOrElement {
public abstract int[] hates();
public abstract boolean owner_needed_or_hated();
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 <T> Forest<T> rewrite(Input.Region loc, Grammar cache);
}
/** the imaginary position before or after an element of a sequence; corresponds to an "LR item" */
public abstract int numPops();
public abstract <T> Forest<T> 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(),
/*
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<Element>, SequenceOrElement {
public int ord() { return ord; }
public int numPops() { return pos; }
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; }
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.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;
}
this.prev = prev;
}
@@
-185,14
+201,14
@@
public abstract class Sequence implements Iterable<Element>, SequenceOrElement {
return ord - ((Position)p).ord;
}
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 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 */
/** 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 <tt>this.element()</tt>) */
public Position next() { return next; }
/** the next Position (the Position after <tt>this.element()</tt>) */
public Position next() { return next; }
@@
-217,7
+233,7
@@
public abstract class Sequence implements Iterable<Element>, SequenceOrElement {
public String toString() {
StringBuffer ret = new StringBuffer();
ret.append("<{");
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());
ret.append(' ');
if (p==this) ret.append(" | ");
if (p.element()!=null) ret.append(p.element());