New test.

[mono.git] / mcs / class / corlib / System.Text / Decoder.cs

diff --git a/mcs/class/corlib/System.Text/Decoder.cs b/mcs/class/corlib/System.Text/Decoder.cs
index 26ac9da4c06378a13e44dc56e129a1d8d1b6f04d..74062465718f4c05303dfe4d855bbcbf831dd165 100644 (file)
--- a/mcs/class/corlib/System.Text/Decoder.cs
+++ b/mcs/class/corlib/System.Text/Decoder.cs
@@ -29,6 +29,9 @@ using System;
 using System.Runtime.InteropServices;
 
 [Serializable]
+#if NET_2_0
+[ComVisible (true)]
+#endif
 public abstract class Decoder
 {
 
@@ -39,6 +42,7 @@ public abstract class Decoder
        DecoderFallback fallback = new DecoderReplacementFallback ();
        DecoderFallbackBuffer fallback_buffer;
 
+       [ComVisible (false)]
        public DecoderFallback Fallback {
                get { return fallback; }
                set {
@@ -49,6 +53,7 @@ public abstract class Decoder
                }
        }
 
+       [ComVisible (false)]
        public DecoderFallbackBuffer FallbackBuffer {
                get {
                        if (fallback_buffer == null)
@@ -66,6 +71,7 @@ public abstract class Decoder
                                                                 char[] chars, int charIndex);
 
 #if NET_2_0
+       [ComVisible (false)]
        public virtual int GetCharCount (byte [] bytes, int index, int count, bool flush)
        {
                if (flush)
@@ -74,8 +80,14 @@ public abstract class Decoder
        }
 
        [CLSCompliant (false)]
+       [ComVisible (false)]
        public unsafe virtual int GetCharCount (byte* bytes, int count, bool flush)
        {
+               if (bytes == null)
+                       throw new ArgumentNullException ("bytes");
+               if (count < 0)
+                       throw new ArgumentOutOfRangeException ("count");
+
                byte [] barr = new byte [count];
                Marshal.Copy ((IntPtr) bytes, barr, 0, count);
                return GetCharCount (barr, 0, count, flush);
@@ -85,15 +97,21 @@ public abstract class Decoder
                byte[] bytes, int byteIndex, int byteCount,
                char[] chars, int charIndex, bool flush)
        {
+               CheckArguments (bytes, byteIndex, byteCount);
+               CheckArguments (chars, charIndex);
+
                if (flush)
                        Reset ();
                return GetChars (bytes, byteIndex, byteCount, chars, charIndex);
        }
 
        [CLSCompliant (false)]
+       [ComVisible (false)]
        public unsafe virtual int GetChars (byte* bytes, int byteCount,
                char* chars, int charCount, bool flush)
        {
+               CheckArguments (chars, charCount, bytes, byteCount);
+
                char [] carr = new char [charCount];
                Marshal.Copy ((IntPtr) chars, carr, 0, charCount);
                byte [] barr = new byte [byteCount];
@@ -101,11 +119,86 @@ public abstract class Decoder
                return GetChars (barr, 0, byteCount, carr, 0, flush);
        }
 
+       [ComVisible (false)]
        public virtual void Reset ()
        {
                if (fallback_buffer != null)
                        fallback_buffer.Reset ();
        }
+
+       [CLSCompliant (false)]
+       [ComVisible (false)]
+       public unsafe virtual void Convert (
+               byte* bytes, int byteCount,
+               char* chars, int charCount, bool flush,
+               out int bytesUsed, out int charsUsed, out bool completed)
+       {
+               CheckArguments (chars, charCount, bytes, byteCount);
+
+               bytesUsed = byteCount;
+               while (true) {
+                       charsUsed = GetCharCount (bytes, bytesUsed, flush);
+                       if (charsUsed <= charCount)
+                               break;
+                       flush = false;
+                       bytesUsed >>= 1;
+               }
+               completed = bytesUsed == byteCount;
+               charsUsed = GetChars (bytes, bytesUsed, chars, charCount, flush);
+       }
+
+       [ComVisible (false)]
+       public virtual void Convert (
+               byte [] bytes, int byteIndex, int byteCount,
+               char [] chars, int charIndex, int charCount, bool flush,
+               out int bytesUsed, out int charsUsed, out bool completed)
+       {
+               CheckArguments (bytes, byteIndex, byteCount);
+               CheckArguments (chars, charIndex);
+               if (charCount < 0 || chars.Length < charIndex + charCount)
+                       throw new ArgumentOutOfRangeException ("charCount");
+
+               bytesUsed = byteCount;
+               while (true) {
+                       charsUsed = GetCharCount (bytes, byteIndex, bytesUsed, flush);
+                       if (charsUsed <= charCount)
+                               break;
+                       flush = false;
+                       bytesUsed >>= 1;
+               }
+               completed = bytesUsed == byteCount;
+               charsUsed = GetChars (bytes, byteIndex, bytesUsed, chars, charIndex, flush);
+       }
+
+       void CheckArguments (char [] chars, int charIndex)
+       {
+               if (chars == null)
+                       throw new ArgumentNullException ("chars");
+               if (charIndex < 0 || chars.Length <= charIndex)
+                       throw new ArgumentOutOfRangeException ("charIndex");
+       }
+
+       void CheckArguments (byte [] bytes, int byteIndex, int byteCount)
+       {
+               if (bytes == null)
+                       throw new ArgumentNullException ("bytes");
+               if (byteIndex < 0 || bytes.Length <= byteIndex)
+                       throw new ArgumentOutOfRangeException ("byteIndex");
+               if (byteCount < 0 || bytes.Length < byteIndex + byteCount)
+                       throw new ArgumentOutOfRangeException ("byteCount");
+       }
+
+       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");
+       }
 #endif
 
 }; // class Decoder