mscorlib(4.0.0.0) API with additions
Buffer.cs
1 using System.Runtime.CompilerServices;
2 using System.Runtime.ConstrainedExecution;
3 using System.Runtime.InteropServices;
4 using System.Security;
5 
6 namespace System
7 {
9  [ComVisible(true)]
10  [__DynamicallyInvokable]
11  public static class Buffer
12  {
25  [MethodImpl(MethodImplOptions.InternalCall)]
26  [SecuritySafeCritical]
27  [__DynamicallyInvokable]
28  public static extern void BlockCopy(Array src, int srcOffset, Array dst, int dstOffset, int count);
29 
30  [MethodImpl(MethodImplOptions.InternalCall)]
31  [SecuritySafeCritical]
32  internal static extern void InternalBlockCopy(Array src, int srcOffsetBytes, Array dst, int dstOffsetBytes, int byteCount);
33 
34  [SecurityCritical]
35  internal unsafe static int IndexOfByte(byte* src, byte value, int index, int count)
36  {
37  byte* ptr;
38  for (ptr = src + index; ((int)ptr & 3) != 0; ptr++)
39  {
40  if (count == 0)
41  {
42  return -1;
43  }
44  if (*ptr == value)
45  {
46  return (int)(ptr - src);
47  }
48  count--;
49  }
50  uint num = (uint)((value << 8) + value);
51  num = (num << 16) + num;
52  while (count > 3)
53  {
54  uint num2 = *(uint*)ptr;
55  num2 ^= num;
56  uint num3 = 2130640639 + num2;
57  num2 = (uint)((int)num2 ^ -1);
58  num2 ^= num3;
59  if (((int)num2 & -2130640640) != 0)
60  {
61  int num4 = (int)(ptr - src);
62  if (*ptr == value)
63  {
64  return num4;
65  }
66  if (ptr[1] == value)
67  {
68  return num4 + 1;
69  }
70  if (ptr[2] == value)
71  {
72  return num4 + 2;
73  }
74  if (ptr[3] == value)
75  {
76  return num4 + 3;
77  }
78  }
79  count -= 4;
80  ptr += 4;
81  }
82  while (count > 0)
83  {
84  if (*ptr == value)
85  {
86  return (int)(ptr - src);
87  }
88  count--;
89  ptr++;
90  }
91  return -1;
92  }
93 
94  [MethodImpl(MethodImplOptions.InternalCall)]
95  [SecurityCritical]
96  private static extern bool IsPrimitiveTypeArray(Array array);
97 
98  [MethodImpl(MethodImplOptions.InternalCall)]
99  [SecurityCritical]
100  private static extern byte _GetByte(Array array, int index);
101 
114  [SecuritySafeCritical]
115  [__DynamicallyInvokable]
116  public static byte GetByte(Array array, int index)
117  {
118  if (array == null)
119  {
120  throw new ArgumentNullException("array");
121  }
122  if (!IsPrimitiveTypeArray(array))
123  {
124  throw new ArgumentException(Environment.GetResourceString("Arg_MustBePrimArray"), "array");
125  }
126  if (index < 0 || index >= _ByteLength(array))
127  {
128  throw new ArgumentOutOfRangeException("index");
129  }
130  return _GetByte(array, index);
131  }
132 
133  [MethodImpl(MethodImplOptions.InternalCall)]
134  [SecurityCritical]
135  private static extern void _SetByte(Array array, int index, byte value);
136 
149  [SecuritySafeCritical]
150  [__DynamicallyInvokable]
151  public static void SetByte(Array array, int index, byte value)
152  {
153  if (array == null)
154  {
155  throw new ArgumentNullException("array");
156  }
157  if (!IsPrimitiveTypeArray(array))
158  {
159  throw new ArgumentException(Environment.GetResourceString("Arg_MustBePrimArray"), "array");
160  }
161  if (index < 0 || index >= _ByteLength(array))
162  {
163  throw new ArgumentOutOfRangeException("index");
164  }
165  _SetByte(array, index, value);
166  }
167 
168  [MethodImpl(MethodImplOptions.InternalCall)]
169  [SecurityCritical]
170  private static extern int _ByteLength(Array array);
171 
181  [SecuritySafeCritical]
182  [__DynamicallyInvokable]
183  public static int ByteLength(Array array)
184  {
185  if (array == null)
186  {
187  throw new ArgumentNullException("array");
188  }
189  if (!IsPrimitiveTypeArray(array))
190  {
191  throw new ArgumentException(Environment.GetResourceString("Arg_MustBePrimArray"), "array");
192  }
193  return _ByteLength(array);
194  }
195 
196  [SecurityCritical]
197  internal unsafe static void ZeroMemory(byte* src, long len)
198  {
199  while (true)
200  {
201  long num = len;
202  len = num - 1;
203  if (num > 0)
204  {
205  src[len] = 0;
206  continue;
207  }
208  break;
209  }
210  }
211 
212  [SecurityCritical]
213  [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
214  internal unsafe static void Memcpy(byte[] dest, int destIndex, byte* src, int srcIndex, int len)
215  {
216  if (len != 0)
217  {
218  fixed (byte* ptr = dest)
219  {
220  Memcpy(ptr + destIndex, src + srcIndex, len);
221  }
222  }
223  }
224 
225  [SecurityCritical]
226  [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
227  internal unsafe static void Memcpy(byte* pDest, int destIndex, byte[] src, int srcIndex, int len)
228  {
229  if (len != 0)
230  {
231  fixed (byte* ptr = src)
232  {
233  Memcpy(pDest + destIndex, ptr + srcIndex, len);
234  }
235  }
236  }
237 
238  [MethodImpl(MethodImplOptions.AggressiveInlining)]
239  [FriendAccessAllowed]
240  [SecurityCritical]
241  [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
242  internal unsafe static void Memcpy(byte* dest, byte* src, int len)
243  {
244  Memmove(dest, src, (uint)len);
245  }
246 
247  [SecurityCritical]
248  [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
249  internal unsafe static void Memmove(byte* dest, byte* src, ulong len)
250  {
251  if ((ulong)((long)dest - (long)src) >= len)
252  {
253  ulong num = len;
254  if (num <= 16)
255  {
256  switch (num)
257  {
258  case 0uL:
259  return;
260  case 1uL:
261  *dest = *src;
262  return;
263  case 2uL:
264  *(short*)dest = *(short*)src;
265  return;
266  case 3uL:
267  *(short*)dest = *(short*)src;
268  dest[2] = src[2];
269  return;
270  case 4uL:
271  *(int*)dest = *(int*)src;
272  return;
273  case 5uL:
274  *(int*)dest = *(int*)src;
275  dest[4] = src[4];
276  return;
277  case 6uL:
278  *(int*)dest = *(int*)src;
279  *(short*)(dest + 4) = *(short*)(src + 4);
280  return;
281  case 7uL:
282  *(int*)dest = *(int*)src;
283  *(short*)(dest + 4) = *(short*)(src + 4);
284  dest[6] = src[6];
285  return;
286  case 8uL:
287  *(long*)dest = *(long*)src;
288  return;
289  case 9uL:
290  *(long*)dest = *(long*)src;
291  dest[8] = src[8];
292  return;
293  case 10uL:
294  *(long*)dest = *(long*)src;
295  *(short*)(dest + 8) = *(short*)(src + 8);
296  return;
297  case 11uL:
298  *(long*)dest = *(long*)src;
299  *(short*)(dest + 8) = *(short*)(src + 8);
300  dest[10] = src[10];
301  return;
302  case 12uL:
303  *(long*)dest = *(long*)src;
304  *(int*)(dest + 8) = *(int*)(src + 8);
305  return;
306  case 13uL:
307  *(long*)dest = *(long*)src;
308  *(int*)(dest + 8) = *(int*)(src + 8);
309  dest[12] = src[12];
310  return;
311  case 14uL:
312  *(long*)dest = *(long*)src;
313  *(int*)(dest + 8) = *(int*)(src + 8);
314  *(short*)(dest + 12) = *(short*)(src + 12);
315  return;
316  case 15uL:
317  *(long*)dest = *(long*)src;
318  *(int*)(dest + 8) = *(int*)(src + 8);
319  *(short*)(dest + 12) = *(short*)(src + 12);
320  dest[14] = src[14];
321  return;
322  case 16uL:
323  *(long*)dest = *(long*)src;
324  *(long*)(dest + 8) = *(long*)(src + 8);
325  return;
326  }
327  }
328  if (len < 512)
329  {
330  if (((int)dest & 3) != 0)
331  {
332  if (((int)dest & 1) != 0)
333  {
334  *dest = *src;
335  src++;
336  dest++;
337  len--;
338  if (((int)dest & 2) == 0)
339  {
340  goto IL_0198;
341  }
342  }
343  *(short*)dest = *(short*)src;
344  src += 2;
345  dest += 2;
346  len -= 2;
347  }
348  goto IL_0198;
349  }
350  }
351  _Memmove(dest, src, len);
352  return;
353  IL_0198:
354  if (((int)dest & 4) != 0)
355  {
356  *(int*)dest = *(int*)src;
357  src += 4;
358  dest += 4;
359  len -= 4;
360  }
361  for (ulong num2 = len / 16uL; num2 != 0; num2--)
362  {
363  *(long*)dest = *(long*)src;
364  *(long*)(dest + 8) = *(long*)(src + 8);
365  dest += 16;
366  src += 16;
367  }
368  if ((len & 8) != 0L)
369  {
370  *(long*)dest = *(long*)src;
371  dest += 8;
372  src += 8;
373  }
374  if ((len & 4) != 0L)
375  {
376  *(int*)dest = *(int*)src;
377  dest += 4;
378  src += 4;
379  }
380  if ((len & 2) != 0L)
381  {
382  *(short*)dest = *(short*)src;
383  dest += 2;
384  src += 2;
385  }
386  if ((len & 1) != 0L)
387  {
388  *dest = *src;
389  }
390  }
391 
392  [MethodImpl(MethodImplOptions.NoInlining)]
393  [SecurityCritical]
394  [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
395  private unsafe static void _Memmove(byte* dest, byte* src, ulong len)
396  {
397  __Memmove(dest, src, len);
398  }
399 
400  [DllImport("QCall", CharSet = CharSet.Unicode)]
401  [SuppressUnmanagedCodeSecurity]
402  [SecurityCritical]
403  [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
404  private unsafe static extern void __Memmove(byte* dest, byte* src, ulong len);
405 
413  [MethodImpl(MethodImplOptions.AggressiveInlining)]
414  [SecurityCritical]
415  [CLSCompliant(false)]
416  public unsafe static void MemoryCopy(void* source, void* destination, long destinationSizeInBytes, long sourceBytesToCopy)
417  {
418  if (sourceBytesToCopy > destinationSizeInBytes)
419  {
420  ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.sourceBytesToCopy);
421  }
422  Memmove((byte*)destination, (byte*)source, checked((ulong)sourceBytesToCopy));
423  }
424 
432  [MethodImpl(MethodImplOptions.AggressiveInlining)]
433  [SecurityCritical]
434  [CLSCompliant(false)]
435  public unsafe static void MemoryCopy(void* source, void* destination, ulong destinationSizeInBytes, ulong sourceBytesToCopy)
436  {
437  if (sourceBytesToCopy > destinationSizeInBytes)
438  {
439  ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.sourceBytesToCopy);
440  }
441  Memmove((byte*)destination, (byte*)source, sourceBytesToCopy);
442  }
443  }
444 }
System.Buffer.MemoryCopy
static unsafe void MemoryCopy(void *source, void *destination, ulong destinationSizeInBytes, ulong sourceBytesToCopy)
Copies a number of bytes specified as an unsigned long integer value from one address in memory to an...
Definition: Buffer.cs:435
System.ArgumentNullException
The exception that is thrown when a null reference (Nothing in Visual Basic) is passed to a method th...
Definition: ArgumentNullException.cs:11
System
Definition: __Canon.cs:3
System.ArgumentOutOfRangeException
The exception that is thrown when the value of an argument is outside the allowable range of values a...
Definition: ArgumentOutOfRangeException.cs:11
System.Buffer.SetByte
static void SetByte(Array array, int index, byte value)
Assigns a specified value to a byte at a particular location in a specified array.
Definition: Buffer.cs:151
System.Runtime.ConstrainedExecution.Cer
Cer
Specifies a method's behavior when called within a constrained execution region.
Definition: Cer.cs:5
System.Environment
Provides information about, and means to manipulate, the current environment and platform....
Definition: Environment.cs:21
System.Buffer.BlockCopy
static void BlockCopy(Array src, int srcOffset, Array dst, int dstOffset, int count)
Copies a specified number of bytes from a source array starting at a particular offset to a destinati...
System.Array
Provides methods for creating, manipulating, searching, and sorting arrays, thereby serving as the ba...
Definition: Array.cs:17
System.Runtime.CompilerServices.MethodImplOptions
MethodImplOptions
Defines the details of how a method is implemented.
Definition: MethodImplOptions.cs:10
System.Runtime.InteropServices.CharSet
CharSet
Dictates which character set marshaled strings should use.
Definition: CharSet.cs:7
System.Buffer.ByteLength
static int ByteLength(Array array)
Returns the number of bytes in the specified array.
Definition: Buffer.cs:183
System.Buffer.GetByte
static byte GetByte(Array array, int index)
Retrieves the byte at a specified location in a specified array.
Definition: Buffer.cs:116
System.ArgumentException
The exception that is thrown when one of the arguments provided to a method is not valid.
Definition: ArgumentException.cs:11
System.Buffer
Manipulates arrays of primitive types.
Definition: Buffer.cs:11
System.Runtime.ConstrainedExecution.Consistency
Consistency
Specifies a reliability contract.
Definition: Consistency.cs:5
System.Buffer.MemoryCopy
static unsafe void MemoryCopy(void *source, void *destination, long destinationSizeInBytes, long sourceBytesToCopy)
Copies a number of bytes specified as a long integer value from one address in memory to another....
Definition: Buffer.cs:416