X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fmcs%2Fsupport.cs;h=b2e983f16d8d580a2d1c8ea7a93407a68da0f415;hb=6245d58fb84a51aec0015cec83ac08b4bf37a927;hp=d5dad0ad67c29c08efe7db545205f90a0db061f7;hpb=d49951ccf584ba637afb1dab7fff714478e3174d;p=mono.git diff --git a/mcs/mcs/support.cs b/mcs/mcs/support.cs index d5dad0ad67c..b2e983f16d8 100644 --- a/mcs/mcs/support.cs +++ b/mcs/mcs/support.cs @@ -4,370 +4,174 @@ // // Author: // Miguel de Icaza (miguel@ximian.com) +// Marek Safar (marek.safar@gmail.com) // -// (C) 2001 Ximian, Inc (http://www.ximian.com) +// Copyright 2001 Ximian, Inc (http://www.ximian.com) +// Copyright 2003-2009 Novell, Inc +// Copyright 2011 Xamarin Inc // using System; using System.IO; using System.Text; -using System.Reflection; -using System.Collections; -using System.Reflection.Emit; -using System.Globalization; +using System.Collections.Generic; namespace Mono.CSharp { - public interface ParameterData { - Type ParameterType (int pos); - Type [] Types { get; } - int Count { get; } - bool HasParams { get; } - string ParameterName (int pos); - string ParameterDesc (int pos); - Parameter.Modifier ParameterModifier (int pos); - string GetSignatureForError (); - } - - public class ReflectionParameters : ParameterData { - ParameterInfo [] pi; - Type [] types; - int params_idx = -1; - bool is_varargs; - ParameterData gpd; + sealed class ReferenceEquality : IEqualityComparer where T : class + { + public static readonly IEqualityComparer Default = new ReferenceEquality (); - public ReflectionParameters (MethodBase mb) + private ReferenceEquality () { - ParameterInfo [] pi = mb.GetParameters (); - is_varargs = (mb.CallingConvention & CallingConventions.VarArgs) != 0; - - this.pi = pi; - int count = pi.Length; - - if (count == 0) { - types = Type.EmptyTypes; - return; - } - - types = new Type [count]; - for (int i = 0; i < count; i++) - types [i] = pi [i].ParameterType; - - // TODO: This (if) should be done one level higher to correctly use - // out caching facilities. - MethodBase generic = TypeManager.DropGenericMethodArguments (mb); - if (generic != mb) { - gpd = TypeManager.GetParameterData (generic); - if (gpd.HasParams) { - for (int i = gpd.Count; i != 0; --i) { - if ((gpd.ParameterModifier (i)& Parameter.Modifier.PARAMS) != 0) { - this.params_idx = i; - break; - } - } - } - return; - } - - // - // So far, the params attribute can be used in C# for the last - // and next to last method parameters. - // If some other language can place it anywhere we will - // have to analyze all parameters and not just last 2. - // - --count; - for (int i = count; i >= 0 && i > count - 2; --i) { - if (!pi [i].ParameterType.IsArray) - continue; - - object [] attrs = pi [i].GetCustomAttributes (TypeManager.param_array_type, true); - if (attrs.Length == 1) { - params_idx = i; - return; - } - } } - public override bool Equals (object obj) + public bool Equals (T x, T y) { - ReflectionParameters rp = obj as ReflectionParameters; - if (rp == null) - return false; - - if (Count != rp.Count) - return false; - - for (int i = 0; i < Count; ++i) { - if (!types [i].Equals (rp.types [i])) - return false; - } - return true; + return ReferenceEquals (x, y); } - public override int GetHashCode() + public int GetHashCode (T obj) { - return base.GetHashCode (); + return System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode (obj); } - - public string GetSignatureForError () + } +#if !NET_4_0 + public class Tuple : IEquatable> + { + public Tuple (T1 item1, T2 item2) { - StringBuilder sb = new StringBuilder ("("); - for (int i = 0; i < pi.Length; ++i) { - if (i != 0) - sb.Append (", "); - sb.Append (ParameterDesc (i)); - } - if (is_varargs) { - if (pi.Length > 0) - sb.Append (", "); - sb.Append ("__arglist"); - } - sb.Append (')'); - return sb.ToString (); + Item1 = item1; + Item2 = item2; } - public Type ParameterType (int pos) - { - if (is_varargs && pos >= pi.Length) - return TypeManager.runtime_argument_handle_type; - - return pi [pos].ParameterType; - } + public T1 Item1 { get; private set; } + public T2 Item2 { get; private set; } - public string ParameterName (int pos) + public override int GetHashCode () { - if (gpd != null) - return gpd.ParameterName (pos); - - if (is_varargs && pos >= pi.Length) - return "__arglist"; - - return pi [pos].Name; + return Item1.GetHashCode () ^ Item2.GetHashCode (); } - public string ParameterDesc (int pos) - { - if (is_varargs && pos >= pi.Length) - return ""; + #region IEquatable> Members - StringBuilder sb = new StringBuilder (); - - if (pi [pos].IsIn) - sb.Append ("in "); - - Type partype = ParameterType (pos); - if (partype.IsByRef){ - partype = TypeManager.GetElementType (partype); - if (pi [pos].IsOut) - sb.Append ("out "); - else - sb.Append ("ref "); - } - - if (params_idx == pos) - sb.Append ("params "); - - sb.Append (TypeManager.CSharpName (partype).Replace ("&", "")); - - return sb.ToString (); - } - - public Parameter.Modifier ParameterModifier (int pos) + public bool Equals (Tuple other) { - if (pos == params_idx) - return Parameter.Modifier.PARAMS; - else if (is_varargs && pos >= pi.Length) - return Parameter.Modifier.ARGLIST; - - if (gpd != null) - return gpd.ParameterModifier (pos); - - Type t = pi [pos].ParameterType; - if (t.IsByRef){ - if ((pi [pos].Attributes & (ParameterAttributes.Out|ParameterAttributes.In)) == ParameterAttributes.Out) - return Parameter.Modifier.OUT; - else - return Parameter.Modifier.REF; - } - - return Parameter.Modifier.NONE; - } - - public int Count { - get { return is_varargs ? pi.Length + 1 : pi.Length; } + return EqualityComparer.Default.Equals (Item1, other.Item1) && + EqualityComparer.Default.Equals (Item2, other.Item2); } - public bool HasParams { - get { return params_idx != -1; } - } - - public Type[] Types { - get { return types; } - } + #endregion } -#if GMCS_SOURCE - public class ReflectionConstraints : GenericConstraints + public class Tuple : IEquatable> { - GenericParameterAttributes attrs; - Type base_type; - Type class_constraint; - Type[] iface_constraints; - string name; - - public static GenericConstraints GetConstraints (Type t) + public Tuple (T1 item1, T2 item2, T3 item3) { - Type [] constraints = t.GetGenericParameterConstraints (); - GenericParameterAttributes attrs = t.GenericParameterAttributes; - if (constraints.Length == 0 && attrs == GenericParameterAttributes.None) - return null; - return new ReflectionConstraints (t.Name, constraints, attrs); + Item1 = item1; + Item2 = item2; + Item3 = item3; } - private ReflectionConstraints (string name, Type [] constraints, GenericParameterAttributes attrs) + public T1 Item1 { get; private set; } + public T2 Item2 { get; private set; } + public T3 Item3 { get; private set; } + + public override int GetHashCode () { - this.name = name; - this.attrs = attrs; - - if ((constraints.Length > 0) && !constraints [0].IsInterface) { - class_constraint = constraints [0]; - iface_constraints = new Type [constraints.Length - 1]; - Array.Copy (constraints, 1, iface_constraints, 0, constraints.Length - 1); - } else - iface_constraints = constraints; - - if (HasValueTypeConstraint) - base_type = TypeManager.value_type; - else if (class_constraint != null) - base_type = class_constraint; - else - base_type = TypeManager.object_type; + return Item1.GetHashCode () ^ Item2.GetHashCode () ^ Item3.GetHashCode (); } - public override string TypeParameter { - get { return name; } - } + #region IEquatable> Members - public override GenericParameterAttributes Attributes { - get { return attrs; } + public bool Equals (Tuple other) + { + return EqualityComparer.Default.Equals (Item1, other.Item1) && + EqualityComparer.Default.Equals (Item2, other.Item2) && + EqualityComparer.Default.Equals (Item3, other.Item3); } - public override Type ClassConstraint { - get { return class_constraint; } - } + #endregion + } - public override Type EffectiveBaseClass { - get { return base_type; } + static class Tuple + { + public static Tuple Create (T1 item1, T2 item2) + { + return new Tuple (item1, item2); } - public override Type[] InterfaceConstraints { - get { return iface_constraints; } + public static Tuple Create (T1 item1, T2 item2, T3 item3) + { + return new Tuple (item1, item2, item3); } } #endif - class PtrHashtable : Hashtable { - sealed class PtrComparer : IComparer { - private PtrComparer () {} + static class ArrayComparer + { + public static bool IsEqual (T[] array1, T[] array2) + { + if (array1 == null || array2 == null) + return array1 == array2; - public static PtrComparer Instance = new PtrComparer (); + var eq = EqualityComparer.Default; - public int Compare (object x, object y) - { - if (x == y) - return 0; - else - return 1; + for (int i = 0; i < array1.Length; ++i) { + if (!eq.Equals (array1[i], array2[i])) { + return false; + } } - } - public PtrHashtable () - { - comparer = PtrComparer.Instance; + return true; } } - /* - * 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; - } - } + /// + /// This is an arbitrarily seekable StreamReader wrapper. + /// + /// It uses a self-tuning buffer to cache the seekable data, + /// but if the seek is too far, it may read the underly + /// stream all over from the beginning. + /// + public class SeekableStreamReader : IDisposable + { + StreamReader reader; + Stream stream; - private int len; + static char[] buffer; + int read_ahead_length; // the length of read buffer + int buffer_start; // in chars + int char_count; // count of filled characters in buffer[] + int pos; // index into buffer[] - protected override int GetHash (Object key) + public SeekableStreamReader (Stream stream, Encoding encoding) { - char[] arr = (char[])key; - int h = 0; - - for (int i = 0; i < len; ++i) - h = (h << 5) - h + arr [i]; + this.stream = stream; - return h; + const int default_read_ahead = 2048; + InitializeStream (default_read_ahead); + reader = new StreamReader (stream, encoding, true); } - public CharArrayHashtable (int len) + public void Dispose () { - this.len = len; - comparer = new ArrComparer (len); + // Needed to release stream reader buffers + reader.Dispose (); } - } - - struct Pair { - public object First; - public object Second; - public Pair (object f, object s) + void InitializeStream (int read_length_inc) { - First = f; - Second = s; - } - } + read_ahead_length += read_length_inc; - /// - /// This is a wrapper around StreamReader which is seekable backwards - /// within a window of around 2048 chars. - /// - public class SeekableStreamReader - { - public SeekableStreamReader (StreamReader reader) - { - this.reader = reader; - this.buffer = new char [AverageReadLength * 3]; + int required_buffer_size = read_ahead_length * 2; - // Let the StreamWriter autodetect the encoder - reader.Peek (); - } + if (buffer == null || buffer.Length < required_buffer_size) + buffer = new char [required_buffer_size]; - public SeekableStreamReader (Stream stream, Encoding encoding) - : this (new StreamReader (stream, encoding, true)) - { } - - StreamReader reader; - - private const int AverageReadLength = 1024; - - char[] buffer; - int buffer_start; // in chars - int char_count; // count buffer[] valid characters - int pos; // index into buffer[] + stream.Position = 0; + buffer_start = char_count = pos = 0; + } /// /// This value corresponds to the current position in a stream of characters. @@ -377,34 +181,75 @@ namespace Mono.CSharp { /// a correlation between them. /// public int Position { - get { return buffer_start + pos; } + get { + return buffer_start + pos; + } set { - if (value < buffer_start || value > buffer_start + char_count) - throw new InternalErrorException ("can't seek that far back: " + (pos - value)); + // + // If the lookahead was too small, re-read from the beginning. Increase the buffer size while we're at it + // This should never happen until we are parsing some weird source code + // + if (value < buffer_start) { + InitializeStream (read_ahead_length); + + // + // Discard buffer data after underlying stream changed position + // Cannot use handy reader.DiscardBufferedData () because it for + // some strange reason resets encoding as well + // + reader = new StreamReader (stream, reader.CurrentEncoding, true); + } + + while (value > buffer_start + char_count) { + pos = char_count; + if (!ReadBuffer ()) + throw new InternalErrorException ("Seek beyond end of file: " + (buffer_start + char_count - value)); + } + pos = value - buffer_start; } } - private bool ReadBuffer () + bool ReadBuffer () { int slack = buffer.Length - char_count; - if (slack <= AverageReadLength / 2) { - // shift the buffer to make room for AverageReadLength number of characters - int shift = AverageReadLength - slack; + + // + // read_ahead_length is only half of the buffer to deal with + // reads ahead and moves back without re-reading whole buffer + // + if (slack <= read_ahead_length) { + // + // shift the buffer to make room for read_ahead_length number of characters + // + int shift = read_ahead_length - slack; Array.Copy (buffer, shift, buffer, 0, char_count - shift); + + // Update all counters pos -= shift; char_count -= shift; buffer_start += shift; - slack += shift; // slack == AverageReadLength + slack += shift; } - int chars_read = reader.Read (buffer, char_count, slack); - char_count += chars_read; + char_count += reader.Read (buffer, char_count, slack); return pos < char_count; } + public char[] ReadChars (int fromPosition, int toPosition) + { + char[] chars = new char[toPosition - fromPosition]; + if (buffer_start <= fromPosition && toPosition <= buffer_start + buffer.Length) { + Array.Copy (buffer, fromPosition - buffer_start, chars, 0, chars.Length); + } else { + throw new NotImplementedException (); + } + + return chars; + } + public int Peek () { if ((pos >= char_count) && !ReadBuffer ()) @@ -422,84 +267,51 @@ namespace Mono.CSharp { } } - public class DoubleHash { - const int DEFAULT_INITIAL_BUCKETS = 100; - - public DoubleHash () : this (DEFAULT_INITIAL_BUCKETS) {} - - public DoubleHash (int size) + public class UnixUtils { + [System.Runtime.InteropServices.DllImport ("libc", EntryPoint="isatty")] + extern static int _isatty (int fd); + + public static bool isatty (int fd) { - count = size; - buckets = new Entry [size]; - } - - int count; - Entry [] buckets; - int size = 0; - - class Entry { - public object key1; - public object key2; - public int hash; - public object value; - public Entry next; - - public Entry (object key1, object key2, int hash, object value, Entry next) - { - this.key1 = key1; - this.key2 = key2; - this.hash = hash; - this.next = next; - this.value = value; + try { + return _isatty (fd) == 1; + } catch { + return false; } } + } - public bool Lookup (object a, object b, out object res) + /// + /// An exception used to terminate the compiler resolution phase and provide completions + /// + /// + /// This is thrown when we want to return the completions or + /// terminate the completion process by AST nodes used in + /// the completion process. + /// + public class CompletionResult : Exception { + string [] result; + string base_text; + + public CompletionResult (string base_text, string [] res) { - int h = (a.GetHashCode () ^ b.GetHashCode ()) & 0x7FFFFFFF; + if (base_text == null) + throw new ArgumentNullException ("base_text"); + this.base_text = base_text; - for (Entry e = buckets [h % count]; e != null; e = e.next) { - if (e.hash == h && e.key1.Equals (a) && e.key2.Equals (b)) { - res = e.value; - return true; - } - } - res = null; - return false; + result = res; + Array.Sort (result); } - public void Insert (object a, object b, object value) - { - // Is it an existing one? - - int h = (a.GetHashCode () ^ b.GetHashCode ()) & 0x7FFFFFFF; - - for (Entry e = buckets [h % count]; e != null; e = e.next) { - if (e.hash == h && e.key1.Equals (a) && e.key2.Equals (b)) - e.value = value; + public string [] Result { + get { + return result; } + } - int bucket = h % count; - buckets [bucket] = new Entry (a, b, h, value, buckets [bucket]); - - // Grow whenever we double in size - if (size++ == count) { - count <<= 1; - count ++; - - Entry [] newBuckets = new Entry [count]; - foreach (Entry root in buckets) { - Entry e = root; - while (e != null) { - int newLoc = e.hash % count; - Entry n = e.next; - e.next = newBuckets [newLoc]; - newBuckets [newLoc] = e; - e = n; - } - } - - buckets = newBuckets; + public string BaseText { + get { + return base_text; } } }