Author: kornelpal
Date: 2006-03-20 21:59:24 -0500 (Mon, 20 Mar 2006)
New Revision: 58213
Modified:
trunk/mcs/class/corlib/System.Text/ChangeLog
trunk/mcs/class/corlib/System.Text/UnicodeEncoding.cs
trunk/mcs/class/corlib/System/ChangeLog
trunk/mcs/class/corlib/System/String.cs
Log:
* String.cs: Make memcpy4 private as it is a helper method. Make memcpy
internal to can be used from UnicodeEncoding.; * UnicodeEncoding.cs: Use unsafe
code for copying characters to speed up conversion.
Modified: trunk/mcs/class/corlib/System/ChangeLog
===================================================================
--- trunk/mcs/class/corlib/System/ChangeLog 2006-03-21 02:09:46 UTC (rev
58212)
+++ trunk/mcs/class/corlib/System/ChangeLog 2006-03-21 02:59:24 UTC (rev
58213)
@@ -1,3 +1,8 @@
+2006-03-21 Kornél Pál <[EMAIL PROTECTED]>
+
+ * String.cs: Make memcpy4 private as it is a helper method.
+ Make memcpy internal to can be used from UnicodeEncoding.
+
2006-03-19 Marek Safar <[EMAIL PROTECTED]>
* Nullable.cs (Compare, Equals): Added constrain as gmcs now correctly
Modified: trunk/mcs/class/corlib/System/String.cs
===================================================================
--- trunk/mcs/class/corlib/System/String.cs 2006-03-21 02:09:46 UTC (rev
58212)
+++ trunk/mcs/class/corlib/System/String.cs 2006-03-21 02:59:24 UTC (rev
58213)
@@ -1837,7 +1837,7 @@
}
}
- internal static unsafe void memcpy4 (byte *dest, byte *src, int
size) {
+ static unsafe void memcpy4 (byte *dest, byte *src, int size) {
/*while (size >= 32) {
// using long is better than int and slower
than double
// FIXME: enable this only on correct alignment
or on platforms
@@ -1915,7 +1915,8 @@
if (size > 0)
((byte*)dest) [0] = ((byte*)src) [0];
}
- static unsafe void memcpy (byte *dest, byte *src, int size) {
+
+ internal static unsafe void memcpy (byte *dest, byte *src, int
size) {
// FIXME: if pointers are not aligned, try to align them
// so a faster routine can be used. Handle the case
where
// the pointers can't be reduced to have the same
alignment
Modified: trunk/mcs/class/corlib/System.Text/ChangeLog
===================================================================
--- trunk/mcs/class/corlib/System.Text/ChangeLog 2006-03-21 02:09:46 UTC
(rev 58212)
+++ trunk/mcs/class/corlib/System.Text/ChangeLog 2006-03-21 02:59:24 UTC
(rev 58213)
@@ -1,3 +1,8 @@
+2006-03-21 Kornél Pál <[EMAIL PROTECTED]>
+
+ * UnicodeEncoding.cs: Use unsafe code for copying characters to speed
+ up conversion.
+
2006-03-09 Zoltan Varga <[EMAIL PROTECTED]>
* Encoding.cs: Add stub for net 2.0 GetEncodings () method.
Modified: trunk/mcs/class/corlib/System.Text/UnicodeEncoding.cs
===================================================================
--- trunk/mcs/class/corlib/System.Text/UnicodeEncoding.cs 2006-03-21
02:09:46 UTC (rev 58212)
+++ trunk/mcs/class/corlib/System.Text/UnicodeEncoding.cs 2006-03-21
02:59:24 UTC (rev 58213)
@@ -4,6 +4,7 @@
*
* Copyright (c) 2001, 2002 Southern Storm Software, Pty Ltd
* Copyright (C) 2003, 2004 Novell, Inc.
+ * Copyright (C) 2006 Korn�l P�l <http://www.kornelpal.hu/>
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the "Software"),
@@ -92,7 +93,6 @@
return count * 2;
}
- // Convenience wrappers for "GetByteCount".
public override int GetByteCount (String s)
{
if (s == null) {
@@ -101,9 +101,22 @@
return s.Length * 2;
}
+#if NET_2_0
+ [CLSCompliantAttribute (false)]
+ public unsafe override int GetByteCount (char* chars, int count)
+ {
+ if (chars == null)
+ throw new ArgumentNullException ("chars");
+ if (count < 0)
+ throw new ArgumentOutOfRangeException ("count");
+
+ return count * 2;
+ }
+#endif
+
// Get the bytes that result from encoding a character buffer.
- public override int GetBytes (char[] chars, int charIndex, int
charCount,
- byte[] bytes,
int byteIndex)
+ public unsafe override int GetBytes (char [] chars, int charIndex, int
charCount,
+
byte [] bytes, int byteIndex)
{
if (chars == null) {
throw new ArgumentNullException ("chars");
@@ -120,31 +133,40 @@
if (byteIndex < 0 || byteIndex > bytes.Length) {
throw new ArgumentOutOfRangeException ("byteIndex",
_("ArgRange_Array"));
}
- if ((bytes.Length - byteIndex) < (charCount * 2)) {
- throw new ArgumentException
(_("Arg_InsufficientSpace"));
- }
- int posn = byteIndex;
- char ch;
- if (bigEndian) {
- while (charCount-- > 0) {
- ch = chars[charIndex++];
- bytes[posn++] = (byte)(ch >> 8);
- bytes[posn++] = (byte)ch;
- }
- } else {
- while (charCount-- > 0) {
- ch = chars[charIndex++];
- bytes[posn++] = (byte)ch;
- bytes[posn++] = (byte)(ch >> 8);
- }
- }
- return posn - byteIndex;
+
+ if (charCount == 0)
+ return 0;
+
+ int byteCount = bytes.Length - byteIndex;
+ if (bytes.Length == 0)
+ bytes = new byte [1];
+
+ fixed (char* charPtr = chars)
+ fixed (byte* bytePtr = bytes)
+ return GetBytesInternal (charPtr + charIndex,
charCount, bytePtr + byteIndex, byteCount);
}
- // Convenience wrappers for "GetBytes".
- public override int GetBytes (String s, int charIndex, int charCount,
- byte[] bytes,
int byteIndex)
+#if !NET_2_0
+ public unsafe override byte [] GetBytes (String s)
{
+ if (s == null)
+ throw new ArgumentNullException ("s");
+
+ int byteCount = GetByteCount (s);
+ byte [] bytes = new byte [byteCount];
+
+ if (byteCount != 0)
+ fixed (char* charPtr = s)
+ fixed (byte* bytePtr = bytes)
+ GetBytesInternal (charPtr, s.Length,
bytePtr, byteCount);
+
+ return bytes;
+ }
+#endif
+
+ public unsafe override int GetBytes (String s, int charIndex, int
charCount,
+
byte [] bytes, int byteIndex)
+ {
if (s == null) {
throw new ArgumentNullException ("s");
}
@@ -160,25 +182,44 @@
if (byteIndex < 0 || byteIndex > bytes.Length) {
throw new ArgumentOutOfRangeException ("byteIndex",
_("ArgRange_Array"));
}
- if ((bytes.Length - byteIndex) < (charCount * 2)) {
+
+ int byteCount = bytes.Length - byteIndex;
+ if (bytes.Length == 0)
+ bytes = new byte [1];
+
+ fixed (char* charPtr = s)
+ fixed (byte* bytePtr = bytes)
+ return GetBytesInternal (charPtr + charIndex,
charCount, bytePtr + byteIndex, byteCount);
+ }
+
+#if NET_2_0
+ [CLSCompliantAttribute (false)]
+ public unsafe override int GetBytes (char* chars, int charCount,
+
byte* bytes, int byteCount)
+ {
+ if (bytes == null)
+ throw new ArgumentNullException ("bytes");
+ if (chars == null)
+ throw new ArgumentNullException ("chars");
+ if (charCount < 0)
+ throw new ArgumentOutOfRangeException ("charCount");
+ if (byteCount < 0)
+ throw new ArgumentOutOfRangeException ("byteCount");
+
+ return GetBytesInternal (chars, charCount, bytes, byteCount);
+ }
+#endif
+
+ private unsafe int GetBytesInternal (char* chars, int charCount,
+
byte* bytes, int byteCount)
+ {
+ int count = charCount * 2;
+
+ if (byteCount < count)
throw new ArgumentException
(_("Arg_InsufficientSpace"));
- }
- int posn = byteIndex;
- char ch;
- if (bigEndian) {
- while (charCount-- > 0) {
- ch = s[charIndex++];
- bytes[posn++] = (byte)(ch >> 8);
- bytes[posn++] = (byte)ch;
- }
- } else {
- while (charCount-- > 0) {
- ch = s[charIndex++];
- bytes[posn++] = (byte)ch;
- bytes[posn++] = (byte)(ch >> 8);
- }
- }
- return posn - byteIndex;
+
+ CopyChars ((byte*) chars, bytes, count, bigEndian);
+ return count;
}
// Get the number of characters needed to decode a byte buffer.
@@ -196,9 +237,22 @@
return count / 2;
}
+#if NET_2_0
+ [CLSCompliantAttribute (false)]
+ public unsafe override int GetCharCount (byte* bytes, int count)
+ {
+ if (bytes == null)
+ throw new ArgumentNullException ("bytes");
+ if (count < 0)
+ throw new ArgumentOutOfRangeException ("count");
+
+ return count / 2;
+ }
+#endif
+
// Get the characters that result from decoding a byte buffer.
- public override int GetChars (byte[] bytes, int byteIndex, int
byteCount,
- char[] chars,
int charIndex)
+ public unsafe override int GetChars (byte [] bytes, int byteIndex, int
byteCount,
+
char [] chars, int charIndex)
{
if (bytes == null) {
throw new ArgumentNullException ("bytes");
@@ -216,45 +270,61 @@
throw new ArgumentOutOfRangeException ("charIndex",
_("ArgRange_Array"));
}
+ if (byteCount == 0)
+ return 0;
+
+ int charCount = chars.Length - charIndex;
+ if (chars.Length == 0)
+ chars = new char [1];
+
+ fixed (byte* bytePtr = bytes)
+ fixed (char* charPtr = chars)
+ return GetCharsInternal (bytePtr + byteIndex,
byteCount, charPtr + charIndex, charCount);
+}
+
+#if NET_2_0
+ [CLSCompliantAttribute (false)]
+ public unsafe override int GetChars (byte* bytes, int byteCount,
+
char* chars, int charCount)
+ {
+ if (bytes == null)
+ throw new ArgumentNullException ("bytes");
+ if (chars == null)
+ throw new ArgumentNullException ("chars");
+ if (charCount < 0)
+ throw new ArgumentOutOfRangeException ("charCount");
+ if (byteCount < 0)
+ throw new ArgumentOutOfRangeException ("byteCount");
+
+ return GetCharsInternal (bytes, byteCount, chars, charCount);
+ }
+#endif
+
+ private unsafe int GetCharsInternal (byte* bytes, int byteCount,
+
char* chars, int charCount)
+ {
+ int count = byteCount / 2;
+ bool isBigEndian;
+
// Determine the byte order in the incoming buffer.
- bool isBigEndian;
- if (byteCount >= 2) {
- if (bytes[byteIndex] == (byte)0xFE && bytes[byteIndex +
1] == (byte)0xFF) {
+ if (byteCount >= 2)
+ {
+ if (bytes [0] == (byte) 0xFE && bytes [1] == (byte)
0xFF)
isBigEndian = true;
- } else if (bytes[byteIndex] == (byte)0xFF &&
bytes[byteIndex + 1] == (byte)0xFE) {
+ else if (bytes [0] == (byte) 0xFF && bytes [1] ==
(byte) 0xFE)
isBigEndian = false;
- } else {
+ else
isBigEndian = bigEndian;
- }
} else {
isBigEndian = bigEndian;
}
// Validate that we have sufficient space in "chars".
- if ((chars.Length - charIndex) < (byteCount / 2)) {
+ if (charCount < count)
throw new ArgumentException
(_("Arg_InsufficientSpace"));
- }
- // Convert the characters.
- int posn = charIndex;
- if (isBigEndian) {
- while (byteCount >= 2) {
- chars[posn++] =
- ((char)((((int)(bytes[byteIndex])) <<
8) |
- ((int)(bytes[byteIndex
+ 1]))));
- byteIndex += 2;
- byteCount -= 2;
- }
- } else {
- while (byteCount >= 2) {
- chars[posn++] =
- ((char)((((int)(bytes[byteIndex + 1]))
<< 8) |
-
((int)(bytes[byteIndex]))));
- byteIndex += 2;
- byteCount -= 2;
- }
- }
- return posn - charIndex;
+ CopyChars (bytes, (byte*) chars, byteCount, isBigEndian);
+ return count;
}
// Get the maximum number of bytes needed to encode a
@@ -321,6 +391,119 @@
return base.GetHashCode ();
}
+ private unsafe static void CopyChars (byte* src, byte* dest, int count,
bool bigEndian)
+ {
+ if (BitConverter.IsLittleEndian != bigEndian) {
+ string.memcpy (dest, src, count & unchecked ((int)
0xFFFFFFFE));
+ return;
+ }
+
+ switch (count) {
+ case 0:
+ return;
+ case 1:
+ return;
+ case 2:
+ goto Count2;
+ case 3:
+ goto Count2;
+ case 4:
+ goto Count4;
+ case 5:
+ goto Count4;
+ case 6:
+ goto Count4;
+ case 7:
+ goto Count4;
+ case 8:
+ goto Count8;
+ case 9:
+ goto Count8;
+ case 10:
+ goto Count8;
+ case 11:
+ goto Count8;
+ case 12:
+ goto Count8;
+ case 13:
+ goto Count8;
+ case 14:
+ goto Count8;
+ case 15:
+ goto Count8;
+ }
+
+ do {
+ dest [0] = src [1];
+ dest [1] = src [0];
+ dest [2] = src [3];
+ dest [3] = src [2];
+ dest [4] = src [5];
+ dest [5] = src [4];
+ dest [6] = src [7];
+ dest [7] = src [6];
+ dest [8] = src [9];
+ dest [9] = src [8];
+ dest [10] = src [11];
+ dest [11] = src [10];
+ dest [12] = src [13];
+ dest [13] = src [12];
+ dest [14] = src [15];
+ dest [15] = src [14];
+ dest += 16;
+ src += 16;
+ count -= 16;
+ } while ((count & unchecked ((int) 0xFFFFFFF0)) != 0);
+
+ switch (count) {
+ case 0:
+ return;
+ case 1:
+ return;
+ case 2:
+ goto Count2;
+ case 3:
+ goto Count2;
+ case 4:
+ goto Count4;
+ case 5:
+ goto Count4;
+ case 6:
+ goto Count4;
+ case 7:
+ goto Count4;
+ }
+
+ Count8:;
+ dest [0] = src [1];
+ dest [1] = src [0];
+ dest [2] = src [3];
+ dest [3] = src [2];
+ dest [4] = src [5];
+ dest [5] = src [4];
+ dest [6] = src [7];
+ dest [7] = src [6];
+ dest += 8;
+ src += 8;
+
+ if ((count & 4) == 0)
+ goto TestCount2;
+ Count4:;
+ dest [0] = src [1];
+ dest [1] = src [0];
+ dest [2] = src [3];
+ dest [3] = src [2];
+ dest += 4;
+ src += 4;
+
+ TestCount2:;
+ if ((count & 2) == 0)
+ return;
+ Count2:;
+ dest [0] = src [1];
+ dest [1] = src [0];
+ }
+
// Unicode decoder implementation.
private sealed class UnicodeDecoder : Decoder
{
@@ -353,9 +536,9 @@
}
}
- public override int GetChars (byte[] bytes, int byteIndex,
- int
byteCount, char[] chars,
- int
charIndex)
+ public unsafe override int GetChars (byte [] bytes, int
byteIndex,
+
int byteCount, char [] chars,
+
int charIndex)
{
if (bytes == null) {
throw new ArgumentNullException ("bytes");
@@ -373,66 +556,45 @@
throw new ArgumentOutOfRangeException
("charIndex", _("ArgRange_Array"));
}
- // Convert the characters.
- int posn = charIndex;
+ if (byteCount == 0)
+ return 0;
+
bool isBigEndian = bigEndian;
int leftOver = leftOverByte;
- int length = chars.Length;
- char ch;
- while (byteCount > 0) {
- if (leftOver != -1) {
- if (isBigEndian) {
- ch = ((char)((leftOver << 8) |
((int)(bytes[byteIndex]))));
- } else {
- ch = ((char)(leftOver |
-
(((int)(bytes[byteIndex])) << 8)));
- }
- leftOver = -1;
- ++byteIndex;
- --byteCount;
- } else if (byteCount > 1) {
- if (isBigEndian) {
- ch =
((char)((((int)(bytes[byteIndex])) << 8) |
-
((int)(bytes[byteIndex + 1]))));
- } else {
- ch =
((char)((((int)(bytes[byteIndex + 1])) << 8) |
-
((int)(bytes[byteIndex]))));
- }
- byteIndex += 2;
- byteCount -= 2;
- } else {
- leftOver = (int)(bytes[byteIndex]);
- break;
- }
+ int count;
- if (posn < length) {
- chars[posn++] = ch;
- } else {
- throw new ArgumentException
(_("Arg_InsufficientSpace"));
- }
+ if (leftOver != -1)
+ count = (byteCount + 1) / 2;
+ else
+ count = byteCount / 2;
+
+ if (chars.Length - charIndex < count)
+ throw new ArgumentException
(_("Arg_InsufficientSpace"));
+
+ if (leftOver != -1) {
+ if (isBigEndian)
+ chars [charIndex] = unchecked ((char)
((leftOver << 8) | (int) bytes [byteIndex]));
+ else
+ chars [charIndex] = unchecked ((char)
(((int) bytes [byteIndex] << 8) | leftOver));
+ charIndex++;
+ byteIndex++;
+ byteCount--;
}
- leftOverByte = leftOver;
- bigEndian = isBigEndian;
- // Finished - return the converted length.
- return posn - charIndex;
+ if ((byteCount & unchecked ((int) 0xFFFFFFFE)) != 0)
+ fixed (byte* bytePtr = bytes)
+ fixed (char* charPtr = chars)
+ CopyChars (bytePtr + byteIndex,
(byte*) (charPtr + charIndex), byteCount, isBigEndian);
+
+ if ((byteCount & 1) == 0)
+ leftOverByte = -1;
+ else
+ leftOverByte = bytes [byteCount + byteIndex -
1];
+
+ return count;
}
} // class UnicodeDecoder
-
-#if NET_2_0
- [CLSCompliantAttribute(false)]
- public unsafe override int GetByteCount (char *chars, int count)
- {
- return count * 2;
- }
-#else
- public override byte [] GetBytes (String s)
- {
- return base.GetBytes (s);
- }
-#endif
-
}; // class UnicodeEncoding
_______________________________________________
Mono-patches maillist - [email protected]
http://lists.ximian.com/mailman/listinfo/mono-patches