/// <summary> /// 指定されたメモリブロックの内容を、他の場所へコピーします。 /// </summary> /// <param name="outDest"></param> /// <param name="inSrc"></param> /// <param name="inNumOfBytes"></param> /// <remarks> /// Yanesdk.NET (http://yanesdkdotnet.sourceforge.jp/) の Screen2DGl.cs から借用させて頂きました。 /// </remarks> #else /// <summary> /// /// </summary> /// <param name="outDest"></param> /// <param name="inSrc"></param> /// <param name="inNumOfBytes"></param> #endif public static unsafe void CopyMemory(void* outDest, void* inSrc, uint inNumOfBytes) { #if net20 || net40 // 転送先をuint幅にalignする const uint align = sizeof(uint) - 1; uint offset = (uint)outDest & align; // ↑ポインタは32bitとは限らないので本来このキャストはuintではダメだが、 // 今は下位2bitだけあればいいのでこれでOK。 if (offset != 0) offset = align - offset; offset = Math.Min(offset, inNumOfBytes); // 先頭の余り部分をbyteでちまちまコピー byte* srcBytes = (byte*)inSrc; byte* dstBytes = (byte*)outDest; for (uint i = 0; i < offset; i++) dstBytes[i] = srcBytes[i]; // uintで一気に転送 uint* dst = (uint*)((byte*)outDest + offset); uint* src = (uint*)((byte*)inSrc + offset); uint numOfUInt = (inNumOfBytes - offset) / sizeof(uint); for (uint i = 0; i < numOfUInt; i++) dst[i] = src[i]; // 末尾の余り部分をbyteでちまちまコピー for (uint i = offset + numOfUInt * sizeof(uint); i < inNumOfBytes; i++) dstBytes[i] = srcBytes[i]; #else Buffer.MemoryCopy(inSrc, outDest, inNumOfBytes, inNumOfBytes); #endif }
public static unsafe void* AllocateObject(void* methodTable, uint classSize) { // HACK: Add compiler architecture to the runtime uint nativeIntSize = 4; // // An object has the following memory layout: // - IntPtr MTable // - IntPtr SyncBlock // - 0 .. n object data fields // ulong allocationSize = (ulong)((2 * nativeIntSize) + classSize); void* memory = MemoryPageManager.Allocate(IntPtr.Zero, allocationSize, PageProtectionFlags.Read | PageProtectionFlags.Write | PageProtectionFlags.WriteCombine).ToPointer(); if (memory == null) { throw new OutOfMemoryException(); } uint* destination = (uint*)memory; Memset((byte*)destination, 0, (int)allocationSize); destination[0] = (uint)methodTable; destination[1] = 0; // No sync block initially return memory; }
/// <summary> /// Formats a message string. The function requires a message definition as input. The message definition can come from a buffer passed into the function. It can come from a message table resource in an already-loaded module. Or the caller can ask the function to search the system's message table resource(s) for the message definition. The function finds the message definition in a message table resource based on a message identifier and a language identifier. The function copies the formatted message text to an output buffer, processing any embedded insert sequences if requested. /// </summary> /// <param name="dwFlags"> /// The formatting options, and how to interpret the lpSource parameter. The low-order byte of dwFlags specifies how the function handles line breaks in the output buffer. The low-order byte can also specify the maximum width of a formatted output line. /// The <see cref="FormatMessageFlags.FORMAT_MESSAGE_ARGUMENT_ARRAY"/> flag is always added /// and the <see cref="FormatMessageFlags.FORMAT_MESSAGE_ALLOCATE_BUFFER"/> flag is always suppressed by this helper method /// </param> /// <param name="lpSource"> /// The location of the message definition. The type of this parameter depends upon the settings in the <paramref name="dwFlags"/> parameter. /// If <see cref="FormatMessageFlags.FORMAT_MESSAGE_FROM_HMODULE"/>: A handle to the module that contains the message table to search. /// If <see cref="FormatMessageFlags.FORMAT_MESSAGE_FROM_STRING"/>: Pointer to a string that consists of unformatted message text. It will be scanned for inserts and formatted accordingly. /// If neither of these flags is set in dwFlags, then lpSource is ignored. /// </param> /// <param name="dwMessageId"> /// The message identifier for the requested message. This parameter is ignored if dwFlags includes <see cref="FormatMessageFlags.FORMAT_MESSAGE_FROM_STRING" />. /// </param> /// <param name="dwLanguageId"> /// The language identifier for the requested message. This parameter is ignored if dwFlags includes <see cref="FormatMessageFlags.FORMAT_MESSAGE_FROM_STRING"/>. /// If you pass a specific LANGID in this parameter, FormatMessage will return a message for that LANGID only.If the function cannot find a message for that LANGID, it sets Last-Error to ERROR_RESOURCE_LANG_NOT_FOUND.If you pass in zero, FormatMessage looks for a message for LANGIDs in the following order: /// Language neutral /// Thread LANGID, based on the thread's locale value /// User default LANGID, based on the user's default locale value /// System default LANGID, based on the system default locale value /// US English /// If FormatMessage does not locate a message for any of the preceding LANGIDs, it returns any language message string that is present.If that fails, it returns ERROR_RESOURCE_LANG_NOT_FOUND. /// </param> /// <param name="Arguments"> /// An array of values that are used as insert values in the formatted message. A %1 in the format string indicates the first value in the Arguments array; a %2 indicates the second argument; and so on. /// The interpretation of each value depends on the formatting information associated with the insert in the message definition.The default is to treat each value as a pointer to a null-terminated string. /// By default, the Arguments parameter is of type va_list*, which is a language- and implementation-specific data type for describing a variable number of arguments.The state of the va_list argument is undefined upon return from the function.To use the va_list again, destroy the variable argument list pointer using va_end and reinitialize it with va_start. /// If you do not have a pointer of type va_list*, then specify the FORMAT_MESSAGE_ARGUMENT_ARRAY flag and pass a pointer to an array of DWORD_PTR values; those values are input to the message formatted as the insert values.Each insert must have a corresponding element in the array. /// </param> /// <param name="maxAllowedBufferSize">The maximum size of the returned string. If exceeded, <c>null</c> is returned.</param> /// <returns> /// If the function succeeds, the return value is the number of TCHARs stored in the output buffer, excluding the terminating null character. /// If the function fails, the return value is zero. To get extended error information, call <see cref="GetLastError"/>. /// </returns> public static unsafe string FormatMessage(FormatMessageFlags dwFlags, void* lpSource, int dwMessageId, int dwLanguageId, IntPtr[] Arguments, int maxAllowedBufferSize) { string errorMsg; StringBuilder sb = new StringBuilder(256); do { if (TryGetErrorMessage(dwFlags, lpSource, dwMessageId, dwLanguageId, sb, Arguments, out errorMsg)) { return errorMsg; } else { if (GetLastError() == Win32ErrorCode.ERROR_INSUFFICIENT_BUFFER) { // increase the capacity of the StringBuilder by 4 times. sb.Capacity *= 4; } else { // No message with the given ID was found, or some other error occurred. return null; } } } while (sb.Capacity < maxAllowedBufferSize); // If you come here then a size as large as 65K is also not sufficient. return null; }
public static void* BoxBoolean(void* methodTable, uint classSize, bool value) { byte* memory = (byte*)AllocateObject(methodTable, classSize); bool* destination = (bool*)(memory + (nativeIntSize * 2)); destination[0] = value; return memory; }
private void OnLogCallback(void* data, libvlc_log_level level, char* fmt, char* args) { try { char* buffer = stackalloc char[BUFFER_SIZE]; int len = vsprintf(buffer, fmt, args); string msg = Marshal.PtrToStringAnsi(new IntPtr(buffer), len); switch (level) { case libvlc_log_level.LIBVLC_DEBUG: m_logger.Debug(msg); break; case libvlc_log_level.LIBVLC_NOTICE: m_logger.Info(msg); break; case libvlc_log_level.LIBVLC_WARNING: m_logger.Warning(msg); break; case libvlc_log_level.LIBVLC_ERROR: default: m_logger.Error(msg); break; } } catch (Exception ex) { m_logger.Error("Failed to handle log callback, reason : " + ex.Message); } }
unsafe public ArgIterator (RuntimeArgumentHandle arglist, void *ptr) { sig = IntPtr.Zero; args = IntPtr.Zero; next_arg = num_args = 0; Setup (arglist.args, (IntPtr) ptr); }
protected uint GetProperty(string pszProperty, void* pbOutput, uint cbOutput) { uint retVal; int ntstatus = UnsafeNativeMethods.BCryptGetProperty(this, pszProperty, pbOutput, cbOutput, out retVal, dwFlags: 0); UnsafeNativeMethods.ThrowExceptionForBCryptStatus(ntstatus); return retVal; }
public static void BlockCopy(void* from, void* to, uint byteCount) { if (byteCount != 0) { BlockCopyCore((byte*)from, (byte*)to, byteCount); } }
public static int Read7BitInt (void* ptr, int* ret_len) { // Originally from Mono: mcs/class/corlib/System.IO/BinaryReader.cs // Copyright (C) 2004 Novell int ret = 0; int shift = 0; byte* bp = (byte*) ptr; byte b; do { b = *bp; ++bp; if (ret_len != null) (*ret_len)++; ret = ret | (((int) (b & 0x7f)) << shift); shift += 7; } while ((b & 0x80) == 0x80); #if VERBOSE_BinaryTool TextMode.WriteLine ("read7bit: ", ret); #endif return ret; }
public static void Append(uint* srcIn, ref void* dst) { int count = sizeof(uint*); void* src = &srcIn; Copy(src, dst, count); dst = (void*)((int)dst + count); }
public static void* BoxInt16(void* methodTable, uint classSize, short value) { byte* memory = (byte*)AllocateObject(methodTable, classSize); short* destination = (short*)(memory + (nativeIntSize * 2)); destination[0] = value; return memory; }
private unsafe int DirectInputEnumCreatedEffectsImpl(void* deviceInstance, IntPtr data) { var newEffect = new Effect((IntPtr)deviceInstance); Effects.Add(newEffect); // Return true to continue iterating return 1; }
internal unsafe TextInfo (CultureInfo ci, int lcid, void* data, bool read_only) { this.m_isReadOnly = read_only; this.m_win32LangID = lcid; this.ci = ci; if (data != null) this.data = *(Data*) data; else { this.data = new Data (); this.data.list_sep = (byte) ','; } CultureInfo tmp = ci; while (tmp.Parent != null && tmp.Parent.LCID != 0x7F && tmp.Parent != tmp) tmp = tmp.Parent; if (tmp != null) { switch (tmp.LCID) { case 44: // Azeri (az) case 31: // Turkish (tr) handleDotI = true; break; } } }
/// <summary> /// 计算32位Hash值 /// </summary> /// <param name="data">数据起始位置</param> /// <param name="length">数据长度</param> /// <returns>32位HASH值</returns> internal static unsafe int GetHashCode(void* data, int length) { if (PubPlus.MemoryBits == 64) { var value = GetHashCode64((byte*) data, length); return (int) (value ^ (value >> 32)); } // 一般编码都以字节为基本单位,也就是说基本单位长度为8bit; // 常用编码可能比较集中,造成编码中出现伪固定位(大多时候某些固定位都是同一值) // 采用移位的方式:当移位量为1或7时,一般只能覆盖掉1个固定位;当移位量为3或5时,一般能覆盖掉3个固定位;所以本程序使用的移位量为8x+5/3 // 由于64=5+59=13+3*17=3*7+43=29+5*7=37+3*3*3=5*9+19=53+11=61+3,其中(5+59),(53+11),(61+3)为素数对成为最佳移位量,本程序选择中性素数对53+11 // 由于32=5+3*3*3=13+19=3*7+11=29+3,其中(13+19),(29+3)为素数对成为最佳移位量,本程序选择中性素数对13+19 if (length >= sizeof (uint)) { var value = *(uint*) data; var start = (byte*) data; for (var end = start + (length & (int.MaxValue - sizeof (uint) + 1)); (start += sizeof (uint)) != end; value ^= *(uint*) start) { value = (value << 13) | (value >> 19); } if ((length & (sizeof (uint) - 1)) != 0) { value = (value << 13) | (value >> 19); value ^= *(uint*) start << ((sizeof (uint) - (length & (sizeof (uint) - 1))) << 3); } return (int) value ^ length; } return (int) (*(uint*) data << ((sizeof (uint) - length) << 3)) ^ length; }
private unsafe static void MyHandleCleanFunc(void* a) { GCHandle gch = GCHandle.FromIntPtr((IntPtr)a); BinaryReader br = (BinaryReader)gch.Target; br.Close(); }
private unsafe int OnFormatCallback(void** opaque, char* chroma, int* width, int* height, int* pitches, int* lines) { IntPtr pChroma = new IntPtr(chroma); string chromaStr = Marshal.PtrToStringAnsi(pChroma); ChromaType type; if (!Enum.TryParse<ChromaType>(chromaStr, out type)) { throw new ArgumentException("Unsupported chroma type " + chromaStr); } m_format = new BitmapFormat(*width, *height, type); if (m_formatSetupCB != null) { m_format = m_formatSetupCB(m_format); } Marshal.Copy(m_format.Chroma.ToUtf8(), 0, pChroma, 4); *width = m_format.Width; *height = m_format.Height; for (int i = 0; i < m_format.Planes; i++) { pitches[i] = m_format.Pitches[i]; lines[i] = m_format.Lines[i]; } m_pixelData = new PlanarPixelData(m_format.PlaneSizes); return m_format.Planes; }
private void OnLogCallback(void* data, LibvlcLogLevel level, void* ctx, char* fmt, char* args) { try { char* buffer = stackalloc char[BufferSize]; var len = vsprintf(buffer, fmt, args); var msg = Marshal.PtrToStringAnsi(new IntPtr(buffer), len); switch (level) { case LibvlcLogLevel.LibvlcDebug: _mLogger.Debug(msg); break; case LibvlcLogLevel.LibvlcNotice: _mLogger.Info(msg); break; case LibvlcLogLevel.LibvlcWarning: _mLogger.Warning(msg); break; case LibvlcLogLevel.LibvlcError: default: _mLogger.Error(msg); break; } } catch (Exception ex) { _mLogger.Error("Failed to handle log callback, reason : " + ex.Message); } }
/// <summary> /// Constructor. /// </summary> /// <param name="ctx">Context.</param> /// <param name="target">Target.</param> public UnmanagedTarget(UnmanagedContext ctx, void* target) : base(IntPtr.Zero) { _ctx = ctx; SetHandle(new IntPtr(target)); }
private unsafe UInt32 FastRead(void* src, UInt32 bytes) { UInt32 val = 0; if (BitConverter.IsLittleEndian) val = *((UInt32*)src); else { Byte* p = (Byte*)src; switch (bytes) { case 4: val = (UInt32)(*p) | (UInt32)(*(p + 1)) << 8 | (UInt32)(*(p + 2)) << 16 | (UInt32)(*(p + 3)) << 24; break; case 3: val = (UInt32)(*p) | (UInt32)(*(p + 1)) << 8 | (UInt32)(*(p + 2)) << 16; break; case 2: val = (UInt32)(*p) | (UInt32)(*(p + 1)) << 8; break; case 1: val = (UInt32)(*p); break; default: break; } } return val; }
public static unsafe int AFCDirectoryRead(void* conn, void* dir, ref string buffer) { int ret; void* ptr = null; ret = AFCDirectoryRead(conn, dir, ref ptr); if ((ret == 0) && (ptr != null)) { IntPtr ipPtr = new IntPtr(ptr); ArrayList bufferArray = new ArrayList(); int curr = 0; while (true) { byte tmpByte = Marshal.ReadByte(ipPtr, curr); if (tmpByte != 0) { bufferArray.Add(tmpByte); curr++; } else { break; } } buffer = System.Text.Encoding.UTF8.GetString((byte[])bufferArray.ToArray(typeof(byte))); } else { buffer = null; } return ret; }
internal unsafe RuntimeMethodHandle GetCallableMethod(void* module) { return new RuntimeMethodHandle(ModuleHandle.GetDynamicMethod( module, m_methodBuilder.Name, (byte[])m_scope[m_methodSigToken], new DynamicResolver(this))); }
public static unsafe int FontEngineAddTextureSync(int hasCode, bool useAlphaBlend, void* fontTexture) { lock (_lock) { return FontEngineAddTexture(hasCode, useAlphaBlend, fontTexture); } }
public static void* BoxDouble(void* methodTable, uint classSize, double value) { byte* memory = (byte*)AllocateObject(methodTable, classSize); double* destination = (double*)(memory + (nativeIntSize * 2)); destination[0] = value; return memory; }
private static extern unsafe bool ReadFile( IntPtr hFile, // handle to file void* pBuffer, // data buffer int NumberOfBytesToRead, // number of bytes to read int* pNumberOfBytesRead, // number of bytes read int Overlapped // overlapped buffer );
/// <summary> /// This function requests allocation of an array. /// </summary> /// <param name="methodTable">Pointer to the array method table.</param> /// <param name="elementSize">The size of a single element in the method table.</param> /// <param name="elements">The number of elements to allocate of the type.</param> /// <returns>A ptr to the allocated memory.</returns> /// <remarks> /// The allocated object is not constructed, e.g. the caller must invoke /// the appropriate constructor in order to obtain a real object. The object header /// has been set. /// </remarks> public static unsafe void* AllocateArray(void* methodTable, uint elementSize, uint elements) { if (elements < 0) { throw new OverflowException(); } // HACK: Add compiler architecture to the runtime uint nativeIntSize = 4; // // An array has the following memory layout: // - IntPtr MTable // - IntPtr SyncBlock // - int length // - ElementType[length] elements // uint allocationSize = (uint)(nativeIntSize + (elements * elementSize)); void* memory = AllocateObject(methodTable, allocationSize); uint* destination = (uint*)memory; Memset((byte*)(destination + 3), 0, (int)allocationSize); destination[2] = elements; return memory; }
/// <summary> /// Frees a memory block. /// </summary> /// <param name="block"></param> public static void Free(void* block) { if (!HeapFree(_ph, 0, block)) { throw new InvalidOperationException(); } }
internal void AddScalar(void* value, int size) { var pb = (byte*)value; if (this.bufferNesting == 0) { var scratchOld = this.scratch; var scratchNew = scratchOld + size; if (this.scratchEnd < scratchNew) { #if PROJECTN throw new IndexOutOfRangeException(SR.GetResourceString("EventSource_AddScalarOutOfRange", null)); #else throw new IndexOutOfRangeException(Environment.GetResourceString("EventSource_AddScalarOutOfRange")); #endif } this.ScalarsBegin(); this.scratch = scratchNew; for (int i = 0; i != size; i++) { scratchOld[i] = pb[i]; } } else { var oldPos = this.bufferPos; this.bufferPos = checked(this.bufferPos + size); this.EnsureBuffer(); for (int i = 0; i != size; i++, oldPos++) { this.buffer[oldPos] = pb[i]; } } }
private static RuntimeTypeHandle GetTypeHandle(void* obj) { // TypeDefinition is located at the beginning of object (i.e. *obj ) RuntimeTypeHandle handle = new RuntimeTypeHandle(); ((uint*)&handle)[0] = ((uint*)obj)[0]; return handle; }
/// <summary> /// Reads structure from the input stream preserving its endianess. /// </summary> /// <param name="reader"></param> /// <param name="pStruct"></param> /// <param name="len"></param> unsafe internal static void ReadStruct(BinaryReader reader, void* pStruct, int len) { byte* p = (byte*) pStruct; if (System.BitConverter.IsLittleEndian) { // On a little-endian machine read data in 64-bit chunks, // this won't work on big-endian machine because // BinaryReader APIs are little-endian while // memory writes are platform-native. // This seems faster than ReadBytes/Copy method // in the "else" clause, especially if used often // (no extra memory allocation for byte[]?). int whole = len >> 3; int rem = len & 7; for (int i = whole; --i >= 0;) { long qw = reader.ReadInt64(); Marshal.WriteInt64((IntPtr) p, qw); p += sizeof (long); } for (int i = rem; --i >= 0;) { *p++ = (byte) reader.ReadByte(); } } else { byte [] buff = reader.ReadBytes(len); Marshal.Copy(buff, 0, (IntPtr) p, len); } }
unsafe public static Object Box(void* ptr, Type type) { Contract.Ensures(Contract.Result<System.Object>() != null); Contract.Ensures(type.IsPointer == true); return default(Object); }