X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mcs%2Fgmcs%2Fsupport.cs;h=328fbbeea7e1d5931cbab066838ee21a9c27d1ad;hb=33828ad95f877e3e5ae6bac604a2db3760b8ea7b;hp=a813eff8aaefc51975b93c19c62ae6193691562e;hpb=2a8259225695032220537b3c90a99d7a2686f214;p=mono.git diff --git a/mcs/gmcs/support.cs b/mcs/gmcs/support.cs index a813eff8aae..328fbbeea7e 100644 --- a/mcs/gmcs/support.cs +++ b/mcs/gmcs/support.cs @@ -26,6 +26,7 @@ namespace Mono.CSharp { string ParameterName (int pos); string ParameterDesc (int pos); Parameter.Modifier ParameterModifier (int pos); + string GetSignatureForError (); } public class ReflectionParameters : ParameterData { @@ -68,6 +69,23 @@ namespace Mono.CSharp { last_arg_is_params = true; } + + 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 (); + } public Type ParameterType (int pos) { @@ -127,8 +145,8 @@ namespace Mono.CSharp { if (pos >= pi.Length - 1 && last_arg_is_params) sb.Append ("params "); - - sb.Append (TypeManager.CSharpName (partype)); + + sb.Append (TypeManager.CSharpName (partype).Replace ("&", "")); return sb.ToString (); @@ -220,6 +238,23 @@ namespace Mono.CSharp { return Parameters.ArrayParameter; } + public string GetSignatureForError () + { + StringBuilder sb = new StringBuilder ("("); + for (int i = 0; i < count; ++i) { + if (i != 0) + sb.Append (", "); + sb.Append (ParameterDesc (i)); + } + if (has_varargs) { + if (count > 0) + sb.Append (", "); + sb.Append ("__arglist"); + } + sb.Append (')'); + return sb.ToString (); + } + public Type ParameterType (int pos) { if (has_varargs && pos >= count) @@ -253,7 +288,7 @@ namespace Mono.CSharp { return "__arglist"; Type t = ParameterType (pos); - return ModifierDesc (pos) + " " + TypeManager.CSharpName (t); + return (ModifierDesc (pos) + " " + TypeManager.CSharpName (t).Replace ("&", "")).TrimStart (); } public string ModifierDesc (int pos) @@ -270,7 +305,6 @@ namespace Mono.CSharp { return "out"; if (p.ModFlags == Parameter.Modifier.PARAMS) return "params"; - return ""; } @@ -295,9 +329,11 @@ namespace Mono.CSharp { Type base_type; Type class_constraint; Type[] iface_constraints; + string name; public ReflectionConstraints (Type t) { + name = t.Name; Type[] constraints = t.GetGenericParameterConstraints (); if ((constraints.Length > 0) && !constraints [0].IsInterface) { class_constraint = constraints [0]; @@ -315,6 +351,10 @@ namespace Mono.CSharp { base_type = TypeManager.object_type; } + public override string TypeParameter { + get { return name; } + } + public override GenericParameterAttributes Attributes { get { return attrs; } } @@ -408,116 +448,67 @@ namespace Mono.CSharp { } /// - /// This is a wrapper around StreamReader which is seekable. + /// 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 [DefaultCacheSize]; - - // Compute the preamble size - + this.buffer = new char [AverageReadLength * 3]; + // Let the StreamWriter autodetect the encoder reader.Peek (); - - reader.BaseStream.Position = 0; - Encoding enc = reader.CurrentEncoding; - // First of all, get at least a char - - byte[] auxb = new byte [50]; - int num_bytes = 0; - int num_chars = 0; - int br = 0; - do { - br = reader.BaseStream.Read (auxb, num_bytes, auxb.Length - num_bytes); - num_bytes += br; - num_chars = enc.GetCharCount (auxb, 0, num_bytes); - } - while (num_chars == 0 && br > 0); - - if (num_chars != 0) - { - // Now, check which bytes at the beginning have no effect in the - // char count - - int p = 0; - while (enc.GetCharCount (auxb, p, num_bytes-p) >= num_chars) - p++; - - preamble_size = p - 1; - reader.BaseStream.Position = 0; - reader.DiscardBufferedData (); - - buffer_start = preamble_size; - } } - public SeekableStreamReader (Stream stream, Encoding encoding, bool detect_encoding_from_bytemarks) - : this (new StreamReader (stream, encoding, detect_encoding_from_bytemarks)) + public SeekableStreamReader (Stream stream, Encoding encoding) + : this (new StreamReader (stream, encoding, true)) { } StreamReader reader; - private const int DefaultCacheSize = 1024; + private const int AverageReadLength = 1024; char[] buffer; - int buffer_start; // in bytes - int buffer_size; // in bytes + int buffer_start; // in chars int char_count; // count buffer[] valid characters int pos; // index into buffer[] - int preamble_size; /// - /// The difference to the StreamReader's BaseStream.Position is that this one is reliable; ie. it - // always reports the correct position and if it's modified, it also takes care of the buffered data. + /// This value corresponds to the current position in a stream of characters. + /// The StreamReader hides its manipulation of the underlying byte stream and all + /// character set/decoding issues. Thus, we cannot use this position to guess at + /// the corresponding position in the underlying byte stream even though there is + /// a correlation between them. /// public int Position { - get { - return buffer_start + reader.CurrentEncoding.GetByteCount (buffer, 0, pos); - } + get { return buffer_start + pos; } set { - // This one is easy: we're modifying the position within our current - // buffer. - if ((value >= buffer_start) && (value < buffer_start + buffer_size)) { - int byte_offset = value - buffer_start; - - // pos is an index into a char - // buffer so it might be - // greater than the buffer - // length now, if the buffer - // contains multibyte chars - pos = byte_offset; - - // encoded characters can take - // more than 1 byte length. - while ((pos > buffer.Length) || - reader.CurrentEncoding.GetByteCount (buffer, 0, pos) > byte_offset) { - pos--; - } - - return; - } - - if (value == 0) // Skip preamble - value = preamble_size; - - // Ok, now we need to seek. - reader.DiscardBufferedData (); - reader.BaseStream.Position = buffer_start = value; - char_count = buffer_size = pos = 0; + if (value < buffer_start || value > buffer_start + char_count) + throw new InternalErrorException ("can't seek that far back: " + (pos - value)); + pos = value - buffer_start; } } private bool ReadBuffer () { - pos = 0; - buffer_start += buffer_size; - char_count = reader.Read (buffer, 0, buffer.Length); - buffer_size = reader.CurrentEncoding.GetByteCount (buffer, 0, char_count); - return buffer_size > 0; + 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; + Array.Copy (buffer, shift, buffer, 0, char_count - shift); + pos -= shift; + char_count -= shift; + buffer_start += shift; + slack += shift; // slack == AverageReadLength + } + + int chars_read = reader.Read (buffer, char_count, slack); + char_count += chars_read; + + return pos < char_count; } public int Peek ()