Imported Upstream version 4.0.0~alpha1

Former-commit-id: 806294f5ded97629b74c85c09952f2a74fe182d9

mcs/class/I18N/Common/ByteEncoding.cs

@@ -48,11 +48,9 @@ public abstract class ByteEncoding : MonoEncoding
 	protected bool isMailNewsDisplay;
 	protected bool isMailNewsSave;
 	protected int windowsCodePage;
-#if NET_2_0
 	static byte [] isNormalized;
 	static byte [] isNormalizedComputed;
 	static byte [] normalization_bytes;
-#endif
 
 	// Constructor.
 	protected ByteEncoding(int codePage, char[] toChars,
@@ -78,7 +76,6 @@ public abstract class ByteEncoding : MonoEncoding
 				this.windowsCodePage = windowsCodePage;
 			}
 
-#if NET_2_0
 	public override bool IsAlwaysNormalized (NormalizationForm form)
 	{
 		if (form != NormalizationForm.FormC)
@@ -114,7 +111,6 @@ public abstract class ByteEncoding : MonoEncoding
 	public override bool IsSingleByte {
 		get { return true; }
 	}
-#endif
 
 	public override int GetByteCount(String s)
 			{

mcs/class/I18N/Common/ByteSafeEncoding.cs

@@ -51,11 +51,9 @@ public abstract class ByteSafeEncoding : MonoSafeEncoding
 	protected bool isMailNewsDisplay;
 	protected bool isMailNewsSave;
 	protected int windowsCodePage;
-#if NET_2_0
 	static byte [] isNormalized;
 	static byte [] isNormalizedComputed;
 	static byte [] normalization_bytes;
-#endif
 
 	// Constructor.
 	protected ByteSafeEncoding(int codePage, char[] toChars,
@@ -81,7 +79,6 @@ public abstract class ByteSafeEncoding : MonoSafeEncoding
 				this.windowsCodePage = windowsCodePage;
 			}
 
-#if NET_2_0
 	public override bool IsAlwaysNormalized (NormalizationForm form)
 	{
 		if (form != NormalizationForm.FormC)
@@ -117,7 +114,6 @@ public abstract class ByteSafeEncoding : MonoSafeEncoding
 	public override bool IsSingleByte {
 		get { return true; }
 	}
-#endif
 
 	public override int GetByteCount(String s)
 	{

mcs/class/I18N/Common/DefaultEncoder.cs

@@ -0,0 +1,148 @@
+// This is partially copied source from referencesource/mscorlib/system/text/encoding.cs, modifying a bit.
+
+// ==++==
+//
+//   Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+using System.Diagnostics.Contracts;
+using System.Runtime.InteropServices;
+using System.Runtime.Serialization;
+using System.Text;
+
+namespace I18N.Common
+{
+        [Serializable]
+        public class ReferenceSourceDefaultEncoder : Encoder, IObjectReference
+        {
+            private Encoding m_encoding;
+            [NonSerialized] private bool m_hasInitializedEncoding;
+
+            [NonSerialized] internal char charLeftOver;
+
+            public ReferenceSourceDefaultEncoder(Encoding encoding)
+            {
+                m_encoding = encoding;
+                m_hasInitializedEncoding = true;
+            }
+
+            // Constructor called by serialization, have to handle deserializing from Everett
+            internal ReferenceSourceDefaultEncoder(SerializationInfo info, StreamingContext context)
+            {
+                if (info==null) throw new ArgumentNullException("info");
+                Contract.EndContractBlock();
+
+                // All we have is our encoding
+                this.m_encoding = (Encoding)info.GetValue("encoding", typeof(Encoding));
+
+                try 
+                {
+                    //this.m_fallback     = (EncoderFallback) info.GetValue("m_fallback",   typeof(EncoderFallback));
+                    this.charLeftOver   = (Char)            info.GetValue("charLeftOver", typeof(Char));
+                }
+                catch (SerializationException)
+                {
+                }
+            }
+
+            // Just get it from GetEncoding
+            [System.Security.SecurityCritical]  // auto-generated
+            public Object GetRealObject(StreamingContext context)
+            {
+                // upon deserialization since the DefaultEncoder implement IObjectReference the 
+                // serialization code tries to do the fixup. The fixup returns another 
+                // IObjectReference (the DefaultEncoder) class and hence so on and on. 
+                // Finally the deserialization logics fails after following maximum references
+                // unless we short circuit with the following
+                if (m_hasInitializedEncoding)
+                {
+                    return this;
+                }
+
+                Encoder encoder = m_encoding.GetEncoder();
+                /*
+                if (m_fallback != null)
+                    encoder.m_fallback = m_fallback;
+                if (charLeftOver != (char) 0)
+                {
+                    EncoderNLS encoderNls = encoder as EncoderNLS;
+                    if (encoderNls != null)
+                        encoderNls.charLeftOver = charLeftOver;
+                }
+                */
+                return encoder;
+            }
+
+#if FEATURE_SERIALIZATION
+            // ISerializable implementation, get data for this object
+            [System.Security.SecurityCritical]  // auto-generated_required
+            void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
+            {
+                // Any info?
+                if (info==null) throw new ArgumentNullException("info");
+                Contract.EndContractBlock();
+
+                // All we have is our encoding
+                info.AddValue("encoding", this.m_encoding);
+            }
+#endif
+
+            // Returns the number of bytes the next call to GetBytes will
+            // produce if presented with the given range of characters and the given
+            // value of the flush parameter. The returned value takes into
+            // account the state in which the encoder was left following the last call
+            // to GetBytes. The state of the encoder is not affected by a call
+            // to this method.
+            //
+
+            public override int GetByteCount(char[] chars, int index, int count, bool flush)
+            {
+                return m_encoding.GetByteCount(chars, index, count);
+            }
+
+            [System.Security.SecurityCritical]  // auto-generated
+            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
+            public unsafe override int GetByteCount(char* chars, int count, bool flush)
+            {
+                return m_encoding.GetByteCount(chars, count);
+            }
+
+            // Encodes a range of characters in a character array into a range of bytes
+            // in a byte array. The method encodes charCount characters from
+            // chars starting at index charIndex, storing the resulting
+            // bytes in bytes starting at index byteIndex. The encoding
+            // takes into account the state in which the encoder was left following the
+            // last call to this method. The flush parameter indicates whether
+            // the encoder should flush any shift-states and partial characters at the
+            // end of the conversion. To ensure correct termination of a sequence of
+            // blocks of encoded bytes, the last call to GetBytes should specify
+            // a value of true for the flush parameter.
+            //
+            // An exception occurs if the byte array is not large enough to hold the
+            // complete encoding of the characters. The GetByteCount method can
+            // be used to determine the exact number of bytes that will be produced for
+            // a given range of characters. Alternatively, the GetMaxByteCount
+            // method of the Encoding that produced this encoder can be used to
+            // determine the maximum number of bytes that will be produced for a given
+            // number of characters, regardless of the actual character values.
+            //
+
+            public override int GetBytes(char[] chars, int charIndex, int charCount,
+                                          byte[] bytes, int byteIndex, bool flush)
+            {
+                return m_encoding.GetBytes(chars, charIndex, charCount, bytes, byteIndex);
+            }
+
+            [System.Security.SecurityCritical]  // auto-generated
+            [SuppressMessage("Microsoft.Contracts", "CC1055")]  // Skip extra error checking to avoid *potential* AppCompat problems.
+            public unsafe override int GetBytes(char* chars, int charCount,
+                                                 byte* bytes, int byteCount, bool flush)
+            {
+                return m_encoding.GetBytes(chars, charCount, bytes, byteCount);
+            }
+        }
+}

mcs/class/I18N/Common/I18N.dll.sources

@@ -6,4 +6,5 @@ Handlers.cs
 Manager.cs
 MonoEncoding.cs
 MonoSafeEncoding.cs
+DefaultEncoder.cs
 Strings.cs

mcs/class/I18N/Common/MonoEncoding.cs

@@ -32,7 +32,6 @@ namespace I18N.Common
 			get { return win_code_page != 0 ? win_code_page : base.WindowsCodePage; }
 		}
 
-#if NET_2_0
 		/// <summary>
 		/// GetBytes method used internally by state-full encoders/encodings.
 		/// </summary>
@@ -90,7 +89,6 @@ namespace I18N.Common
 			HandleFallback(ref buffer, chars, ref charIndex, ref charCount,
 				bytes, ref byteIndex, ref byteCount, null);
 		}
-#endif
 
 		// Get the bytes that result from encoding a character buffer.
 		public override int GetByteCount (
@@ -193,7 +191,6 @@ namespace I18N.Common
 			}
 		}
 
-#if NET_2_0
 		public unsafe override int GetByteCount (char* chars, int count)
 
 		{
@@ -206,7 +203,6 @@ namespace I18N.Common
 		{
 			return GetBytesImpl (chars, charCount, bytes, byteCount);
 		}
-#endif
 
 		//[CLSCompliant (false)]
 		public unsafe abstract int GetByteCountImpl (char* chars, int charCount);
@@ -214,19 +210,20 @@ namespace I18N.Common
 		//[CLSCompliant (false)]
 		public unsafe abstract int GetBytesImpl (char* chars, int charCount,
 			byte* bytes, int byteCount);
+		
+		public override Encoder GetEncoder ()
+		{
+			return new MonoEncodingDefaultEncoder (this);
+		}
 	}
 
 		public abstract class MonoEncoder : Encoder
 		{
-#if NET_2_0
 			MonoEncoding encoding;
-#endif
 
 			public MonoEncoder (MonoEncoding encoding)
 			{
-#if NET_2_0
 				this.encoding = encoding;
-#endif
 			}
 
 			public override int GetByteCount (
@@ -289,7 +286,6 @@ namespace I18N.Common
 
 			public unsafe abstract int GetBytesImpl (char* chars, int charCount, byte* bytes, int byteCount, bool refresh);
 
-		#if NET_2_0
 			public unsafe override int GetBytes (char* chars, int charCount, byte* bytes, int byteCount, bool flush)
 			{
 				return GetBytesImpl (chars, charCount, bytes, byteCount, flush);
@@ -312,6 +308,77 @@ namespace I18N.Common
 				HandleFallback(chars, ref charIndex, ref charCount,
 					bytes, ref byteIndex, ref byteCount, null);
 			}*/
-		#endif
 		}
+
+	public class MonoEncodingDefaultEncoder : ReferenceSourceDefaultEncoder
+	{
+		public MonoEncodingDefaultEncoder (Encoding encoding)
+			: base (encoding)
+		{
+		}
+
+		[CLSCompliant (false)]
+		[ComVisible (false)]
+		public unsafe override void Convert (
+			char* chars, int charCount,
+			byte* bytes, int byteCount, bool flush,
+			out int charsUsed, out int bytesUsed, out bool completed)
+		{
+			CheckArguments (chars, charCount, bytes, byteCount);
+
+			charsUsed = charCount;
+			while (true) {
+				bytesUsed = GetByteCount (chars, charsUsed, flush);
+				if (bytesUsed <= byteCount)
+					break;
+				flush = false;
+				charsUsed >>= 1;
+			}
+			completed = charsUsed == charCount;
+			bytesUsed = GetBytes (chars, charsUsed, bytes, byteCount, flush);
+		}
+
+		[ComVisible (false)]
+		public override void Convert (
+			char [] chars, int charIndex, int charCount,
+			byte [] bytes, int byteIndex, int byteCount, bool flush,
+			out int charsUsed, out int bytesUsed, out bool completed)
+		{
+			if (chars == null)
+				throw new ArgumentNullException ("chars");
+			if (bytes == null)
+				throw new ArgumentNullException ("bytes");
+			if (charIndex < 0)
+				throw new ArgumentOutOfRangeException ("charIndex");
+			if (charCount < 0 || chars.Length < charIndex + charCount)
+				throw new ArgumentOutOfRangeException ("charCount");
+			if (byteIndex < 0)
+				throw new ArgumentOutOfRangeException ("byteIndex");
+			if (byteCount < 0 || bytes.Length < byteIndex + byteCount)
+				throw new ArgumentOutOfRangeException ("byteCount");
+
+			charsUsed = charCount;
+			while (true) {
+				bytesUsed = GetByteCount (chars, charIndex, charsUsed, flush);
+				if (bytesUsed <= byteCount)
+					break;
+				flush = false;
+				charsUsed >>= 1;
+			}
+			completed = charsUsed == charCount;
+			bytesUsed = GetBytes (chars, charIndex, charsUsed, bytes, byteIndex, flush);
+		}
+
+		unsafe void CheckArguments (char* chars, int charCount, byte* bytes, int byteCount)
+		{
+			if (chars == null)
+				throw new ArgumentNullException ("chars");
+			if (bytes == null)
+				throw new ArgumentNullException ("bytes");
+			if (charCount < 0)
+				throw new ArgumentOutOfRangeException ("charCount");
+			if (byteCount < 0)
+				throw new ArgumentOutOfRangeException ("byteCount");
+		}
+	}
 }

mcs/class/I18N/Common/MonoSafeEncoding.cs

@@ -87,15 +87,11 @@ namespace I18N.Common
 
 		public abstract class MonoSafeEncoder : Encoder
 		{
-#if NET_2_0
 			MonoSafeEncoding encoding;
-#endif
 
 			public MonoSafeEncoder (MonoSafeEncoding encoding)
 			{
-#if NET_2_0
 				this.encoding = encoding;
-#endif
 			}
 
 			public void HandleFallback(