using System;
using System.Runtime.ConstrainedExecution;
using System.Security;
using Cpp2IlInjected;
namespace System.Runtime.InteropServices
{
/// Provides a collection of methods for allocating unmanaged memory, copying unmanaged memory blocks, and converting managed to unmanaged types, as well as other miscellaneous methods used when interacting with unmanaged code.
// Token: 0x020005A7 RID: 1447
[Token(Token = "0x20005A7")]
public static class Marshal
{
// Token: 0x06002CFF RID: 11519 RVA: 0x00018FC0 File Offset: 0x000171C0
[Token(Token = "0x6002CFF")]
[Address(RVA = "0x2CF0FD0", Offset = "0x2CEFFD0", VA = "0x182CF0FD0")]
private static int AddRefInternal(IntPtr pUnk)
{
return 0;
}
/// Increments the reference count on the specified interface.
/// The interface reference count to increment.
/// The new value of the reference count on the parameter.
// Token: 0x06002D00 RID: 11520 RVA: 0x00018FD8 File Offset: 0x000171D8
[Token(Token = "0x6002D00")]
[Address(RVA = "0x2CF0FE0", Offset = "0x2CEFFE0", VA = "0x182CF0FE0")]
public static int AddRef(IntPtr pUnk)
{
return 0;
}
/// Allocates a block of memory of specified size from the COM task memory allocator.
/// The size of the block of memory to be allocated.
/// An integer representing the address of the block of memory allocated. This memory must be released with .
/// There is insufficient memory to satisfy the request.
// Token: 0x06002D01 RID: 11521 RVA: 0x00018FF0 File Offset: 0x000171F0
[Token(Token = "0x6002D01")]
[Address(RVA = "0x2CF1080", Offset = "0x2CF0080", VA = "0x182CF1080")]
public static IntPtr AllocCoTaskMem(int cb)
{
return 0;
}
/// Allocates memory from the unmanaged memory of the process by using the pointer to the specified number of bytes.
/// The required number of bytes in memory.
/// A pointer to the newly allocated memory. This memory must be released using the method.
/// There is insufficient memory to satisfy the request.
// Token: 0x06002D02 RID: 11522 RVA: 0x00019008 File Offset: 0x00017208
[Token(Token = "0x6002D02")]
[Address(RVA = "0x2CF1090", Offset = "0x2CF0090", VA = "0x182CF1090")]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
public static IntPtr AllocHGlobal(IntPtr cb)
{
return 0;
}
/// Allocates memory from the unmanaged memory of the process by using the specified number of bytes.
/// The required number of bytes in memory.
/// A pointer to the newly allocated memory. This memory must be released using the method.
/// There is insufficient memory to satisfy the request.
// Token: 0x06002D03 RID: 11523 RVA: 0x00019020 File Offset: 0x00017220
[Token(Token = "0x6002D03")]
[Address(RVA = "0x2CF10A0", Offset = "0x2CF00A0", VA = "0x182CF10A0")]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
public static IntPtr AllocHGlobal(int cb)
{
return 0;
}
// Token: 0x06002D04 RID: 11524 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x6002D04")]
[Address(RVA = "0x2CF3880", Offset = "0x2CF2880", VA = "0x182CF3880")]
internal static void copy_to_unmanaged(Array source, int startIndex, IntPtr destination, int length)
{
}
// Token: 0x06002D05 RID: 11525 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x6002D05")]
[Address(RVA = "0x2CF3870", Offset = "0x2CF2870", VA = "0x182CF3870")]
internal static void copy_from_unmanaged(IntPtr source, int startIndex, Array destination, int length)
{
}
/// Copies data from a one-dimensional, managed 8-bit unsigned integer array to an unmanaged memory pointer.
/// The one-dimensional array to copy from.
/// The zero-based index in the source array where copying should start.
/// The memory pointer to copy to.
/// The number of array elements to copy.
///
/// and are not valid.
///
/// , , , or is .
// Token: 0x06002D06 RID: 11526 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x6002D06")]
[Address(RVA = "0x2CF1F90", Offset = "0x2CF0F90", VA = "0x182CF1F90")]
public static void Copy(byte[] source, int startIndex, IntPtr destination, int length)
{
}
/// Copies data from a one-dimensional, managed array to an unmanaged memory pointer.
/// The one-dimensional array to copy from.
/// The zero-based index in the source array where copying should start.
/// The memory pointer to copy to.
/// The number of array elements to copy.
///
/// , , , or is .
// Token: 0x06002D07 RID: 11527 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x6002D07")]
[Address(RVA = "0x2CF2190", Offset = "0x2CF1190", VA = "0x182CF2190")]
public static void Copy(IntPtr[] source, int startIndex, IntPtr destination, int length)
{
}
/// Copies data from an unmanaged memory pointer to a managed 8-bit unsigned integer array.
/// The memory pointer to copy from.
/// The array to copy to.
/// The zero-based index in the destination array where copying should start.
/// The number of array elements to copy.
///
/// , , , or is .
// Token: 0x06002D08 RID: 11528 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x6002D08")]
[Address(RVA = "0x2CF2110", Offset = "0x2CF1110", VA = "0x182CF2110")]
public static void Copy(IntPtr source, byte[] destination, int startIndex, int length)
{
}
/// Copies data from an unmanaged memory pointer to a managed character array.
/// The memory pointer to copy from.
/// The array to copy to.
/// The zero-based index in the destination array where copying should start.
/// The number of array elements to copy.
///
/// , , , or is .
// Token: 0x06002D09 RID: 11529 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x6002D09")]
[Address(RVA = "0x2CF2090", Offset = "0x2CF1090", VA = "0x182CF2090")]
public static void Copy(IntPtr source, char[] destination, int startIndex, int length)
{
}
/// Copies data from an unmanaged memory pointer to a managed 16-bit signed integer array.
/// The memory pointer to copy from.
/// The array to copy to.
/// The zero-based index in the destination array where copying should start.
/// The number of array elements to copy.
///
/// , , , or is .
// Token: 0x06002D0A RID: 11530 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x6002D0A")]
[Address(RVA = "0x2CF2210", Offset = "0x2CF1210", VA = "0x182CF2210")]
public static void Copy(IntPtr source, short[] destination, int startIndex, int length)
{
}
/// Copies data from an unmanaged memory pointer to a managed single-precision floating-point number array.
/// The memory pointer to copy from.
/// The array to copy to.
/// The zero-based index in the destination array where copying should start.
/// The number of array elements to copy.
///
/// , , , or is .
// Token: 0x06002D0B RID: 11531 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x6002D0B")]
[Address(RVA = "0x2CF2010", Offset = "0x2CF1010", VA = "0x182CF2010")]
public static void Copy(IntPtr source, float[] destination, int startIndex, int length)
{
}
/// Frees all substructures that the specified unmanaged memory block points to.
/// A pointer to an unmanaged block of memory.
/// Type of a formatted class. This provides the layout information necessary to delete the buffer in the parameter.
///
/// has an automatic layout. Use sequential or explicit instead.
// Token: 0x06002D0C RID: 11532 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x6002D0C")]
[Address(RVA = "0x2CF2290", Offset = "0x2CF1290", VA = "0x182CF2290")]
[ComVisible(true)]
public static void DestroyStructure(IntPtr ptr, Type structuretype)
{
}
/// Frees a using the COM SysFreeString function.
/// The address of the BSTR to be freed.
// Token: 0x06002D0D RID: 11533 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x6002D0D")]
[Address(RVA = "0x2CF22A0", Offset = "0x2CF12A0", VA = "0x182CF22A0")]
public static void FreeBSTR(IntPtr ptr)
{
}
/// Frees a block of memory allocated by the unmanaged COM task memory allocator.
/// The address of the memory to be freed.
// Token: 0x06002D0E RID: 11534 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x6002D0E")]
[Address(RVA = "0x2CF22B0", Offset = "0x2CF12B0", VA = "0x182CF22B0")]
public static void FreeCoTaskMem(IntPtr ptr)
{
}
/// Frees memory previously allocated from the unmanaged memory of the process.
/// The handle returned by the original matching call to .
// Token: 0x06002D0F RID: 11535 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x6002D0F")]
[Address(RVA = "0x2CF22C0", Offset = "0x2CF12C0", VA = "0x182CF22C0")]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static void FreeHGlobal(IntPtr hglobal)
{
}
// Token: 0x06002D10 RID: 11536 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x6002D10")]
[Address(RVA = "0x2CF1100", Offset = "0x2CF0100", VA = "0x182CF1100")]
private static void ClearBSTR(IntPtr ptr)
{
}
/// Frees a BSTR pointer that was allocated using the method.
/// The address of the to free.
// Token: 0x06002D11 RID: 11537 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x6002D11")]
[Address(RVA = "0x2CF3580", Offset = "0x2CF2580", VA = "0x182CF3580")]
public static void ZeroFreeBSTR(IntPtr s)
{
}
// Token: 0x06002D12 RID: 11538 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x6002D12")]
[Address(RVA = "0x2CF11E0", Offset = "0x2CF01E0", VA = "0x182CF11E0")]
private static void ClearUnicode(IntPtr ptr)
{
}
/// Frees an unmanaged string pointer that was allocated using the method.
/// The address of the unmanaged string to free.
// Token: 0x06002D13 RID: 11539 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x6002D13")]
[Address(RVA = "0x2CF36B0", Offset = "0x2CF26B0", VA = "0x182CF36B0")]
public static void ZeroFreeGlobalAllocUnicode(IntPtr s)
{
}
// Token: 0x06002D14 RID: 11540 RVA: 0x00019038 File Offset: 0x00017238
[Token(Token = "0x6002D14")]
[Address(RVA = "0x2CF22D0", Offset = "0x2CF12D0", VA = "0x182CF22D0")]
private static IntPtr GetCCW(object o, Type T)
{
return 0;
}
// Token: 0x06002D15 RID: 11541 RVA: 0x00019050 File Offset: 0x00017250
[Token(Token = "0x6002D15")]
[Address(RVA = "0x2CF22E0", Offset = "0x2CF12E0", VA = "0x182CF22E0")]
private static IntPtr GetComInterfaceForObjectInternal(object o, Type T)
{
return 0;
}
/// Returns a pointer to an IUnknown interface that represents the specified interface on the specified object. Custom query interface access is enabled by default.
/// The object that provides the interface.
/// The type of interface that is requested.
/// The interface pointer that represents the specified interface for the object.
/// The parameter is not an interface.
/// -or-
/// The type is not visible to COM.
/// -or-
/// The parameter is a generic type definition.
/// The parameter does not support the requested interface.
/// The parameter is .
/// -or-
/// The parameter is .
// Token: 0x06002D16 RID: 11542 RVA: 0x00019068 File Offset: 0x00017268
[Token(Token = "0x6002D16")]
[Address(RVA = "0x2CF2340", Offset = "0x2CF1340", VA = "0x182CF2340")]
public static IntPtr GetComInterfaceForObject(object o, Type T)
{
return 0;
}
/// Converts the specified exception to an HRESULT.
/// The exception to convert to an HRESULT.
/// The HRESULT mapped to the supplied exception.
// Token: 0x06002D17 RID: 11543 RVA: 0x00019080 File Offset: 0x00017280
[Token(Token = "0x6002D17")]
[Address(RVA = "0x2CF27B0", Offset = "0x2CF17B0", VA = "0x182CF27B0")]
public static int GetHRForException(Exception e)
{
return 0;
}
/// Returns the error code returned by the last unmanaged function that was called using platform invoke that has the flag set.
/// The last error code set by a call to the Win32 SetLastError function.
// Token: 0x06002D18 RID: 11544 RVA: 0x00019098 File Offset: 0x00017298
[Token(Token = "0x6002D18")]
[Address(RVA = "0x2CF27C0", Offset = "0x2CF17C0", VA = "0x182CF27C0")]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static int GetLastWin32Error()
{
return 0;
}
/// Performs a pre-link check for all methods on a class.
/// The class whose methods are to be checked.
/// The parameter is .
// Token: 0x06002D19 RID: 11545 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x6002D19")]
[Address(RVA = "0x2CF27D0", Offset = "0x2CF17D0", VA = "0x182CF27D0")]
public static void PrelinkAll(Type c)
{
}
/// Copies all characters up to the first null character from an unmanaged ANSI string to a managed , and widens each ANSI character to Unicode.
/// The address of the first character of the unmanaged string.
/// A managed string that holds a copy of the unmanaged ANSI string. If is , the method returns a null string.
// Token: 0x06002D1A RID: 11546 RVA: 0x00002082 File Offset: 0x00000282
[Token(Token = "0x6002D1A")]
[Address(RVA = "0x2CF27F0", Offset = "0x2CF17F0", VA = "0x182CF27F0")]
public static string PtrToStringAnsi(IntPtr ptr)
{
return null;
}
/// Allocates a managed , copies a specified number of characters from an unmanaged ANSI string into it, and widens each ANSI character to Unicode.
/// The address of the first character of the unmanaged string.
/// The byte count of the input string to copy.
/// A managed string that holds a copy of the native ANSI string if the value of the parameter is not ; otherwise, this method returns .
///
/// is less than zero.
// Token: 0x06002D1B RID: 11547 RVA: 0x00002082 File Offset: 0x00000282
[Token(Token = "0x6002D1B")]
[Address(RVA = "0x2CF27E0", Offset = "0x2CF17E0", VA = "0x182CF27E0")]
public static string PtrToStringAnsi(IntPtr ptr, int len)
{
return null;
}
/// Allocates a managed and copies all characters up to the first null character from a string stored in unmanaged memory into it.
/// For Unicode platforms, the address of the first Unicode character.
/// -or-
/// For ANSI plaforms, the address of the first ANSI character.
/// A managed string that holds a copy of the unmanaged string if the value of the parameter is not ; otherwise, this method returns .
// Token: 0x06002D1C RID: 11548 RVA: 0x00002082 File Offset: 0x00000282
[Token(Token = "0x6002D1C")]
[Address(RVA = "0x2CF2800", Offset = "0x2CF1800", VA = "0x182CF2800")]
public static string PtrToStringAuto(IntPtr ptr)
{
return null;
}
/// Allocates a managed and copies all characters up to the first null character from an unmanaged Unicode string into it.
/// The address of the first character of the unmanaged string.
/// A managed string that holds a copy of the unmanaged string if the value of the parameter is not ; otherwise, this method returns .
// Token: 0x06002D1D RID: 11549 RVA: 0x00002082 File Offset: 0x00000282
[Token(Token = "0x6002D1D")]
[Address(RVA = "0x2CF28B0", Offset = "0x2CF18B0", VA = "0x182CF28B0")]
public static string PtrToStringUni(IntPtr ptr)
{
return null;
}
/// Allocates a managed and copies a binary string (BSTR) stored in unmanaged memory into it.
/// The address of the first character of the unmanaged string.
/// A managed string that holds a copy of the unmanaged string.
///
/// equals .
// Token: 0x06002D1E RID: 11550 RVA: 0x00002082 File Offset: 0x00000282
[Token(Token = "0x6002D1E")]
[Address(RVA = "0x2CF28A0", Offset = "0x2CF18A0", VA = "0x182CF28A0")]
public static string PtrToStringBSTR(IntPtr ptr)
{
return null;
}
/// Marshals data from an unmanaged block of memory to a managed object.
/// A pointer to an unmanaged block of memory.
/// The object to which the data is to be copied. This must be an instance of a formatted class.
/// Structure layout is not sequential or explicit.
/// -or-
/// Structure is a boxed value type.
// Token: 0x06002D1F RID: 11551 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x6002D1F")]
[Address(RVA = "0x2CF28C0", Offset = "0x2CF18C0", VA = "0x182CF28C0")]
[ComVisible(true)]
public static void PtrToStructure(IntPtr ptr, object structure)
{
}
/// Marshals data from an unmanaged block of memory to a newly allocated managed object of the specified type.
/// A pointer to an unmanaged block of memory.
/// The type of object to be created. This object must represent a formatted class or a structure.
/// A managed object containing the data pointed to by the parameter.
/// The parameter layout is not sequential or explicit.
/// -or-
/// The parameter is a generic type definition.
///
/// is .
/// The class specified by does not have an accessible default constructor.
// Token: 0x06002D20 RID: 11552 RVA: 0x00002082 File Offset: 0x00000282
[Token(Token = "0x6002D20")]
[Address(RVA = "0x2CF28D0", Offset = "0x2CF18D0", VA = "0x182CF28D0")]
[ComVisible(true)]
public static object PtrToStructure(IntPtr ptr, Type structureType)
{
return null;
}
/// [Supported in the .NET Framework 4.5.1 and later versions]
/// Marshals data from an unmanaged block of memory to a managed object of the specified type.
/// A pointer to an unmanaged block of memory.
/// The object to which the data is to be copied.
/// The type of . This must be a formatted class.
/// Structure layout is not sequential or explicit.
// Token: 0x06002D21 RID: 11553 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x6002D21")]
[Address(RVA = "0x1FD72A0", Offset = "0x1FD62A0", VA = "0x181FD72A0")]
public static void PtrToStructure(IntPtr ptr, T structure)
{
}
/// [Supported in the .NET Framework 4.5.1 and later versions]
/// Marshals data from an unmanaged block of memory to a newly allocated managed object of the type specified by a generic type parameter.
/// A pointer to an unmanaged block of memory.
/// The type of the object to which the data is to be copied. This must be a formatted class or a structure.
/// A managed object that contains the data that the parameter points to.
/// The layout of is not sequential or explicit.
/// The class specified by does not have an accessible default constructor.
// Token: 0x06002D22 RID: 11554 RVA: 0x00002082 File Offset: 0x00000282
[Token(Token = "0x6002D22")]
[Address(RVA = "0x1E5F400", Offset = "0x1E5E400", VA = "0x181E5F400")]
public static T PtrToStructure(IntPtr ptr)
{
return null;
}
/// Reads a single byte at a given offset (or index) from unmanaged memory.
/// The base address in unmanaged memory from which to read.
/// An additional byte offset, which is added to the parameter before reading.
/// The byte read from unmanaged memory at the given offset.
/// Base address () plus offset byte () produces a null or invalid address.
// Token: 0x06002D23 RID: 11555 RVA: 0x000190B0 File Offset: 0x000172B0
[Token(Token = "0x6002D23")]
[Address(RVA = "0x2CF28E0", Offset = "0x2CF18E0", VA = "0x182CF28E0")]
public static byte ReadByte(IntPtr ptr, int ofs)
{
return 0;
}
/// Reads a 16-bit signed integer at a given offset from unmanaged memory.
/// The base address in unmanaged memory from which to read.
/// An additional byte offset, which is added to the parameter before reading.
/// The 16-bit signed integer read from unmanaged memory at the given offset.
/// Base address () plus offset byte () produces a null or invalid address.
// Token: 0x06002D24 RID: 11556 RVA: 0x000190C8 File Offset: 0x000172C8
[Token(Token = "0x6002D24")]
[Address(RVA = "0x2CF2900", Offset = "0x2CF1900", VA = "0x182CF2900")]
public static short ReadInt16(IntPtr ptr, int ofs)
{
return 0;
}
/// Reads a 32-bit signed integer from unmanaged memory.
/// The address in unmanaged memory from which to read.
/// The 32-bit signed integer read from unmanaged memory.
///
/// is not a recognized format.
/// -or-
/// is .
/// -or-
/// is invalid.
// Token: 0x06002D25 RID: 11557 RVA: 0x000190E0 File Offset: 0x000172E0
[Token(Token = "0x6002D25")]
[Address(RVA = "0x2CF2950", Offset = "0x2CF1950", VA = "0x182CF2950")]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static int ReadInt32(IntPtr ptr)
{
return 0;
}
/// Reads a 32-bit signed integer at a given offset from unmanaged memory.
/// The base address in unmanaged memory from which to read.
/// An additional byte offset, which is added to the parameter before reading.
/// The 32-bit signed integer read from unmanaged memory.
/// Base address () plus offset byte () produces a null or invalid address.
// Token: 0x06002D26 RID: 11558 RVA: 0x000190F8 File Offset: 0x000172F8
[Token(Token = "0x6002D26")]
[Address(RVA = "0x2CF2990", Offset = "0x2CF1990", VA = "0x182CF2990")]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static int ReadInt32(IntPtr ptr, int ofs)
{
return 0;
}
/// Reads a 64-bit signed integer from unmanaged memory.
/// The address in unmanaged memory from which to read.
/// The 64-bit signed integer read from unmanaged memory.
///
/// is not a recognized format.
/// -or-
/// is .
/// -or-
/// is invalid.
// Token: 0x06002D27 RID: 11559 RVA: 0x00019110 File Offset: 0x00017310
[Token(Token = "0x6002D27")]
[Address(RVA = "0x2CF2A30", Offset = "0x2CF1A30", VA = "0x182CF2A30")]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static long ReadInt64(IntPtr ptr)
{
return 0L;
}
/// Reads a 64-bit signed integer at a given offset from unmanaged memory.
/// The base address in unmanaged memory from which to read.
/// An additional byte offset, which is added to the parameter before reading.
/// The 64-bit signed integer read from unmanaged memory at the given offset.
/// Base address () plus offset byte () produces a null or invalid address.
// Token: 0x06002D28 RID: 11560 RVA: 0x00019128 File Offset: 0x00017328
[Token(Token = "0x6002D28")]
[Address(RVA = "0x2CF29E0", Offset = "0x2CF19E0", VA = "0x182CF29E0")]
public static long ReadInt64(IntPtr ptr, int ofs)
{
return 0L;
}
/// Reads a processor native-sized integer from unmanaged memory.
/// The address in unmanaged memory from which to read.
/// The integer read from unmanaged memory. A 32 bit integer is returned on 32 bit machines and a 64 bit integer is returned on 64 bit machines.
///
/// is not a recognized format.
/// -or-
/// is .
/// -or-
/// is invalid.
// Token: 0x06002D29 RID: 11561 RVA: 0x00019140 File Offset: 0x00017340
[Token(Token = "0x6002D29")]
[Address(RVA = "0x2CF2BA0", Offset = "0x2CF1BA0", VA = "0x182CF2BA0")]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static IntPtr ReadIntPtr(IntPtr ptr)
{
return 0;
}
/// Reads a processor native sized integer at a given offset from unmanaged memory.
/// The base address in unmanaged memory from which to read.
/// An additional byte offset, which is added to the parameter before reading.
/// The integer read from unmanaged memory at the given offset.
/// Base address () plus offset byte () produces a null or invalid address.
// Token: 0x06002D2A RID: 11562 RVA: 0x00019158 File Offset: 0x00017358
[Token(Token = "0x6002D2A")]
[Address(RVA = "0x2CF2A80", Offset = "0x2CF1A80", VA = "0x182CF2A80")]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static IntPtr ReadIntPtr(IntPtr ptr, int ofs)
{
return 0;
}
// Token: 0x06002D2B RID: 11563 RVA: 0x00019170 File Offset: 0x00017370
[Token(Token = "0x6002D2B")]
[Address(RVA = "0x2CF2CB0", Offset = "0x2CF1CB0", VA = "0x182CF2CB0")]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
private static int ReleaseInternal(IntPtr pUnk)
{
return 0;
}
/// Decrements the reference count on the specified interface.
/// The interface to release.
/// The new value of the reference count on the interface specified by the parameter.
// Token: 0x06002D2C RID: 11564 RVA: 0x00019188 File Offset: 0x00017388
[Token(Token = "0x6002D2C")]
[Address(RVA = "0x2CF2CC0", Offset = "0x2CF1CC0", VA = "0x182CF2CC0")]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
public static int Release(IntPtr pUnk)
{
return 0;
}
/// Returns the unmanaged size of an object in bytes.
/// The object whose size is to be returned.
/// The size of the specified object in unmanaged code.
/// The parameter is .
// Token: 0x06002D2D RID: 11565 RVA: 0x000191A0 File Offset: 0x000173A0
[Token(Token = "0x6002D2D")]
[Address(RVA = "0x2CF31D0", Offset = "0x2CF21D0", VA = "0x182CF31D0")]
[ComVisible(true)]
public static int SizeOf(object structure)
{
return 0;
}
/// Returns the size of an unmanaged type in bytes.
/// The type whose size is to be returned.
/// The size of the specified type in unmanaged code.
/// The parameter is a generic type definition.
/// The parameter is .
// Token: 0x06002D2E RID: 11566 RVA: 0x000191B8 File Offset: 0x000173B8
[Token(Token = "0x6002D2E")]
[Address(RVA = "0x2CF31C0", Offset = "0x2CF21C0", VA = "0x182CF31C0")]
public static int SizeOf(Type t)
{
return 0;
}
/// [Supported in the .NET Framework 4.5.1 and later versions]
/// Returns the size of an unmanaged type in bytes.
/// The type whose size is to be returned.
/// The size, in bytes, of the type that is specified by the generic type parameter.
// Token: 0x06002D2F RID: 11567 RVA: 0x000191D0 File Offset: 0x000173D0
[Token(Token = "0x6002D2F")]
[Address(RVA = "0x27D7D40", Offset = "0x27D6D40", VA = "0x1827D7D40")]
public static int SizeOf()
{
return 0;
}
/// [Supported in the .NET Framework 4.5.1 and later versions]
/// Returns the unmanaged size of an object of a specified type in bytes.
/// The object whose size is to be returned.
/// The type of the parameter.
/// The size, in bytes, of the specified object in unmanaged code.
/// The parameter is .
// Token: 0x06002D30 RID: 11568 RVA: 0x000191E8 File Offset: 0x000173E8
[Token(Token = "0x6002D30")]
[Address(RVA = "0x27D7DD0", Offset = "0x27D6DD0", VA = "0x1827D7DD0")]
public static int SizeOf(T structure)
{
return 0;
}
/// Allocates a BSTR and copies the contents of a managed into it.
/// The managed string to be copied.
/// An unmanaged pointer to the , or 0 if is null.
/// There is insufficient memory available.
/// The length for is out of range.
// Token: 0x06002D31 RID: 11569 RVA: 0x00019200 File Offset: 0x00017400
[Token(Token = "0x6002D31")]
[Address(RVA = "0x2CF3240", Offset = "0x2CF2240", VA = "0x182CF3240")]
public static IntPtr StringToBSTR(string s)
{
return 0;
}
/// Copies the contents of a managed into unmanaged memory.
/// A managed string to be copied.
/// The address, in unmanaged memory, to where the was copied, or 0 if is .
/// The method could not allocate enough native heap memory.
/// The parameter exceeds the maximum length allowed by the operating system.
// Token: 0x06002D32 RID: 11570 RVA: 0x00019218 File Offset: 0x00017418
[Token(Token = "0x6002D32")]
[Address(RVA = "0x2CF3250", Offset = "0x2CF2250", VA = "0x182CF3250")]
public static IntPtr StringToHGlobalUni(string s)
{
return 0;
}
/// Allocates an unmanaged binary string (BSTR) and copies the contents of a managed object into it.
/// The managed object to copy.
/// The address, in unmanaged memory, where the parameter was copied to, or 0 if a null object was supplied.
/// The parameter is .
/// The current computer is not running Windows 2000 Service Pack 3 or later.
/// There is insufficient memory available.
// Token: 0x06002D33 RID: 11571 RVA: 0x00019230 File Offset: 0x00017430
[Token(Token = "0x6002D33")]
[Address(RVA = "0x2CF2D60", Offset = "0x2CF1D60", VA = "0x182CF2D60")]
public static IntPtr SecureStringToBSTR(SecureString s)
{
return 0;
}
/// Copies the contents of a managed object to a block of memory allocated from the unmanaged COM task allocator.
/// The managed object to copy.
/// The address, in unmanaged memory, where the parameter was copied to, or 0 if a null object was supplied.
/// The parameter is .
/// The current computer is not running Windows 2000 Service Pack 3 or later.
/// There is insufficient memory available.
// Token: 0x06002D34 RID: 11572 RVA: 0x00019248 File Offset: 0x00017448
[Token(Token = "0x6002D34")]
[Address(RVA = "0x2CF2ED0", Offset = "0x2CF1ED0", VA = "0x182CF2ED0")]
public static IntPtr SecureStringToCoTaskMemUnicode(SecureString s)
{
return 0;
}
/// Copies the contents of a managed object into unmanaged memory.
/// The managed object to copy.
/// The address, in unmanaged memory, where was copied, or 0 if is a object whose length is 0.
/// The parameter is .
/// The current computer is not running Windows 2000 Service Pack 3 or later.
/// There is insufficient memory available.
// Token: 0x06002D35 RID: 11573 RVA: 0x00019260 File Offset: 0x00017460
[Token(Token = "0x6002D35")]
[Address(RVA = "0x2CF3130", Offset = "0x2CF2130", VA = "0x182CF3130")]
public static IntPtr SecureStringToGlobalAllocUnicode(SecureString s)
{
return 0;
}
/// Marshals data from a managed object to an unmanaged block of memory.
/// A managed object that holds the data to be marshaled. This object must be a structure or an instance of a formatted class.
/// A pointer to an unmanaged block of memory, which must be allocated before this method is called.
///
/// to call the method on the parameter before this method copies the data. The block must contain valid data. Note that passing when the memory block already contains data can lead to a memory leak.
///
/// is a reference type that is not a formatted class.
/// -or-
/// is an instance of a generic type (in the .NET Framework 4.5 and earlier versions only).
// Token: 0x06002D36 RID: 11574 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x6002D36")]
[Address(RVA = "0x2CF3260", Offset = "0x2CF2260", VA = "0x182CF3260")]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
[ComVisible(true)]
public static void StructureToPtr(object structure, IntPtr ptr, bool fDeleteOld)
{
}
/// [Supported in the .NET Framework 4.5.1 and later versions]
/// Marshals data from a managed object of a specified type to an unmanaged block of memory.
/// A managed object that holds the data to be marshaled. The object must be a structure or an instance of a formatted class.
/// A pointer to an unmanaged block of memory, which must be allocated before this method is called.
///
/// to call the method on the parameter before this method copies the data. The block must contain valid data. Note that passing when the memory block already contains data can lead to a memory leak.
/// The type of the managed object.
///
/// is a reference type that is not a formatted class.
// Token: 0x06002D37 RID: 11575 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x6002D37")]
[Address(RVA = "0x1FD7310", Offset = "0x1FD6310", VA = "0x181FD7310")]
public static void StructureToPtr(T structure, IntPtr ptr, bool fDeleteOld)
{
}
/// Throws an exception with a specific failure HRESULT value.
/// The HRESULT corresponding to the desired exception.
// Token: 0x06002D38 RID: 11576 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x6002D38")]
[Address(RVA = "0x2CF3270", Offset = "0x2CF2270", VA = "0x182CF3270")]
public static void ThrowExceptionForHR(int errorCode)
{
}
// Token: 0x06002D39 RID: 11577 RVA: 0x00019278 File Offset: 0x00017478
[Token(Token = "0x6002D39")]
[Address(RVA = "0x92BEF0", Offset = "0x92AEF0", VA = "0x18092BEF0")]
private static IntPtr BufferToBSTR(Array ptr, int slen)
{
return 0;
}
/// Gets the address of the element at the specified index inside the specified array.
/// The array that contains the desired element.
/// The index in the parameter of the desired element.
/// The address of inside .
// Token: 0x06002D3A RID: 11578 RVA: 0x00019290 File Offset: 0x00017490
[Token(Token = "0x6002D3A")]
[Address(RVA = "0x2CF3360", Offset = "0x2CF2360", VA = "0x182CF3360")]
public static IntPtr UnsafeAddrOfPinnedArrayElement(Array arr, int index)
{
return 0;
}
/// [Supported in the .NET Framework 4.5.1 and later versions]
/// Gets the address of the element at the specified index in an array of a specified type.
/// The array that contains the desired element.
/// The index of the desired element in the array.
/// The type of the array.
/// The address of in .
// Token: 0x06002D3B RID: 11579 RVA: 0x000192A8 File Offset: 0x000174A8
[Token(Token = "0x6002D3B")]
[Address(RVA = "0x27D8490", Offset = "0x27D7490", VA = "0x1827D8490")]
public static IntPtr UnsafeAddrOfPinnedArrayElement(T[] arr, int index)
{
return 0;
}
/// Writes a single byte value to unmanaged memory at a specified offset.
/// The base address in unmanaged memory to write to.
/// An additional byte offset, which is added to the parameter before writing.
/// The value to write.
/// Base address () plus offset byte () produces a null or invalid address.
// Token: 0x06002D3C RID: 11580 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x6002D3C")]
[Address(RVA = "0x2CF3370", Offset = "0x2CF2370", VA = "0x182CF3370")]
public static void WriteByte(IntPtr ptr, int ofs, byte val)
{
}
/// Writes a 16-bit signed integer value into unmanaged memory at a specified offset.
/// The base address in unmanaged memory to write to.
/// An additional byte offset, which is added to the parameter before writing.
/// The value to write.
/// Base address () plus offset byte () produces a null or invalid address.
// Token: 0x06002D3D RID: 11581 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x6002D3D")]
[Address(RVA = "0x2CF33A0", Offset = "0x2CF23A0", VA = "0x182CF33A0")]
public static void WriteInt16(IntPtr ptr, int ofs, short val)
{
}
/// Writes a 32-bit signed integer value to unmanaged memory.
/// The address in unmanaged memory to write to.
/// The value to write.
///
/// is not a recognized format.
/// -or-
/// is .
/// -or-
/// is invalid.
// Token: 0x06002D3E RID: 11582 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x6002D3E")]
[Address(RVA = "0x2CF33F0", Offset = "0x2CF23F0", VA = "0x182CF33F0")]
public static void WriteInt32(IntPtr ptr, int val)
{
}
/// Writes a 64-bit signed integer value to unmanaged memory.
/// The address in unmanaged memory to write to.
/// The value to write.
///
/// is not a recognized format.
/// -or-
/// is .
/// -or-
/// is invalid.
// Token: 0x06002D3F RID: 11583 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x6002D3F")]
[Address(RVA = "0x2CF3430", Offset = "0x2CF2430", VA = "0x182CF3430")]
public static void WriteInt64(IntPtr ptr, long val)
{
}
/// Writes a processor native sized integer value into unmanaged memory.
/// The address in unmanaged memory to write to.
/// The value to write.
///
/// is not a recognized format.
/// -or-
/// is .
/// -or-
/// is invalid.
// Token: 0x06002D40 RID: 11584 RVA: 0x00002050 File Offset: 0x00000250
[Token(Token = "0x6002D40")]
[Address(RVA = "0x2CF3470", Offset = "0x2CF2470", VA = "0x182CF3470")]
public static void WriteIntPtr(IntPtr ptr, IntPtr val)
{
}
// Token: 0x06002D41 RID: 11585 RVA: 0x00002082 File Offset: 0x00000282
[Token(Token = "0x6002D41")]
[Address(RVA = "0x2CF12F0", Offset = "0x2CF02F0", VA = "0x182CF12F0")]
private static Exception ConvertHrToException(int errorCode)
{
return null;
}
/// Converts the specified HRESULT error code to a corresponding object.
/// The HRESULT to be converted.
/// An object that represents the converted HRESULT.
// Token: 0x06002D42 RID: 11586 RVA: 0x00002082 File Offset: 0x00000282
[Token(Token = "0x6002D42")]
[Address(RVA = "0x2CF2710", Offset = "0x2CF1710", VA = "0x182CF2710")]
public static Exception GetExceptionForHR(int errorCode)
{
return null;
}
/// Converts the specified HRESULT error code to a corresponding object, with additional error information passed in an IErrorInfo interface for the exception object.
/// The HRESULT to be converted.
/// A pointer to the interface that provides more information about the error. You can specify IntPtr(0) to use the current interface, or IntPtr(-1) to ignore the current interface and construct the exception just from the error code.
/// An object that represents the converted HRESULT and information obtained from .
// Token: 0x06002D43 RID: 11587 RVA: 0x00002082 File Offset: 0x00000282
[Token(Token = "0x6002D43")]
[Address(RVA = "0x2CF26C0", Offset = "0x2CF16C0", VA = "0x182CF26C0")]
public static Exception GetExceptionForHR(int errorCode, IntPtr errorInfo)
{
return null;
}
// Token: 0x06002D44 RID: 11588 RVA: 0x00002082 File Offset: 0x00000282
[Token(Token = "0x6002D44")]
[Address(RVA = "0x2CF2470", Offset = "0x2CF1470", VA = "0x182CF2470")]
private static Delegate GetDelegateForFunctionPointerInternal(IntPtr ptr, Type t)
{
return null;
}
/// Converts an unmanaged function pointer to a delegate.
/// The unmanaged function pointer to be converted.
/// The type of the delegate to be returned.
/// A delegate instance that can be cast to the appropriate delegate type.
/// The parameter is not a delegate or is generic.
/// The parameter is .
/// -or-
/// The parameter is .
// Token: 0x06002D45 RID: 11589 RVA: 0x00002082 File Offset: 0x00000282
[Token(Token = "0x6002D45")]
[Address(RVA = "0x2CF2480", Offset = "0x2CF1480", VA = "0x182CF2480")]
public static Delegate GetDelegateForFunctionPointer(IntPtr ptr, Type t)
{
return null;
}
/// [Supported in the .NET Framework 4.5.1 and later versions]
/// Converts an unmanaged function pointer to a delegate of a specified type.
/// The unmanaged function pointer to convert.
/// The type of the delegate to return.
/// A instance of the specified delegate type.
/// The generic parameter is not a delegate, or it is an open generic type.
/// The parameter is .
// Token: 0x06002D46 RID: 11590 RVA: 0x00002082 File Offset: 0x00000282
[Token(Token = "0x6002D46")]
[Address(RVA = "0x1E5F320", Offset = "0x1E5E320", VA = "0x181E5F320")]
public static TDelegate GetDelegateForFunctionPointer(IntPtr ptr)
{
return null;
}
// Token: 0x06002D47 RID: 11591 RVA: 0x000192C0 File Offset: 0x000174C0
[Token(Token = "0x6002D47")]
[Address(RVA = "0x2CF27A0", Offset = "0x2CF17A0", VA = "0x182CF27A0")]
private static IntPtr GetFunctionPointerForDelegateInternal(Delegate d)
{
return 0;
}
/// [Supported in the .NET Framework 4.5.1 and later versions]
/// Converts a delegate of a specified type to a function pointer that is callable from unmanaged code.
/// The delegate to be passed to unmanaged code.
/// The type of delegate to convert.
/// A value that can be passed to unmanaged code, which, in turn, can use it to call the underlying managed delegate.
/// The parameter is a generic type definition.
/// The parameter is .
// Token: 0x06002D48 RID: 11592 RVA: 0x000192D8 File Offset: 0x000174D8
[Token(Token = "0x6002D48")]
[Address(RVA = "0x27D7C80", Offset = "0x27D6C80", VA = "0x1827D7C80")]
public static IntPtr GetFunctionPointerForDelegate(TDelegate d)
{
return 0;
}
/// Represents the maximum size of a double byte character set (DBCS) size, in bytes, for the current operating system. This field is read-only.
// Token: 0x04001A04 RID: 6660
[Token(Token = "0x4001A04")]
public static readonly int SystemMaxDBCSCharSize;
/// Represents the default character size on the system; the default is 2 for Unicode systems and 1 for ANSI systems. This field is read-only.
// Token: 0x04001A05 RID: 6661
[Token(Token = "0x4001A05")]
public static readonly int SystemDefaultCharSize;
}
}