mcs/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 //
   8 // Copyright 2001 Ximian, Inc (http://www.ximian.com)
   9 // Copyright 2003-2008 Novell, Inc
  10 //
  11
  12 using System;
  13 using System.IO;
  14 using System.Text;
  15 using System.Reflection;
  16 using System.Collections;
  17 using System.Reflection.Emit;
  18 using System.Globalization;
  19
  20 namespace Mono.CSharp {
  21
  22         class PtrHashtable : Hashtable {
  23                 sealed class PtrComparer : IComparer
  24 #if NET_2_0
  25                         , IEqualityComparer
  26 #endif
  27                 {
  28                         private PtrComparer () {}
  29
  30                         public static PtrComparer Instance = new PtrComparer ();
  31
  32                         public int Compare (object x, object y)
  33                         {
  34                                 if (x == y)
  35                                         return 0;
  36                                 else
  37                                         return 1;
  38                         }
  39 #if NET_2_0
  40                         bool IEqualityComparer.Equals (object x, object y)
  41                         {
  42                                 return x == y;
  43                         }
  44
  45                         int IEqualityComparer.GetHashCode (object obj)
  46                         {
  47                                 return obj.GetHashCode ();
  48                         }
  49 #endif
  50
  51                 }
  52
  53 #if NET_2_0
  54                 public PtrHashtable () : base (PtrComparer.Instance) {}
  55 #else
  56                 public PtrHashtable ()
  57                 {
  58                         comparer = PtrComparer.Instance;
  59                 }
  60 #endif
  61
  62 #if MS_COMPATIBLE
  63                 //
  64                 // Workaround System.InvalidOperationException for enums
  65                 //
  66                 protected override int GetHash (object key)
  67                 {
  68                         TypeBuilder tb = key as TypeBuilder;
  69                         if (tb != null && tb.BaseType == TypeManager.enum_type && tb.BaseType != null)
  70                                 key = tb.BaseType;
  71
  72                         return base.GetHash (key);
  73                 }
  74 #endif
  75         }
  76
  77         /*
  78          * Hashtable whose keys are character arrays with the same length
  79          */
  80         class CharArrayHashtable : Hashtable {
  81                 sealed class ArrComparer : IComparer {
  82                         private int len;
  83
  84                         public ArrComparer (int len) {
  85                                 this.len = len;
  86                         }
  87
  88                         public int Compare (object x, object y)
  89                         {
  90                                 char[] a = (char[])x;
  91                                 char[] b = (char[])y;
  92
  93                                 for (int i = 0; i < len; ++i)
  94                                         if (a [i] != b [i])
  95                                                 return 1;
  96                                 return 0;
  97                         }
  98                 }
  99
 100                 private int len;
 101
 102                 protected override int GetHash (Object key)
 103                 {
 104                         char[] arr = (char[])key;
 105                         int h = 0;
 106
 107                         for (int i = 0; i < len; ++i)
 108                                 h = (h << 5) - h + arr [i];
 109
 110                         return h;
 111                 }
 112
 113                 public CharArrayHashtable (int len)
 114                 {
 115                         this.len = len;
 116                         comparer = new ArrComparer (len);
 117                 }
 118         }
 119
 120         struct Pair {
 121                 public object First;
 122                 public object Second;
 123
 124                 public Pair (object f, object s)
 125                 {
 126                         First = f;
 127                         Second = s;
 128                 }
 129         }
 130
 131         public class Accessors {
 132                 public Accessor get_or_add;
 133                 public Accessor set_or_remove;
 134
 135                 // was 'set' declared before 'get'?  was 'remove' declared before 'add'?
 136                 public bool declared_in_reverse;
 137
 138                 public Accessors (Accessor get_or_add, Accessor set_or_remove)
 139                 {
 140                         this.get_or_add = get_or_add;
 141                         this.set_or_remove = set_or_remove;
 142                 }
 143         }
 144
 145         /// <summary>
 146         ///   This is an arbitrarily seekable StreamReader wrapper.
 147         ///
 148         ///   It uses a self-tuning buffer to cache the seekable data,
 149         ///   but if the seek is too far, it may read the underly
 150         ///   stream all over from the beginning.
 151         /// </summary>
 152         public class SeekableStreamReader
 153         {
 154                 const int default_average_read_length = 1024;
 155                 const int buffer_read_length_spans = 3;
 156
 157                 TextReader reader;
 158                 Stream stream;
 159                 Encoding encoding;
 160
 161                 char[] buffer;
 162                 int average_read_length;
 163                 int buffer_start;       // in chars
 164                 int char_count;         // count buffer[] valid characters
 165                 int pos;                // index into buffer[]
 166
 167                 void ResetStream (int read_length_inc)
 168                 {
 169                         average_read_length += read_length_inc;
 170                         stream.Position = 0;
 171                         reader = new StreamReader (stream, encoding, true);
 172                         buffer = new char [average_read_length * buffer_read_length_spans];
 173                         buffer_start = char_count = pos = 0;
 174                 }
 175
 176                 public SeekableStreamReader (Stream stream, Encoding encoding)
 177                 {
 178                         this.stream = stream;
 179                         this.encoding = encoding;
 180
 181                         ResetStream (default_average_read_length);
 182                 }
 183
 184                 /// <remarks>
 185                 ///   This value corresponds to the current position in a stream of characters.
 186                 ///   The StreamReader hides its manipulation of the underlying byte stream and all
 187                 ///   character set/decoding issues.  Thus, we cannot use this position to guess at
 188                 ///   the corresponding position in the underlying byte stream even though there is
 189                 ///   a correlation between them.
 190                 /// </remarks>
 191                 public int Position {
 192                         get { return buffer_start + pos; }
 193
 194                         set {
 195                                 // If the lookahead was too small, re-read from the beginning.  Increase the buffer size while we're at it
 196                                 if (value < buffer_start)
 197                                         ResetStream (average_read_length / 2);
 198
 199                                 while (value > buffer_start + char_count) {
 200                                         pos = char_count;
 201                                         if (!ReadBuffer ())
 202                                                 throw new InternalErrorException ("Seek beyond end of file: " + (buffer_start + char_count - value));
 203                                 }
 204
 205                                 pos = value - buffer_start;
 206                         }
 207                 }
 208
 209                 private bool ReadBuffer ()
 210                 {
 211                         int slack = buffer.Length - char_count;
 212                         if (slack <= average_read_length / 2) {
 213                                 // shift the buffer to make room for average_read_length number of characters
 214                                 int shift = average_read_length - slack;
 215                                 Array.Copy (buffer, shift, buffer, 0, char_count - shift);
 216                                 pos -= shift;
 217                                 char_count -= shift;
 218                                 buffer_start += shift;
 219                                 slack += shift;         // slack == average_read_length
 220                         }
 221
 222                         char_count += reader.Read (buffer, char_count, slack);
 223
 224                         return pos < char_count;
 225                 }
 226
 227                 public int Peek ()
 228                 {
 229                         if ((pos >= char_count) && !ReadBuffer ())
 230                                 return -1;
 231
 232                         return buffer [pos];
 233                 }
 234
 235                 public int Read ()
 236                 {
 237                         if ((pos >= char_count) && !ReadBuffer ())
 238                                 return -1;
 239
 240                         return buffer [pos++];
 241                 }
 242         }
 243
 244         public class DoubleHash {
 245                 const int DEFAULT_INITIAL_BUCKETS = 100;
 246
 247                 public DoubleHash () : this (DEFAULT_INITIAL_BUCKETS) {}
 248
 249                 public DoubleHash (int size)
 250                 {
 251                         count = size;
 252                         buckets = new Entry [size];
 253                 }
 254
 255                 int count;
 256                 Entry [] buckets;
 257                 int size = 0;
 258
 259                 class Entry {
 260                         public object key1;
 261                         public object key2;
 262                         public int hash;
 263                         public object value;
 264                         public Entry next;
 265
 266                         public Entry (object key1, object key2, int hash, object value, Entry next)
 267                         {
 268                                 this.key1 = key1;
 269                                 this.key2 = key2;
 270                                 this.hash = hash;
 271                                 this.next = next;
 272                                 this.value = value;
 273                         }
 274                 }
 275
 276                 public bool Lookup (object a, object b, out object res)
 277                 {
 278                         int h = (a.GetHashCode () ^ b.GetHashCode ()) & 0x7FFFFFFF;
 279
 280                         for (Entry e = buckets [h % count]; e != null; e = e.next) {
 281                                 if (e.hash == h && e.key1.Equals (a) && e.key2.Equals (b)) {
 282                                         res = e.value;
 283                                         return true;
 284                                 }
 285                         }
 286                         res = null;
 287                         return false;
 288                 }
 289
 290                 public void Insert (object a, object b, object value)
 291                 {
 292                         // Is it an existing one?
 293
 294                         int h = (a.GetHashCode () ^ b.GetHashCode ()) & 0x7FFFFFFF;
 295
 296                         for (Entry e = buckets [h % count]; e != null; e = e.next) {
 297                                 if (e.hash == h && e.key1.Equals (a) && e.key2.Equals (b))
 298                                         e.value = value;
 299                         }
 300
 301                         int bucket = h % count;
 302                         buckets [bucket] = new Entry (a, b, h, value, buckets [bucket]);
 303
 304                         // Grow whenever we double in size
 305                         if (size++ == count) {
 306                                 count <<= 1;
 307                                 count ++;
 308
 309                                 Entry [] newBuckets = new Entry [count];
 310                                 foreach (Entry root in buckets) {
 311                                         Entry e = root;
 312                                         while (e != null) {
 313                                                 int newLoc = e.hash % count;
 314                                                 Entry n = e.next;
 315                                                 e.next = newBuckets [newLoc];
 316                                                 newBuckets [newLoc] = e;
 317                                                 e = n;
 318                                         }
 319                                 }
 320
 321                                 buckets = newBuckets;
 322                         }
 323                 }
 324         }
 325
 326         class PartialMethodDefinitionInfo : MethodInfo
 327         {
 328                 MethodOrOperator mc;
 329                 MethodAttributes attrs;
 330
 331                 public PartialMethodDefinitionInfo (MethodOrOperator mc)
 332                 {
 333                         this.mc = mc;
 334                         if ((mc.ModFlags & Modifiers.STATIC) != 0)
 335                                 attrs = MethodAttributes.Static;
 336                 }
 337
 338                 public override MethodInfo GetBaseDefinition ()
 339                 {
 340                         throw new NotImplementedException ();
 341                 }
 342
 343                 public override ICustomAttributeProvider ReturnTypeCustomAttributes
 344                 {
 345                         get { throw new NotImplementedException (); }
 346                 }
 347
 348                 public override MethodAttributes Attributes
 349                 {
 350                         get { return attrs; }
 351                 }
 352
 353                 public override MethodImplAttributes GetMethodImplementationFlags ()
 354                 {
 355                         throw new NotImplementedException ();
 356                 }
 357
 358                 public override ParameterInfo [] GetParameters ()
 359                 {
 360                         throw new NotImplementedException ();
 361                 }
 362
 363                 public override object Invoke (object obj, BindingFlags invokeAttr, Binder binder, object [] parameters, CultureInfo culture)
 364                 {
 365                         throw new NotImplementedException ();
 366                 }
 367
 368                 public override RuntimeMethodHandle MethodHandle
 369                 {
 370                         get { throw new NotImplementedException (); }
 371                 }
 372
 373                 public override Type DeclaringType
 374                 {
 375                         get { return mc.Parent.TypeBuilder; }
 376                 }
 377
 378                 public override object [] GetCustomAttributes (Type attributeType, bool inherit)
 379                 {
 380                         throw new NotImplementedException ();
 381                 }
 382
 383                 public override object [] GetCustomAttributes (bool inherit)
 384                 {
 385                         throw new NotImplementedException ();
 386                 }
 387
 388                 public override Type ReturnType {
 389                         get {
 390                                 return mc.MemberType;
 391                         }
 392                 }
 393
 394                 public override bool IsDefined (Type attributeType, bool inherit)
 395                 {
 396                         throw new NotImplementedException ();
 397                 }
 398
 399                 public override string Name
 400                 {
 401                         get { return mc.Name; }
 402                 }
 403
 404                 public override Type ReflectedType
 405                 {
 406                         get { throw new NotImplementedException (); }
 407                 }
 408         }
 409
 410         public class UnixUtils {
 411                 [System.Runtime.InteropServices.DllImport ("libc", EntryPoint="isatty")]
 412                 extern static int _isatty (int fd);
 413
 414                 public static bool isatty (int fd)
 415                 {
 416                         try {
 417                                 return _isatty (fd) == 1;
 418                         } catch {
 419                                 return false;
 420                         }
 421                 }
 422         }
 423
 424         /// <summary>
 425         ///   An exception used to terminate the compiler resolution phase and provide completions
 426         /// </summary>
 427         /// <remarks>
 428         ///   This is thrown when we want to return the completions or
 429         ///   terminate the completion process by AST nodes used in
 430         ///   the completion process.
 431         /// </remarks>
 432         public class CompletionResult : Exception {
 433                 string [] result;
 434                 string base_text;
 435
 436                 public CompletionResult (string base_text, string [] res)
 437                 {
 438                         if (base_text == null)
 439                                 throw new ArgumentNullException ("base_text");
 440                         this.base_text = base_text;
 441
 442                         result = res;
 443                         Array.Sort (result);
 444                 }
 445
 446                 public string [] Result {
 447                         get {
 448                                 return result;
 449                         }
 450                 }
 451
 452                 public string BaseText {
 453                         get {
 454                                 return base_text;
 455                         }
 456                 }
 457         }
 458 }