X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=unused%2Fcom%2Fstevesoft%2Fpat%2FFastBracket.java;h=74fae2de13416c5072e207251f4bee1a0a58277e;hb=6319110ce33faa76ee6cf9832e78faa224510fed;hp=a10ec2be0730199d6562670ce9ed60020132bca7;hpb=7301a2415adab88038b291fc54caeeb3a5a47a44;p=jalviewjs.git

diff --git a/unused/com/stevesoft/pat/FastBracket.java b/unused/com/stevesoft/pat/FastBracket.java
index a10ec2b..74fae2d 100644
--- a/unused/com/stevesoft/pat/FastBracket.java
+++ b/unused/com/stevesoft/pat/FastBracket.java
@@ -1,256 +1,256 @@
-//
-// This software is now distributed according to
-// the Lesser Gnu Public License.  Please see
-// http://www.gnu.org/copyleft/lesser.txt for
-// the details.
-//    -- Happy Computing!
-//
-package com.stevesoft.pat;
-
-import java.util.*;
-
-/**
- * Uses table lookup to match [] type constructs, but only if it can use a
- * lookup table 256 bits in size. It is impractical to make a table if it is too
- * large.
- */
-public class FastBracket extends Bracket
-{
-  int min, max;
-
-  BitSet bs;
-
-  FastBracket(boolean n)
-  {
-    super(n);
-  }
-
-  // This routine can optimize a bracket, possibly
-  // it will replace it with a FastBracket.
-  static Bracket process(Bracket b, boolean ignc)
-  {
-    Vector v = b.v;
-    b.pv = null;
-    try
-    {
-
-      // Expand out the vector to make separate
-      // entries for other cases if ignoreCase is
-      // turned on.
-      Vector nv = v;
-      if (ignc)
-      {
-        nv = new Vector();
-        for (int i = 0; i < v.size(); i++)
-        {
-          Pattern p = (Pattern) v.elementAt(i);
-          nv.addElement(p);
-          if (p instanceof oneChar)
-          {
-            oneChar oc = (oneChar) p;
-            nv.addElement(new oneChar(oc.altc));
-          }
-          else if (p instanceof Range)
-          {
-            Range ra = (Range) p;
-            nv.addElement(new Range(ra.altlo, ra.althi));
-          }
-        }
-      }
-      v = nv;
-
-      // Bubble sort, make sure elements
-      // are in order. This will allow us
-      // to merge them.
-      for (int i = 0; i < v.size() - 1; i++)
-      {
-        for (int j = 0; j < v.size() - 1; j++)
-        {
-          char c1 = getl(v.elementAt(j));
-          char c2 = getl(v.elementAt(j + 1));
-          if (c2 < c1)
-          {
-            Object o = v.elementAt(j);
-            v.setElementAt(v.elementAt(j + 1), j);
-            v.setElementAt(o, j + 1);
-          }
-        }
-      }
-
-      nv = new Vector();
-      // merge -- remove overlaps
-      Pattern p = (Pattern) v.elementAt(0);
-      nv.addElement(p);
-      for (int i = 1; i < v.size(); i++)
-      {
-        if (geth(p) + 1 >= getl(v.elementAt(i)))
-        {
-          Pattern p2 = (Pattern) v.elementAt(i);
-          char lo = min(getl(p), getl(p2));
-          char hi = max(geth(p), geth(p2));
-          nv.setElementAt(p = mkelem(lo, hi), nv.size() - 1);
-        }
-        else
-        {
-          p = (Pattern) v.elementAt(i);
-          nv.addElement(p);
-        }
-      }
-
-      b.v = v = nv;
-    } catch (RegSyntax e)
-    {
-      e.printStackTrace();
-    }
-
-    // We don't want these things to be empty.
-    Vector negv = neg(v);
-    if (v.size() == 1)
-    {
-      return b;
-    }
-    if (negv.size() == 1)
-    {
-      b.v = negv;
-      b.neg = !b.neg;
-      return b;
-    }
-
-    // Now consider if we can make a FastBracket.
-    // Uses a BitSet to do a lookup.
-    FastBracket fb = newbrack(v, b.neg);
-    if (fb == null)
-    {
-      fb = newbrack(negv, !b.neg);
-    }
-    if (fb != null)
-    {
-      fb.parent = b.parent;
-      fb.next = b.next;
-      return fb;
-    }
-
-    // return the normal Bracket.
-    return b;
-  }
-
-  // Build a FastBracket and set bits. If this can't
-  // be done, return null.
-  final static FastBracket newbrack(Vector v, boolean neg)
-  {
-    FastBracket fb = new FastBracket(neg);
-    fb.v = v;
-    if (v.size() == 0)
-    {
-      return null;
-    }
-    fb.min = getl(v.elementAt(0));
-    fb.max = geth(v.elementAt(v.size() - 1));
-    if (fb.max - fb.min <= 256)
-    {
-      fb.bs = new BitSet(fb.max - fb.min + 1);
-      for (int i = 0; i < v.size(); i++)
-      {
-        Object o = v.elementAt(i);
-        int min0 = getl(o) - fb.min;
-        int max0 = geth(o) - fb.min;
-        for (int j = min0; j <= max0; j++)
-        {
-          fb.bs.set(j);
-        }
-      }
-      return fb;
-    }
-    return null;
-  }
-
-  // Negate a sorted Vector. Applying this
-  // operation twice should yield the same Vector
-  // back.
-  final static Vector neg(Vector v)
-  {
-    try
-    {
-      Vector nv = new Vector();
-      if (v.size() == 0)
-      {
-        nv.addElement(new Range((char) 0, (char) 65535));
-        return nv;
-      }
-      int p0 = getl(v.elementAt(0));
-      if (p0 != 0)
-      {
-        nv.addElement(mkelem((char) 0, (char) (p0 - 1)));
-      }
-      for (int i = 0; i < v.size() - 1; i++)
-      {
-        int hi = getl(v.elementAt(i + 1)) - 1;
-        int lo = geth(v.elementAt(i)) + 1;
-        nv.addElement(mkelem((char) lo, (char) hi));
-      }
-      int pN = geth(v.lastElement());
-      if (pN != 65535)
-      {
-        nv.addElement(mkelem((char) (pN + 1), (char) 65535));
-      }
-      return nv;
-    } catch (RegSyntax rs)
-    {
-      return null;
-    }
-  }
-
-  // Make either a Range or oneChar Object, depending on which
-  // is appropriate.
-  final static Pattern mkelem(char lo, char hi) throws RegSyntax
-  {
-    return lo == hi ? (Pattern) (new oneChar(lo)) : (Pattern) (new Range(
-            lo, hi));
-  }
-
-  static final char min(char a, char b)
-  {
-    return a < b ? a : b;
-  }
-
-  static final char max(char a, char b)
-  {
-    return a > b ? a : b;
-  }
-
-  // getl -- get lower value of Range object,
-  // or get value of oneChar object.
-  final static char getl(Object o)
-  {
-    Pattern p = (Pattern) o;
-    if (p instanceof Range)
-    {
-      return ((Range) p).lo;
-    }
-    return ((oneChar) p).c;
-  }
-
-  // geth -- get higher value of Range object,
-  // or get value of oneChar object.
-  final static char geth(Object o)
-  {
-    Pattern p = (Pattern) o;
-    if (p instanceof Range)
-    {
-      return ((Range) p).hi;
-    }
-    return ((oneChar) p).c;
-  }
-
-  // This is the easy part!
-  public int matchInternal(int pos, Pthings pt)
-  {
-    if (pos >= pt.src.length() || Masked(pos, pt))
-    {
-      return -1;
-    }
-    char c = pt.src.charAt(pos);
-    return (neg ^ (c >= min && c <= max && bs.get(c - min))) ? nextMatch(
-            pos + 1, pt) : -1;
-  }
-}
+//
+// This software is now distributed according to
+// the Lesser Gnu Public License.  Please see
+// http://www.gnu.org/copyleft/lesser.txt for
+// the details.
+//    -- Happy Computing!
+//
+package com.stevesoft.pat;
+
+import java.util.*;
+
+/**
+ * Uses table lookup to match [] type constructs, but only if it can use a
+ * lookup table 256 bits in size. It is impractical to make a table if it is too
+ * large.
+ */
+public class FastBracket extends Bracket
+{
+  int min, max;
+
+  BitSet bs;
+
+  FastBracket(boolean n)
+  {
+    super(n);
+  }
+
+  // This routine can optimize a bracket, possibly
+  // it will replace it with a FastBracket.
+  static Bracket process(Bracket b, boolean ignc)
+  {
+    Vector v = b.v;
+    b.pv = null;
+    try
+    {
+
+      // Expand out the vector to make separate
+      // entries for other cases if ignoreCase is
+      // turned on.
+      Vector nv = v;
+      if (ignc)
+      {
+        nv = new Vector();
+        for (int i = 0; i < v.size(); i++)
+        {
+          Pattern p = (Pattern) v.elementAt(i);
+          nv.addElement(p);
+          if (p instanceof oneChar)
+          {
+            oneChar oc = (oneChar) p;
+            nv.addElement(new oneChar(oc.altc));
+          }
+          else if (p instanceof Range)
+          {
+            Range ra = (Range) p;
+            nv.addElement(new Range(ra.altlo, ra.althi));
+          }
+        }
+      }
+      v = nv;
+
+      // Bubble sort, make sure elements
+      // are in order. This will allow us
+      // to merge them.
+      for (int i = 0; i < v.size() - 1; i++)
+      {
+        for (int j = 0; j < v.size() - 1; j++)
+        {
+          char c1 = getl(v.elementAt(j));
+          char c2 = getl(v.elementAt(j + 1));
+          if (c2 < c1)
+          {
+            Object o = v.elementAt(j);
+            v.setElementAt(v.elementAt(j + 1), j);
+            v.setElementAt(o, j + 1);
+          }
+        }
+      }
+
+      nv = new Vector();
+      // merge -- remove overlaps
+      Pattern p = (Pattern) v.elementAt(0);
+      nv.addElement(p);
+      for (int i = 1; i < v.size(); i++)
+      {
+        if (geth(p) + 1 >= getl(v.elementAt(i)))
+        {
+          Pattern p2 = (Pattern) v.elementAt(i);
+          char lo = min(getl(p), getl(p2));
+          char hi = max(geth(p), geth(p2));
+          nv.setElementAt(p = mkelem(lo, hi), nv.size() - 1);
+        }
+        else
+        {
+          p = (Pattern) v.elementAt(i);
+          nv.addElement(p);
+        }
+      }
+
+      b.v = v = nv;
+    } catch (RegSyntax e)
+    {
+      e.printStackTrace();
+    }
+
+    // We don't want these things to be empty.
+    Vector negv = neg(v);
+    if (v.size() == 1)
+    {
+      return b;
+    }
+    if (negv.size() == 1)
+    {
+      b.v = negv;
+      b.neg = !b.neg;
+      return b;
+    }
+
+    // Now consider if we can make a FastBracket.
+    // Uses a BitSet to do a lookup.
+    FastBracket fb = newbrack(v, b.neg);
+    if (fb == null)
+    {
+      fb = newbrack(negv, !b.neg);
+    }
+    if (fb != null)
+    {
+      fb.parent = b.parent;
+      fb.next = b.next;
+      return fb;
+    }
+
+    // return the normal Bracket.
+    return b;
+  }
+
+  // Build a FastBracket and set bits. If this can't
+  // be done, return null.
+  final static FastBracket newbrack(Vector v, boolean neg)
+  {
+    FastBracket fb = new FastBracket(neg);
+    fb.v = v;
+    if (v.size() == 0)
+    {
+      return null;
+    }
+    fb.min = getl(v.elementAt(0));
+    fb.max = geth(v.elementAt(v.size() - 1));
+    if (fb.max - fb.min <= 256)
+    {
+      fb.bs = new BitSet(fb.max - fb.min + 1);
+      for (int i = 0; i < v.size(); i++)
+      {
+        Object o = v.elementAt(i);
+        int min0 = getl(o) - fb.min;
+        int max0 = geth(o) - fb.min;
+        for (int j = min0; j <= max0; j++)
+        {
+          fb.bs.set(j);
+        }
+      }
+      return fb;
+    }
+    return null;
+  }
+
+  // Negate a sorted Vector. Applying this
+  // operation twice should yield the same Vector
+  // back.
+  final static Vector neg(Vector v)
+  {
+    try
+    {
+      Vector nv = new Vector();
+      if (v.size() == 0)
+      {
+        nv.addElement(new Range((char) 0, (char) 65535));
+        return nv;
+      }
+      int p0 = getl(v.elementAt(0));
+      if (p0 != 0)
+      {
+        nv.addElement(mkelem((char) 0, (char) (p0 - 1)));
+      }
+      for (int i = 0; i < v.size() - 1; i++)
+      {
+        int hi = getl(v.elementAt(i + 1)) - 1;
+        int lo = geth(v.elementAt(i)) + 1;
+        nv.addElement(mkelem((char) lo, (char) hi));
+      }
+      int pN = geth(v.lastElement());
+      if (pN != 65535)
+      {
+        nv.addElement(mkelem((char) (pN + 1), (char) 65535));
+      }
+      return nv;
+    } catch (RegSyntax rs)
+    {
+      return null;
+    }
+  }
+
+  // Make either a Range or oneChar Object, depending on which
+  // is appropriate.
+  final static Pattern mkelem(char lo, char hi) throws RegSyntax
+  {
+    return lo == hi ? (Pattern) (new oneChar(lo)) : (Pattern) (new Range(
+            lo, hi));
+  }
+
+  static final char min(char a, char b)
+  {
+    return a < b ? a : b;
+  }
+
+  static final char max(char a, char b)
+  {
+    return a > b ? a : b;
+  }
+
+  // getl -- get lower value of Range object,
+  // or get value of oneChar object.
+  final static char getl(Object o)
+  {
+    Pattern p = (Pattern) o;
+    if (p instanceof Range)
+    {
+      return ((Range) p).lo;
+    }
+    return ((oneChar) p).c;
+  }
+
+  // geth -- get higher value of Range object,
+  // or get value of oneChar object.
+  final static char geth(Object o)
+  {
+    Pattern p = (Pattern) o;
+    if (p instanceof Range)
+    {
+      return ((Range) p).hi;
+    }
+    return ((oneChar) p).c;
+  }
+
+  // This is the easy part!
+  public int matchInternal(int pos, Pthings pt)
+  {
+    if (pos >= pt.src.length() || Masked(pos, pt))
+    {
+      return -1;
+    }
+    char c = pt.src.charAt(pos);
+    return (neg ^ (c >= min && c <= max && bs.get(c - min))) ? nextMatch(
+            pos + 1, pt) : -1;
+  }
+}