X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fmcs%2Fsupport.cs;h=8fcb5bf6081b058042eb984fdb684167c9412570;hb=b7dc3a9663532553ea61bcaee3b41bc808617829;hp=4cba731c3b6249cc19eb89e9799b5f65e2c17f94;hpb=ba9b512cfa2332c63bc8354a5949616a3b59f2bc;p=mono.git diff --git a/mcs/mcs/support.cs b/mcs/mcs/support.cs index 4cba731c3b6..8fcb5bf6081 100644 --- a/mcs/mcs/support.cs +++ b/mcs/mcs/support.cs @@ -4,404 +4,73 @@ // // 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 // 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; } - Type ExtensionMethodType { get; } - bool HasParams { get; } - string ParameterName (int pos); - string ParameterDesc (int pos); - - Parameter.Modifier ParameterModifier (int pos); - string GetSignatureForError (); - -#if MS_COMPATIBLE - ParameterData InflateTypes (Type[] genArguments, Type[] argTypes); -#endif - } - - public class ReflectionParameters : ParameterData { - ParameterInfo [] pi; - Type [] types; - int params_idx = -1; - bool is_varargs; - bool is_extension; - ParameterData gpd; - - public ReflectionParameters (MethodBase mb) - { - 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-1) & Parameter.Modifier.PARAMS) != 0) { - this.params_idx = i-1; - 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; - - if (pi [i].IsDefined (TypeManager.param_array_type, false)) { - params_idx = i; - break; - } - } - - if (TypeManager.extension_attribute_type != null && mb.IsStatic && - (mb.DeclaringType.Attributes & Class.StaticClassAttribute) == Class.StaticClassAttribute && - mb.IsDefined (TypeManager.extension_attribute_type, false)) - is_extension = true; - } - - public override bool Equals (object obj) - { - 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; - } - - public override int GetHashCode () - { - return base.GetHashCode (); - } - - public string GetSignatureForError () - { - 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 (); - } - -#if MS_COMPATIBLE - public ParameterData InflateTypes (Type[] genArguments, Type[] argTypes) - { - ReflectionParameters p = (ReflectionParameters)MemberwiseClone (); - - for (int i = 0; i < types.Length; ++i) { - if (types[i].IsGenericParameter) { - for (int ii = 0; ii < genArguments.Length; ++ii) { - if (types[i] != genArguments[ii]) - continue; - - p.types[i] = argTypes[ii]; - break; - } - continue; - } - - if (types[i].IsGenericType) { - Type[] gen_arguments_open = types[i].GetGenericTypeDefinition ().GetGenericArguments (); - Type[] gen_arguments = types[i].GetGenericArguments (); - for (int ii = 0; ii < gen_arguments_open.Length; ++ii) { - if (gen_arguments [ii].IsGenericParameter) { - for (int iii = 0; iii < genArguments.Length; ++iii) { - if (gen_arguments [ii] != genArguments [iii]) - continue; - - gen_arguments_open [ii] = argTypes [iii]; - break; - } - } else { - gen_arguments_open [ii] = gen_arguments [ii]; - } - } - - p.types[i] = types[i].GetGenericTypeDefinition ().MakeGenericType (gen_arguments_open); - } - } - return p; - } -#endif + sealed class ReferenceEquality : IEqualityComparer where T : class + { + public static readonly IEqualityComparer Default = new ReferenceEquality (); - public Type ParameterType (int pos) + private ReferenceEquality () { - if (is_varargs && pos >= pi.Length) - return TypeManager.runtime_argument_handle_type; - - return types [pos]; } - public string ParameterName (int pos) + public bool Equals (T x, T y) { - if (gpd != null) - return gpd.ParameterName (pos); - - if (is_varargs && pos >= pi.Length) - return "__arglist"; - - return pi [pos].Name; + return ReferenceEquals (x, y); } - public string ParameterDesc (int pos) + public int GetHashCode (T obj) { - if (is_varargs && pos >= pi.Length) - return ""; - - 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 "); - - if (pos == 0 && ExtensionMethodType != null) - sb.Append ("this "); - - sb.Append (TypeManager.CSharpName (partype).Replace ("&", "")); - - return sb.ToString (); - } - - public Parameter.Modifier ParameterModifier (int pos) - { - 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 = types [pos]; - 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; } - } - - public Type ExtensionMethodType { - get { - if (!is_extension) - return null; - - return types [0]; - } - } - - public bool HasParams { - get { return params_idx != -1; } - } - - public Type[] Types { - get { return types; } + return System.Runtime.CompilerServices.RuntimeHelpers.GetHashCode (obj); } } -#if GMCS_SOURCE - public class ReflectionConstraints : GenericConstraints + 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) { - Type [] constraints = t.GetGenericParameterConstraints (); - GenericParameterAttributes attrs = t.GenericParameterAttributes; - if (constraints.Length == 0 && attrs == GenericParameterAttributes.None) - return null; - return new ReflectionConstraints (t.Name, constraints, attrs); - } - - private ReflectionConstraints (string name, Type [] constraints, GenericParameterAttributes attrs) - { - 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; - } - - public override string TypeParameter { - get { return name; } - } - - public override GenericParameterAttributes Attributes { - get { return attrs; } - } - - public override Type ClassConstraint { - get { return class_constraint; } - } - - public override Type EffectiveBaseClass { - get { return base_type; } - } - - public override Type[] InterfaceConstraints { - get { return iface_constraints; } + Item1 = item1; + Item2 = item2; } - } -#endif - - class PtrHashtable : Hashtable { - sealed class PtrComparer : IComparer { - private PtrComparer () {} - public static PtrComparer Instance = new PtrComparer (); + public T1 Item1 { get; private set; } + public T2 Item2 { get; private set; } - public int Compare (object x, object y) - { - if (x == y) - return 0; - else - return 1; - } - } - - public PtrHashtable () + public override int GetHashCode () { - comparer = PtrComparer.Instance; + return Item1.GetHashCode () ^ Item2.GetHashCode (); } - } - /* - * Hashtable whose keys are character arrays with the same length - */ - class CharArrayHashtable : Hashtable { - sealed class ArrComparer : IComparer { - private int len; + #region IEquatable> Members - 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) + public bool Equals (Tuple other) { - char[] arr = (char[])key; - int h = 0; - - for (int i = 0; i < len; ++i) - h = (h << 5) - h + arr [i]; - - return h; + return EqualityComparer.Default.Equals (Item1, other.Item1) && + EqualityComparer.Default.Equals (Item2, other.Item2); } - public CharArrayHashtable (int len) - { - this.len = len; - comparer = new ArrComparer (len); - } + #endregion } - struct Pair { - public object First; - public object Second; - - public Pair (object f, object s) + static class Tuple + { + public static Tuple Create (T1 item1, T2 item2) { - First = f; - Second = s; + return new Tuple (item1, item2); } } @@ -420,17 +89,21 @@ namespace Mono.CSharp { } /// - /// This is a wrapper around StreamReader which is seekable backwards - /// within a window of around 2048 chars. + /// 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 + public class SeekableStreamReader : IDisposable { - const int AverageReadLength = 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[] @@ -438,13 +111,28 @@ namespace Mono.CSharp { public SeekableStreamReader (Stream stream, Encoding encoding) { this.stream = stream; - this.encoding = encoding; - - this.reader = new StreamReader (stream, encoding, true); - this.buffer = new char [AverageReadLength * 3]; - // Let the StreamWriter autodetect the encoder - reader.Peek (); + const int default_average_read_length = 1024; + InitializeStream (default_average_read_length); + reader = new StreamReader (stream, encoding, true); + } + + public void Dispose () + { + // Needed to release stream reader buffers + reader.Dispose (); + } + + 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; } /// @@ -458,23 +146,14 @@ namespace Mono.CSharp { get { return buffer_start + pos; } set { - if (value > buffer_start + char_count) - throw new InternalErrorException ("can't seek that far forward: " + (pos - value)); - - if (value < buffer_start){ - // Reinitialize. - stream.Position = 0; - reader = new StreamReader (stream, encoding, true); - buffer_start = 0; - char_count = 0; - pos = 0; - Peek (); - - while (value > buffer_start + char_count){ - pos = char_count+1; - int p = Peek (); - } - pos = value - buffer_start; + // If the lookahead was too small, re-read from the beginning. Increase the buffer size while we're at it + if (value < buffer_start) + InitializeStream (average_read_length / 2); + + 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; @@ -484,18 +163,17 @@ namespace Mono.CSharp { private 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; + if (slack <= average_read_length / 2) { + // shift the buffer to make room for average_read_length number of characters + int shift = average_read_length - slack; Array.Copy (buffer, shift, buffer, 0, char_count - shift); pos -= shift; char_count -= shift; buffer_start += shift; - slack += shift; // slack == AverageReadLength + slack += shift; // slack == average_read_length } - 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; } @@ -599,88 +277,52 @@ namespace Mono.CSharp { } } - class PartialMethodDefinitionInfo : MethodInfo - { - MethodOrOperator mc; - MethodAttributes attrs; - - public PartialMethodDefinitionInfo (MethodOrOperator mc) - { - this.mc = mc; - if ((mc.ModFlags & Modifiers.STATIC) != 0) - attrs = MethodAttributes.Static; - } - - public override MethodInfo GetBaseDefinition () - { - throw new NotImplementedException (); - } - - public override ICustomAttributeProvider ReturnTypeCustomAttributes - { - get { throw new NotImplementedException (); } - } - - public override MethodAttributes Attributes - { - get { return attrs; } - } - - public override MethodImplAttributes GetMethodImplementationFlags () - { - throw new NotImplementedException (); - } - - public override ParameterInfo [] GetParameters () - { - throw new NotImplementedException (); - } - - public override object Invoke (object obj, BindingFlags invokeAttr, Binder binder, object [] parameters, CultureInfo culture) - { - throw new NotImplementedException (); - } - - public override RuntimeMethodHandle MethodHandle - { - get { throw new NotImplementedException (); } - } - - public override Type DeclaringType - { - get { return mc.Parent.TypeBuilder; } - } - - public override object [] GetCustomAttributes (Type attributeType, bool inherit) - { - throw new NotImplementedException (); - } - - public override object [] GetCustomAttributes (bool inherit) + public class UnixUtils { + [System.Runtime.InteropServices.DllImport ("libc", EntryPoint="isatty")] + extern static int _isatty (int fd); + + public static bool isatty (int fd) { - throw new NotImplementedException (); + try { + return _isatty (fd) == 1; + } catch { + return false; + } } + } - public override Type ReturnType { + /// + /// 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) + { + if (base_text == null) + throw new ArgumentNullException ("base_text"); + this.base_text = base_text; + + result = res; + Array.Sort (result); + } + + public string [] Result { get { - return mc.MemberType; + return result; } } - public override bool IsDefined (Type attributeType, bool inherit) - { - throw new NotImplementedException (); - } - - public override string Name - { - get { return mc.Name; } - } - - public override Type ReflectedType - { - get { throw new NotImplementedException (); } + public string BaseText { + get { + return base_text; + } } } - }