resizablebitset -> bitset

5 files changed, 37 insertions, 32 deletions

diff --git a/config/list/library.lst b/config/list/library.lst
index ed05705016..a82958e12d 100644
--- a/config/list/library.lst
+++ b/config/list/library.lst
@@ -72,6 +72,7 @@ collection/SetProxy.scala
 collection/BitSet.scala
 
 collection/mutable/ArrayBuffer.scala
+collection/mutable/BitSet.scala
 collection/mutable/Buffer.scala
 collection/mutable/BufferProxy.scala
 collection/mutable/DefaultMapModel.scala
@@ -101,7 +102,6 @@ collection/mutable/Publisher.scala
 collection/mutable/Queue.scala
 collection/mutable/QueueProxy.scala
 collection/mutable/ResizableArray.scala
-collection/mutable/ResizableBitSet.scala
 collection/mutable/RevertableHistory.scala
 collection/mutable/Scriptable.scala
 collection/mutable/Set.scala
diff --git a/sources/scala/collection/immutable/BitSet.scala b/sources/scala/collection/immutable/BitSet.scala
index 9dde4a7ae2..f9a629b2e4 100644
--- a/sources/scala/collection/immutable/BitSet.scala
+++ b/sources/scala/collection/immutable/BitSet.scala
@@ -14,28 +14,28 @@ package scala.collection.immutable;
  *  <code>mutable.ResizableBitSet</code>.
  *
  *  @param <code>n</code> represents the number of relevant bits
- *  @param ba:   array of bytes of length <code>n</code>&gt;&gt;&gt;3
+ *  @param ba:   array of ints of length <code>n</code>&gt;&gt;&gt;5
  *  @param copy: if yes, then <code>ba</code> is copied and updates will
  *               not affect this bitset
  *
  *  @author  Burak Emir
  *  @version 1.0
  */
