use Sequence.Pos rather than Sequence.Position wherever possible

[sbp.git] / src / edu / berkeley / sbp / Grammar.java

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.*;
-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<Token> {
         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<Token> {
         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<Token> {
             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<Token> {
         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<Token> {
     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()))
@@ -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();
@@ -166,7 +166,7 @@ abstract class Grammar<Token> {
         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<Token> {
         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;