mcs/support.cs

   1 //
   2 // support.cs: Support routines to work around the fact that System.Reflection.Emit
   3 // can not introspect types that are being constructed
   4 //
   5 // Author:
   6 //   Miguel de Icaza (miguel@ximian.com)
   7 //   Marek Safar (marek.safar@gmail.com)
   8 //
   9 // Copyright 2001 Ximian, Inc (http://www.ximian.com)
  10 // Copyright 2003-2009 Novell, Inc
  11 //
  12
  13 using System;
  14 using System.IO;
  15 using System.Text;
  16 using System.Reflection;
  17 using System.Reflection.Emit;
  18 using System.Globalization;
  19 using System.Collections.Generic;
  20
  21 namespace Mono.CSharp {
  22
  23         sealed class ReferenceEquality<T> : IEqualityComparer<T> where T : class
  24         {
  25                 public static readonly IEqualityComparer<T> Default = new ReferenceEquality<T> ();
  26
  27                 private ReferenceEquality ()
  28                 {
  29                 }
  30
  31                 public bool Equals (T x, T y)
  32                 {
  33                         return ReferenceEquals (x, y);
  34                 }
  35
  36                 public int GetHashCode (T obj)
  37                 {
  38                         return System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode (obj);
  39                 }
  40         }
  41
  42         class Tuple<T1, T2> : IEquatable<Tuple<T1, T2>>
  43         {
  44                 public Tuple (T1 item1, T2 item2)
  45                 {
  46                         Item1 = item1;
  47                         Item2 = item2;
  48                 }
  49
  50                 public T1 Item1 { get; private set; }
  51                 public T2 Item2 { get; private set; }
  52
  53                 public override int GetHashCode ()
  54                 {
  55                         return Item1.GetHashCode () ^ Item2.GetHashCode ();
  56                 }
  57
  58                 #region IEquatable<Tuple<T1,T2>> Members
  59
  60                 public bool Equals (Tuple<T1, T2> other)
  61                 {
  62                         return EqualityComparer<T1>.Default.Equals (Item1, other.Item1) &&
  63                                 EqualityComparer<T2>.Default.Equals (Item2, other.Item2);
  64                 }
  65
  66                 #endregion
  67         }
  68
  69         static class Tuple
  70         {
  71                 public static Tuple<T1, T2> Create<T1, T2> (T1 item1, T2 item2)
  72                 {
  73                         return new Tuple<T1, T2> (item1, item2);
  74                 }
  75         }
  76
  77         /// <summary>
  78         ///   This is an arbitrarily seekable StreamReader wrapper.
  79         ///
  80         ///   It uses a self-tuning buffer to cache the seekable data,
  81         ///   but if the seek is too far, it may read the underly
  82         ///   stream all over from the beginning.
  83         /// </summary>
  84         public class SeekableStreamReader : IDisposable
  85         {
  86                 const int buffer_read_length_spans = 3;
  87
  88                 TextReader reader;
  89                 Stream stream;
  90
  91                 static char[] buffer;
  92                 int average_read_length;
  93                 int buffer_start;       // in chars
  94                 int char_count;         // count buffer[] valid characters
  95                 int pos;                // index into buffer[]
  96
  97                 public SeekableStreamReader (Stream stream, Encoding encoding)
  98                 {
  99                         this.stream = stream;
 100
 101                         const int default_average_read_length = 1024;
 102                         InitializeStream (default_average_read_length);
 103                         reader = new StreamReader (stream, encoding, true);
 104                 }
 105
 106                 public void Dispose ()
 107                 {
 108                         // Needed to release stream reader buffers
 109                         reader.Dispose ();
 110                 }
 111
 112                 void InitializeStream (int read_length_inc)
 113                 {
 114                         average_read_length += read_length_inc;
 115
 116                         int required_buffer_size = average_read_length * buffer_read_length_spans;
 117                         if (buffer == null || buffer.Length < required_buffer_size)
 118                                 buffer = new char [required_buffer_size];
 119
 120                         stream.Position = 0;
 121                         buffer_start = char_count = pos = 0;
 122                 }
 123
 124                 /// <remarks>
 125                 ///   This value corresponds to the current position in a stream of characters.
 126                 ///   The StreamReader hides its manipulation of the underlying byte stream and all
 127                 ///   character set/decoding issues.  Thus, we cannot use this position to guess at
 128                 ///   the corresponding position in the underlying byte stream even though there is
 129                 ///   a correlation between them.
 130                 /// </remarks>
 131                 public int Position {
 132                         get { return buffer_start + pos; }
 133
 134                         set {
 135                                 // If the lookahead was too small, re-read from the beginning.  Increase the buffer size while we're at it
 136                                 if (value < buffer_start)
 137                                         InitializeStream (average_read_length / 2);
 138
 139                                 while (value > buffer_start + char_count) {
 140                                         pos = char_count;
 141                                         if (!ReadBuffer ())
 142                                                 throw new InternalErrorException ("Seek beyond end of file: " + (buffer_start + char_count - value));
 143                                 }
 144
 145                                 pos = value - buffer_start;
 146                         }
 147                 }
 148
 149                 private bool ReadBuffer ()
 150                 {
 151                         int slack = buffer.Length - char_count;
 152                         if (slack <= average_read_length / 2) {
 153                                 // shift the buffer to make room for average_read_length number of characters
 154                                 int shift = average_read_length - slack;
 155                                 Array.Copy (buffer, shift, buffer, 0, char_count - shift);
 156                                 pos -= shift;
 157                                 char_count -= shift;
 158                                 buffer_start += shift;
 159                                 slack += shift;         // slack == average_read_length
 160                         }
 161
 162                         char_count += reader.Read (buffer, char_count, slack);
 163
 164                         return pos < char_count;
 165                 }
 166
 167                 public int Peek ()
 168                 {
 169                         if ((pos >= char_count) && !ReadBuffer ())
 170                                 return -1;
 171
 172                         return buffer [pos];
 173                 }
 174
 175                 public int Read ()
 176                 {
 177                         if ((pos >= char_count) && !ReadBuffer ())
 178                                 return -1;
 179
 180                         return buffer [pos++];
 181                 }
 182         }
 183
 184         public class DoubleHash {
 185                 const int DEFAULT_INITIAL_BUCKETS = 100;
 186
 187                 public DoubleHash () : this (DEFAULT_INITIAL_BUCKETS) {}
 188
 189                 public DoubleHash (int size)
 190                 {
 191                         count = size;
 192                         buckets = new Entry [size];
 193                 }
 194
 195                 int count;
 196                 Entry [] buckets;
 197                 int size = 0;
 198
 199                 class Entry {
 200                         public object key1;
 201                         public object key2;
 202                         public int hash;
 203                         public object value;
 204                         public Entry next;
 205
 206                         public Entry (object key1, object key2, int hash, object value, Entry next)
 207                         {
 208                                 this.key1 = key1;
 209                                 this.key2 = key2;
 210                                 this.hash = hash;
 211                                 this.next = next;
 212                                 this.value = value;
 213                         }
 214                 }
 215
 216                 public bool Lookup (object a, object b, out object res)
 217                 {
 218                         int h = (a.GetHashCode () ^ b.GetHashCode ()) & 0x7FFFFFFF;
 219
 220                         for (Entry e = buckets [h % count]; e != null; e = e.next) {
 221                                 if (e.hash == h && e.key1.Equals (a) && e.key2.Equals (b)) {
 222                                         res = e.value;
 223                                         return true;
 224                                 }
 225                         }
 226                         res = null;
 227                         return false;
 228                 }
 229
 230                 public void Insert (object a, object b, object value)
 231                 {
 232                         // Is it an existing one?
 233
 234                         int h = (a.GetHashCode () ^ b.GetHashCode ()) & 0x7FFFFFFF;
 235
 236                         for (Entry e = buckets [h % count]; e != null; e = e.next) {
 237                                 if (e.hash == h && e.key1.Equals (a) && e.key2.Equals (b))
 238                                         e.value = value;
 239                         }
 240
 241                         int bucket = h % count;
 242                         buckets [bucket] = new Entry (a, b, h, value, buckets [bucket]);
 243
 244                         // Grow whenever we double in size
 245                         if (size++ == count) {
 246                                 count <<= 1;
 247                                 count ++;
 248
 249                                 Entry [] newBuckets = new Entry [count];
 250                                 foreach (Entry root in buckets) {
 251                                         Entry e = root;
 252                                         while (e != null) {
 253                                                 int newLoc = e.hash % count;
 254                                                 Entry n = e.next;
 255                                                 e.next = newBuckets [newLoc];
 256                                                 newBuckets [newLoc] = e;
 257                                                 e = n;
 258                                         }
 259                                 }
 260
 261                                 buckets = newBuckets;
 262                         }
 263                 }
 264         }
 265
 266         public class UnixUtils {
 267                 [System.Runtime.InteropServices.DllImport ("libc", EntryPoint="isatty")]
 268                 extern static int _isatty (int fd);
 269
 270                 public static bool isatty (int fd)
 271                 {
 272                         try {
 273                                 return _isatty (fd) == 1;
 274                         } catch {
 275                                 return false;
 276                         }
 277                 }
 278         }
 279
 280         /// <summary>
 281         ///   An exception used to terminate the compiler resolution phase and provide completions
 282         /// </summary>
 283         /// <remarks>
 284         ///   This is thrown when we want to return the completions or
 285         ///   terminate the completion process by AST nodes used in
 286         ///   the completion process.
 287         /// </remarks>
 288         public class CompletionResult : Exception {
 289                 string [] result;
 290                 string base_text;
 291
 292                 public CompletionResult (string base_text, string [] res)
 293                 {
 294                         if (base_text == null)
 295                                 throw new ArgumentNullException ("base_text");
 296                         this.base_text = base_text;
 297
 298                         result = res;
 299                         Array.Sort (result);
 300                 }
 301
 302                 public string [] Result {
 303                         get {
 304                                 return result;
 305                         }
 306                 }
 307
 308                 public string BaseText {
 309                         get {
 310                                 return base_text;
 311                         }
 312                 }
 313         }
 314 }