-class BitSet(n:Int, ba: Array[Byte], copy: Boolean) extends scala.collection.BitSet {
+class BitSet(n:Int, ba: Array[Int], copy: Boolean) extends collection.BitSet {
 
   final def size = n;
 
-  val array: Array[Byte]  =
+  protected val array: Array[Int]  =
     if (copy) {
-      val arr = new Array[Byte](ba.length);
+      val arr = new Array[Int](ba.length);
       java.lang.System.arraycopy(ba, 0, arr, 0, ba.length);
       arr
     }
     else
       ba;
 
-  def this(rbs: scala.collection.mutable.ResizableBitSet) = {
-    this(rbs.size, rbs.toByteArray, false);
+  def this(rbs: mutable.BitSet) = {
+    this(rbs.size, rbs.toArray, false);
   }
 
   /** returns true if bit i is set
@@ -43,9 +43,14 @@ class BitSet(n:Int, ba: Array[Byte], copy: Boolean) extends scala.collection.Bit
    * @param i
    */
   def apply(i: Int):Boolean = {
-    val j    = (i >>> 3);
-    val mask = (1 << (i & 0x07));
+    val j    = (i >>> 5);
+    val mask = (1 << (i & 0x1F));
     (array(j) & mask) != 0;
   }
 
+  def toArray: Array[Int] = {
+    val arr = new Array[Int](array.length);
+    java.lang.System.arraycopy(arr, 0, array, 0, array.length);
+    arr
+  }
 }
diff --git a/sources/scala/collection/mutable/ResizableBitSet.scala b/sources/scala/collection/mutable/BitSet.scala
index a92184b441..eac258ef04 100644
--- a/sources/scala/collection/mutable/ResizableBitSet.scala
+++ b/sources/scala/collection/mutable/BitSet.scala
@@ -9,36 +9,36 @@
 
 package scala.collection.mutable ;
 
-/** resizable bit sets, to represent small sets of integers
+/** mutable, resizable bit sets, to represent dense sets of small integers
  *  @author  Burak Emir
  *  @param initSize: initial size in nbits
  */
-class ResizableBitSet(initSize: Int) extends scala.collection.BitSet {
+class BitSet(initSize: Int) extends scala.collection.BitSet {
 
   /** default constructor, initial size of 16 bits */
   def this() = this( 16 );
 
-  final def byteSize(size:Int) = { (size >>> 3) + (if( (size & 0x07)!= 0 ) 1 else 0) };
+  final def byteSize(size:Int) = { (size >>> 5) + (if( (size & 0x1F)!= 0 ) 1 else 0) };
 
-  class ByteArray with ResizableArray[Byte] {
+  class ByteArray with ResizableArray[Int] {
     override protected val initialSize: Int = byteSize( initSize );
-    override protected var array: Array[Byte] = new Array[Byte](initialSize);
+    override protected var array: Array[Int] = new Array[Int](initialSize);
 
     /** size of this bitset in nbits */
     def ensureBits(nbits: Int): Unit = ensureSize( byteSize( nbits ));
 
     final def and(j: Int, mask:Int): Unit = {
-      array.update( j, (array(j) & mask).asInstanceOf[Byte] );
+      array.update( j, array(j) & mask );
     }
     final def or(j: Int, mask:Int): Unit = {
-      array.update( j, (array(j) | mask).asInstanceOf[Byte] );
+      array.update( j, array(j) | mask );
     }
     def get(j:Int, mask:Int):Boolean = {
       (array(j) & mask) != 0;
     }
 
-    def freeze: Array[Byte] = {
-      val arr = new Array[Byte]( array.length );
+    def freeze: Array[Int] = {
+      val arr = new Array[Int]( array.length );
       java.lang.System.arraycopy(array, 0, arr, 0, arr.length);
       arr
     }
@@ -59,23 +59,23 @@ class ResizableBitSet(initSize: Int) extends scala.collection.BitSet {
 
   final def set(i: Int): Unit = {
     ensureSize(i+1);
-    val j         = (i >>> 3);
-    val mask      = (1 << (i & 0x07));
+    val j         = (i >>> 5);
+    val mask      = (1 << (i & 0x1F));
     internal.or(j, mask);
   }
 
   def clear(i: Int): Unit = {
     ensureSize(i+1);
-    val j    = (i >>> 3);
-    val mask = (1 << (i & 0x07));
+    val j    = (i >>> 5);
+    val mask = (1 << (i & 0x1F));
     internal.and(j, ~mask);
   }
 
   def apply(i: Int):Boolean = {
-    val j    = (i >>> 3);
-    val mask = (1 << (i & 0x07));
+    val j    = (i >>> 5);
+    val mask = (1 << (i & 0x1F));
     internal.get(j, mask);
   }
 
-  def toByteArray: Array[Byte] = internal.freeze;
+  def toArray: Array[Int] = internal.freeze;
 }
diff --git a/sources/scala/tools/scalac/transformer/matching/MutableGrammar.scala b/sources/scala/tools/scalac/transformer/matching/MutableGrammar.scala
index 65abc34bdf..7f8b75e122 100644
--- a/sources/scala/tools/scalac/transformer/matching/MutableGrammar.scala
+++ b/sources/scala/tools/scalac/transformer/matching/MutableGrammar.scala
@@ -87,8 +87,8 @@ case class MutableGrammar( treeRules:mutable.Set[TRule],
 
   /** converts this grammar in a pattern grammar (an ImmutableTreeHedgeGrammar with variable info)
   */
-  def toGrammar:PatternGrammar = {
-    val rbsNullable = new mutable.ResizableBitSet();
+  def toGrammar: PatternGrammar = {
+    val rbsNullable = new mutable.BitSet();
     val _treeTransitions:Array[immutable.Set[TreeRHS]] = {
       val theTreeTransitionsMap: immutable.TreeMap[Int,immutable.Set[TreeRHS]] = {
         var tmp =
@@ -143,7 +143,7 @@ case class MutableGrammar( treeRules:mutable.Set[TRule],
     }
 
     val _treeInitials = {
-      val rbs = new mutable.ResizableBitSet( _nTreeNT );
+      val rbs = new mutable.BitSet( _nTreeNT );
       for( val k <- make.treeInitials ) {
         rbs.set( k.i )
       }
@@ -151,7 +151,7 @@ case class MutableGrammar( treeRules:mutable.Set[TRule],
     }
 
     val _hedgeInitials = {
-      val rbs = new mutable.ResizableBitSet( _nHedgeNT );
+      val rbs = new mutable.BitSet( _nHedgeNT );
       for( val k <- make.hedgeInitials ) {
         rbsNullable.ensureSize( k.i );
         rbsNullable.set( k.i, k.nullable );
diff --git a/sources/scala/util/grammar/MutableTreeHedgeGrammar.scala b/sources/scala/util/grammar/MutableTreeHedgeGrammar.scala
index 1da3f025a9..d1ac0b0560 100644
--- a/sources/scala/util/grammar/MutableTreeHedgeGrammar.scala
+++ b/sources/scala/util/grammar/MutableTreeHedgeGrammar.scala
@@ -16,11 +16,11 @@ class MutableTreeHedgeGrammar[ A <: Alphabet ] extends TreeHedgeGrammar[ A ] {
   /** number of hedge nonterminals*/
   var nHedgeNT: Int = 0;
   /** inv: treeInitials.length == nTreeNT */
-  val treeInitials    = new mutable.ResizableBitSet();
+  val treeInitials    = new mutable.BitSet();
   /** inv: hedgeInitials.length == nHedgeNT */
-  val hedgeInitials   = new mutable.ResizableBitSet();
+  val hedgeInitials   = new mutable.BitSet();
   /** inv: hedgeIsNullable.length == nHedgeNT */
-  val isNullable      = new mutable.ResizableBitSet();;
+  val isNullable      = new mutable.BitSet();;
   val treeTransitions:  mutable.Map[Int, mutable.Set[TreeRHS]] =
     new mutable.HashMap[Int, mutable.Set[TreeRHS]];
   val hedgeTransitions: mutable.Map[Int, mutable.Set[HedgeRHS]] =