--- /dev/null
+namespace System
+{
+ partial class Buffer
+ {
+ public static int ByteLength (Array array)
+ {
+ // note: the other methods in this class also use ByteLength to test for
+ // null and non-primitive arguments as a side-effect.
+
+ if (array == null)
+ throw new ArgumentNullException ("array");
+
+ int length = _ByteLength (array);
+ if (length < 0)
+ throw new ArgumentException (Locale.GetText ("Object must be an array of primitives."));
+
+ return length;
+ }
+
+ public static byte GetByte (Array array, int index)
+ {
+ if (index < 0 || index >= ByteLength (array))
+ throw new ArgumentOutOfRangeException ("index");
+
+ return _GetByte (array, index);
+ }
+
+ public static void SetByte (Array array, int index, byte value)
+ {
+ if (index < 0 || index >= ByteLength (array))
+ throw new ArgumentOutOfRangeException ("index");
+
+ _SetByte (array, index, value);
+ }
+
+ public static void BlockCopy (Array src, int srcOffset, Array dst, int dstOffset, int count)
+ {
+ if (src == null)
+ throw new ArgumentNullException ("src");
+
+ if (dst == null)
+ throw new ArgumentNullException ("dst");
+
+ if (srcOffset < 0)
+ throw new ArgumentOutOfRangeException ("srcOffset", Locale.GetText(
+ "Non-negative number required."));
+
+ if (dstOffset < 0)
+ throw new ArgumentOutOfRangeException ("dstOffset", Locale.GetText (
+ "Non-negative number required."));
+
+ if (count < 0)
+ throw new ArgumentOutOfRangeException ("count", Locale.GetText (
+ "Non-negative number required."));
+
+ // We do the checks in unmanaged code for performance reasons
+ bool res = InternalBlockCopy (src, srcOffset, dst, dstOffset, count);
+ if (!res) {
+ // watch for integer overflow
+ if ((srcOffset > ByteLength (src) - count) || (dstOffset > ByteLength (dst) - count))
+ throw new ArgumentException (Locale.GetText (
+ "Offset and length were out of bounds for the array or count is greater than " +
+ "the number of elements from index to the end of the source collection."));
+ }
+ }
+
+ internal 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
+ // that can tolerate unaligned reads/writes of doubles
+ ((double*)dest) [0] = ((double*)src) [0];
+ ((double*)dest) [1] = ((double*)src) [1];
+ ((double*)dest) [2] = ((double*)src) [2];
+ ((double*)dest) [3] = ((double*)src) [3];
+ dest += 32;
+ src += 32;
+ size -= 32;
+ }*/
+ while (size >= 16) {
+ ((int*)dest) [0] = ((int*)src) [0];
+ ((int*)dest) [1] = ((int*)src) [1];
+ ((int*)dest) [2] = ((int*)src) [2];
+ ((int*)dest) [3] = ((int*)src) [3];
+ dest += 16;
+ src += 16;
+ size -= 16;
+ }
+ while (size >= 4) {
+ ((int*)dest) [0] = ((int*)src) [0];
+ dest += 4;
+ src += 4;
+ size -= 4;
+ }
+ while (size > 0) {
+ ((byte*)dest) [0] = ((byte*)src) [0];
+ dest += 1;
+ src += 1;
+ --size;
+ }
+ }
+ internal static unsafe void memcpy2 (byte *dest, byte *src, int size) {
+ while (size >= 8) {
+ ((short*)dest) [0] = ((short*)src) [0];
+ ((short*)dest) [1] = ((short*)src) [1];
+ ((short*)dest) [2] = ((short*)src) [2];
+ ((short*)dest) [3] = ((short*)src) [3];
+ dest += 8;
+ src += 8;
+ size -= 8;
+ }
+ while (size >= 2) {
+ ((short*)dest) [0] = ((short*)src) [0];
+ dest += 2;
+ src += 2;
+ size -= 2;
+ }
+ if (size > 0)
+ ((byte*)dest) [0] = ((byte*)src) [0];
+ }
+ static unsafe void memcpy1 (byte *dest, byte *src, int size) {
+ while (size >= 8) {
+ ((byte*)dest) [0] = ((byte*)src) [0];
+ ((byte*)dest) [1] = ((byte*)src) [1];
+ ((byte*)dest) [2] = ((byte*)src) [2];
+ ((byte*)dest) [3] = ((byte*)src) [3];
+ ((byte*)dest) [4] = ((byte*)src) [4];
+ ((byte*)dest) [5] = ((byte*)src) [5];
+ ((byte*)dest) [6] = ((byte*)src) [6];
+ ((byte*)dest) [7] = ((byte*)src) [7];
+ dest += 8;
+ src += 8;
+ size -= 8;
+ }
+ while (size >= 2) {
+ ((byte*)dest) [0] = ((byte*)src) [0];
+ ((byte*)dest) [1] = ((byte*)src) [1];
+ dest += 2;
+ src += 2;
+ size -= 2;
+ }
+ if (size > 0)
+ ((byte*)dest) [0] = ((byte*)src) [0];
+ }
+
+ 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
+ // (just ignore the issue on x86?)
+ if ((((int)dest | (int)src) & 3) != 0) {
+ if (((int)dest & 1) != 0 && ((int)src & 1) != 0 && size >= 1) {
+ dest [0] = src [0];
+ ++dest;
+ ++src;
+ --size;
+ }
+ if (((int)dest & 2) != 0 && ((int)src & 2) != 0 && size >= 2) {
+ ((short*)dest) [0] = ((short*)src) [0];
+ dest += 2;
+ src += 2;
+ size -= 2;
+ }
+ if ((((int)dest | (int)src) & 1) != 0) {
+ memcpy1 (dest, src, size);
+ return;
+ }
+ if ((((int)dest | (int)src) & 2) != 0) {
+ memcpy2 (dest, src, size);
+ return;
+ }
+ }
+ memcpy4 (dest, src, size);
+ }
+ }
+}
\ No newline at end of file
+++ /dev/null
-//
-// System.Buffer.cs
-//
-// Authors:
-// Paolo Molaro (lupus@ximian.com)
-// Dan Lewis (dihlewis@yahoo.co.uk)
-//
-// (C) 2001 Ximian, Inc. http://www.ximian.com
-//
-
-//
-// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
-//
-// Permission is hereby granted, free of charge, to any person obtaining
-// a copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to
-// permit persons to whom the Software is furnished to do so, subject to
-// the following conditions:
-//
-// The above copyright notice and this permission notice shall be
-// included in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Diagnostics.Contracts;
-
-namespace System {
- [ComVisible (true)]
- public static class Buffer {
-
- public static int ByteLength (Array array)
- {
- // note: the other methods in this class also use ByteLength to test for
- // null and non-primitive arguments as a side-effect.
-
- if (array == null)
- throw new ArgumentNullException ("array");
-
- int length = ByteLengthInternal (array);
- if (length < 0)
- throw new ArgumentException (Locale.GetText ("Object must be an array of primitives."));
-
- return length;
- }
-
- public static byte GetByte (Array array, int index)
- {
- if (index < 0 || index >= ByteLength (array))
- throw new ArgumentOutOfRangeException ("index", Locale.GetText(
- "Value must be non-negative and less than the size of the collection."));
-
- return GetByteInternal (array, index);
- }
-
- public static void SetByte (Array array, int index, byte value)
- {
- if (index < 0 || index >= ByteLength (array))
- throw new ArgumentOutOfRangeException ("index", Locale.GetText(
- "Value must be non-negative and less than the size of the collection."));
-
- SetByteInternal (array, index, value);
- }
-
- public static void BlockCopy (Array src, int srcOffset, Array dst, int dstOffset, int count)
- {
- if (src == null)
- throw new ArgumentNullException ("src");
-
- if (dst == null)
- throw new ArgumentNullException ("dst");
-
- if (srcOffset < 0)
- throw new ArgumentOutOfRangeException ("srcOffset", Locale.GetText(
- "Non-negative number required."));
-
- if (dstOffset < 0)
- throw new ArgumentOutOfRangeException ("dstOffset", Locale.GetText (
- "Non-negative number required."));
-
- if (count < 0)
- throw new ArgumentOutOfRangeException ("count", Locale.GetText (
- "Non-negative number required."));
-
- // We do the checks in unmanaged code for performance reasons
- bool res = BlockCopyInternal (src, srcOffset, dst, dstOffset, count);
- if (!res) {
- // watch for integer overflow
- if ((srcOffset > ByteLength (src) - count) || (dstOffset > ByteLength (dst) - count))
- throw new ArgumentException (Locale.GetText (
- "Offset and length were out of bounds for the array or count is greater than " +
- "the number of elements from index to the end of the source collection."));
- }
- }
-
- // private
- [MethodImplAttribute (MethodImplOptions.InternalCall)]
- private extern static int ByteLengthInternal (Array array);
-
- [MethodImplAttribute (MethodImplOptions.InternalCall)]
- private extern static byte GetByteInternal (Array array, int index);
-
- [MethodImplAttribute (MethodImplOptions.InternalCall)]
- private extern static void SetByteInternal (Array array, int index, int value);
-
- [MethodImplAttribute (MethodImplOptions.InternalCall)]
- internal extern static bool BlockCopyInternal (Array src, int src_offset, Array dest, int dest_offset, int count);
-
- internal static bool InternalBlockCopy (Array src, int src_offset, Array dest, int dest_offset, int count)
- {
- return BlockCopyInternal (src, src_offset, dest, dest_offset, count);
- }
-
- internal unsafe static void ZeroMemory (byte* src, long len)
- {
- while(len-- > 0)
- *(src + len) = 0;
- }
-
- internal unsafe static void Memcpy (byte* pDest, int destIndex, byte[] src, int srcIndex, int len)
- {
- Contract.Assert( (srcIndex >= 0) && (destIndex >= 0) && (len >= 0), "Index and length must be non-negative!");
- Contract.Assert(src.Length - srcIndex >= len, "not enough bytes in src");
- // If dest has 0 elements, the fixed statement will throw an
- // IndexOutOfRangeException. Special-case 0-byte copies.
- if (len==0)
- return;
- fixed(byte* pSrc = src) {
- Memcpy(pDest + destIndex, pSrc + srcIndex, len);
- }
- }
-
- internal unsafe static void Memcpy(byte[] dest, int destIndex, byte* src, int srcIndex, int len) {
- Contract.Assert( (srcIndex >= 0) && (destIndex >= 0) && (len >= 0), "Index and length must be non-negative!");
- Contract.Assert(dest.Length - destIndex >= len, "not enough bytes in dest");
- // If dest has 0 elements, the fixed statement will throw an
- // IndexOutOfRangeException. Special-case 0-byte copies.
- if (len==0)
- return;
- fixed(byte* pDest = dest) {
- Memcpy(pDest + destIndex, src + srcIndex, len);
- }
- }
-
- internal 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
- // that can tolerate unaligned reads/writes of doubles
- ((double*)dest) [0] = ((double*)src) [0];
- ((double*)dest) [1] = ((double*)src) [1];
- ((double*)dest) [2] = ((double*)src) [2];
- ((double*)dest) [3] = ((double*)src) [3];
- dest += 32;
- src += 32;
- size -= 32;
- }*/
- while (size >= 16) {
- ((int*)dest) [0] = ((int*)src) [0];
- ((int*)dest) [1] = ((int*)src) [1];
- ((int*)dest) [2] = ((int*)src) [2];
- ((int*)dest) [3] = ((int*)src) [3];
- dest += 16;
- src += 16;
- size -= 16;
- }
- while (size >= 4) {
- ((int*)dest) [0] = ((int*)src) [0];
- dest += 4;
- src += 4;
- size -= 4;
- }
- while (size > 0) {
- ((byte*)dest) [0] = ((byte*)src) [0];
- dest += 1;
- src += 1;
- --size;
- }
- }
- internal static unsafe void memcpy2 (byte *dest, byte *src, int size) {
- while (size >= 8) {
- ((short*)dest) [0] = ((short*)src) [0];
- ((short*)dest) [1] = ((short*)src) [1];
- ((short*)dest) [2] = ((short*)src) [2];
- ((short*)dest) [3] = ((short*)src) [3];
- dest += 8;
- src += 8;
- size -= 8;
- }
- while (size >= 2) {
- ((short*)dest) [0] = ((short*)src) [0];
- dest += 2;
- src += 2;
- size -= 2;
- }
- if (size > 0)
- ((byte*)dest) [0] = ((byte*)src) [0];
- }
- static unsafe void memcpy1 (byte *dest, byte *src, int size) {
- while (size >= 8) {
- ((byte*)dest) [0] = ((byte*)src) [0];
- ((byte*)dest) [1] = ((byte*)src) [1];
- ((byte*)dest) [2] = ((byte*)src) [2];
- ((byte*)dest) [3] = ((byte*)src) [3];
- ((byte*)dest) [4] = ((byte*)src) [4];
- ((byte*)dest) [5] = ((byte*)src) [5];
- ((byte*)dest) [6] = ((byte*)src) [6];
- ((byte*)dest) [7] = ((byte*)src) [7];
- dest += 8;
- src += 8;
- size -= 8;
- }
- while (size >= 2) {
- ((byte*)dest) [0] = ((byte*)src) [0];
- ((byte*)dest) [1] = ((byte*)src) [1];
- dest += 2;
- src += 2;
- size -= 2;
- }
- if (size > 0)
- ((byte*)dest) [0] = ((byte*)src) [0];
- }
-
- 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
- // (just ignore the issue on x86?)
- if ((((int)dest | (int)src) & 3) != 0) {
- if (((int)dest & 1) != 0 && ((int)src & 1) != 0 && size >= 1) {
- dest [0] = src [0];
- ++dest;
- ++src;
- --size;
- }
- if (((int)dest & 2) != 0 && ((int)src & 2) != 0 && size >= 2) {
- ((short*)dest) [0] = ((short*)src) [0];
- dest += 2;
- src += 2;
- size -= 2;
- }
- if ((((int)dest | (int)src) & 1) != 0) {
- memcpy1 (dest, src, size);
- return;
- }
- if ((((int)dest | (int)src) & 2) != 0) {
- memcpy2 (dest, src, size);
- return;
- }
- }
- memcpy4 (dest, src, size);
- }
-
- internal unsafe static int IndexOfByte(byte* src, byte value, int index, int count)
- {
- Contract.Assert(src != null, "src should not be null");
-
- byte* pByte = src + index;
-
- // Align up the pointer to sizeof(int).
- while (((int)pByte & 3) != 0)
- {
- if (count == 0)
- return -1;
- else if (*pByte == value)
- return (int) (pByte - src);
-
- count--;
- pByte++;
- }
-
- // Fill comparer with value byte for comparisons
- //
- // comparer = 0/0/value/value
- uint comparer = (((uint)value << 8) + (uint)value);
- // comparer = value/value/value/value
- comparer = (comparer << 16) + comparer;
-
- // Run through buffer until we hit a 4-byte section which contains
- // the byte we're looking for or until we exhaust the buffer.
- while (count > 3)
- {
- // Test the buffer for presence of value. comparer contains the byte
- // replicated 4 times.
- uint t1 = *(uint*)pByte;
- t1 = t1 ^ comparer;
- uint t2 = 0x7efefeff + t1;
- t1 = t1 ^ 0xffffffff;
- t1 = t1 ^ t2;
- t1 = t1 & 0x81010100;
-
- // if t1 is zero then these 4-bytes don't contain a match
- if (t1 != 0)
- {
- // We've found a match for value, figure out which position it's in.
- int foundIndex = (int) (pByte - src);
- if (pByte[0] == value)
- return foundIndex;
- else if (pByte[1] == value)
- return foundIndex + 1;
- else if (pByte[2] == value)
- return foundIndex + 2;
- else if (pByte[3] == value)
- return foundIndex + 3;
- }
-
- count -= 4;
- pByte += 4;
-
- }
-
- // Catch any bytes that might be left at the tail of the buffer
- while (count > 0)
- {
- if (*pByte == value)
- return (int) (pByte - src);
-
- count--;
- pByte++;
- }
-
- // If we don't have a match return -1;
- return -1;
- }
- }
-}
projects / mono.git / commitdiff