Fixes build.

[mono.git] / mcs / mcs / support.cs

diff --git a/mcs/mcs/support.cs b/mcs/mcs/support.cs
index 8c92396bce23d52752738101d22e1b078c4556f8..c9e1a359f65adc3135be47f5e04c909e7c27b047 100644 (file)
--- a/mcs/mcs/support.cs
+++ b/mcs/mcs/support.cs
@@ -62,49 +62,6 @@ namespace Mono.CSharp {
 #endif
        }
 
-       /*
-        * Hashtable whose keys are character arrays with the same length
-        */
-       class CharArrayHashtable : Hashtable {
-               sealed class ArrComparer : IComparer {
-                       private int len;
-
-                       public ArrComparer (int len) {
-                               this.len = len;
-                       }
-
-                       public int Compare (object x, object y)
-                       {
-                               char[] a = (char[])x;
-                               char[] b = (char[])y;
-
-                               for (int i = 0; i < len; ++i)
-                                       if (a [i] != b [i])
-                                               return 1;
-                               return 0;
-                       }
-               }
-
-               private int len;
-
-               protected override int GetHash (Object key)
-               {
-                       char[] arr = (char[])key;
-                       int h = 0;
-
-                       for (int i = 0; i < len; ++i)
-                               h = (h << 5) - h + arr [i];
-
-                       return h;
-               }
-
-               public CharArrayHashtable (int len)
-               {
-                       this.len = len;
-                       comparer = new ArrComparer (len);
-               }
-       }
-
        struct Pair {
                public object First;
                public object Second;
@@ -137,36 +94,44 @@ namespace Mono.CSharp {
        ///   but if the seek is too far, it may read the underly
        ///   stream all over from the beginning.
        /// </summary>
-       public class SeekableStreamReader
+       public class SeekableStreamReader : IDisposable
        {
-               const int default_average_read_length = 1024;
                const int buffer_read_length_spans = 3;
 
                TextReader reader;
                Stream stream;
-               Encoding encoding;
 
-               char[] buffer;
+               static char[] buffer;
                int average_read_length;
                int buffer_start;       // in chars
                int char_count;         // count buffer[] valid characters
                int pos;                // index into buffer[]
 
-               void ResetStream (int read_length_inc)
+               public SeekableStreamReader (Stream stream, Encoding encoding)
                {
-                       average_read_length += read_length_inc;
-                       stream.Position = 0;
+                       this.stream = stream;
+
+                       const int default_average_read_length = 1024;
+                       InitializeStream (default_average_read_length);
                        reader = new StreamReader (stream, encoding, true);
-                       buffer = new char [average_read_length * buffer_read_length_spans];
-                       buffer_start = char_count = pos = 0;
                }
 
-               public SeekableStreamReader (Stream stream, Encoding encoding)
+               public void Dispose ()
                {
-                       this.stream = stream;
-                       this.encoding = encoding;
+                       // Needed to release stream reader buffers
+                       reader.Dispose ();
+               }
 
-                       ResetStream (default_average_read_length);
+               void InitializeStream (int read_length_inc)
+               {
+                       average_read_length += read_length_inc;
+
+                       int required_buffer_size = average_read_length * buffer_read_length_spans;
+                       if (buffer == null || buffer.Length < required_buffer_size)
+                               buffer = new char [required_buffer_size];
+
+                       stream.Position = 0;                    
+                       buffer_start = char_count = pos = 0;
                }
 
                /// <remarks>
@@ -182,7 +147,7 @@ namespace Mono.CSharp {
                        set {
                                // If the lookahead was too small, re-read from the beginning.  Increase the buffer size while we're at it
                                if (value < buffer_start)
-                                       ResetStream (average_read_length / 2);
+                                       InitializeStream (average_read_length / 2);
 
                                while (value > buffer_start + char_count) {
                                        pos = char_count;