mirror of
https://github.com/goatcorp/Dalamud.git
synced 2025-12-12 10:17:22 +01:00
5047 lines
117 KiB
C#
5047 lines
117 KiB
C#
// ------------------------------------------------------------------------------
|
|
// <auto-generated>
|
|
// This code was generated by a tool.
|
|
//
|
|
// Changes to this file may cause incorrect behavior and will be lost if
|
|
// the code is regenerated.
|
|
// </auto-generated>
|
|
// ------------------------------------------------------------------------------
|
|
|
|
using System;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Runtime.InteropServices;
|
|
using HexaGen.Runtime;
|
|
using System.Numerics;
|
|
|
|
namespace Dalamud.Bindings.ImGui
|
|
{
|
|
public unsafe partial class ImGuiP
|
|
{
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static uint ImHashDataNative(void* data, ulong dataSize, uint seed)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
return ((delegate* unmanaged[Cdecl]<void*, ulong, uint, uint>)funcTable[691])(data, dataSize, seed);
|
|
#else
|
|
return (uint)((delegate* unmanaged[Cdecl]<nint, ulong, uint, uint>)funcTable[691])((nint)data, dataSize, seed);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static uint ImHashData(void* data, ulong dataSize, uint seed)
|
|
{
|
|
uint ret = ImHashDataNative(data, dataSize, seed);
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static uint ImHashData(void* data, ulong dataSize)
|
|
{
|
|
uint ret = ImHashDataNative(data, dataSize, (uint)(0));
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static uint ImHashData(void* data, nuint dataSize, uint seed)
|
|
{
|
|
uint ret = ImHashDataNative(data, dataSize, seed);
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static uint ImHashData(void* data, nuint dataSize)
|
|
{
|
|
uint ret = ImHashDataNative(data, dataSize, (uint)(0));
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static uint ImHashStrNative(byte* data, ulong dataSize, uint seed)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
return ((delegate* unmanaged[Cdecl]<byte*, ulong, uint, uint>)funcTable[692])(data, dataSize, seed);
|
|
#else
|
|
return (uint)((delegate* unmanaged[Cdecl]<nint, ulong, uint, uint>)funcTable[692])((nint)data, dataSize, seed);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static uint ImHashStr(byte* data, ulong dataSize, uint seed)
|
|
{
|
|
uint ret = ImHashStrNative(data, dataSize, seed);
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static uint ImHashStr(byte* data, ulong dataSize)
|
|
{
|
|
uint ret = ImHashStrNative(data, dataSize, (uint)(0));
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static uint ImHashStr(byte* data)
|
|
{
|
|
uint ret = ImHashStrNative(data, (ulong)(0), (uint)(0));
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static uint ImHashStr(byte* data, uint seed)
|
|
{
|
|
uint ret = ImHashStrNative(data, (ulong)(0), seed);
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static uint ImHashStr(ref byte data, ulong dataSize, uint seed)
|
|
{
|
|
fixed (byte* pdata = &data)
|
|
{
|
|
uint ret = ImHashStrNative((byte*)pdata, dataSize, seed);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static uint ImHashStr(ref byte data, ulong dataSize)
|
|
{
|
|
fixed (byte* pdata = &data)
|
|
{
|
|
uint ret = ImHashStrNative((byte*)pdata, dataSize, (uint)(0));
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static uint ImHashStr(ref byte data)
|
|
{
|
|
fixed (byte* pdata = &data)
|
|
{
|
|
uint ret = ImHashStrNative((byte*)pdata, (ulong)(0), (uint)(0));
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static uint ImHashStr(ref byte data, uint seed)
|
|
{
|
|
fixed (byte* pdata = &data)
|
|
{
|
|
uint ret = ImHashStrNative((byte*)pdata, (ulong)(0), seed);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static uint ImHashStr(ReadOnlySpan<byte> data, ulong dataSize, uint seed)
|
|
{
|
|
fixed (byte* pdata = data)
|
|
{
|
|
uint ret = ImHashStrNative((byte*)pdata, dataSize, seed);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static uint ImHashStr(ReadOnlySpan<byte> data, ulong dataSize)
|
|
{
|
|
fixed (byte* pdata = data)
|
|
{
|
|
uint ret = ImHashStrNative((byte*)pdata, dataSize, (uint)(0));
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static uint ImHashStr(ReadOnlySpan<byte> data)
|
|
{
|
|
fixed (byte* pdata = data)
|
|
{
|
|
uint ret = ImHashStrNative((byte*)pdata, (ulong)(0), (uint)(0));
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static uint ImHashStr(ReadOnlySpan<byte> data, uint seed)
|
|
{
|
|
fixed (byte* pdata = data)
|
|
{
|
|
uint ret = ImHashStrNative((byte*)pdata, (ulong)(0), seed);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static uint ImHashStr(string data, ulong dataSize, uint seed)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (data != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(data);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(data, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
uint ret = ImHashStrNative(pStr0, dataSize, seed);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static uint ImHashStr(string data, ulong dataSize)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (data != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(data);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(data, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
uint ret = ImHashStrNative(pStr0, dataSize, (uint)(0));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static uint ImHashStr(string data)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (data != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(data);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(data, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
uint ret = ImHashStrNative(pStr0, (ulong)(0), (uint)(0));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static uint ImHashStr(string data, uint seed)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (data != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(data);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(data, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
uint ret = ImHashStrNative(pStr0, (ulong)(0), seed);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static uint ImHashStr(byte* data, nuint dataSize, uint seed)
|
|
{
|
|
uint ret = ImHashStrNative(data, dataSize, seed);
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static uint ImHashStr(byte* data, nuint dataSize)
|
|
{
|
|
uint ret = ImHashStrNative(data, dataSize, (uint)(0));
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static uint ImHashStr(ref byte data, nuint dataSize, uint seed)
|
|
{
|
|
fixed (byte* pdata = &data)
|
|
{
|
|
uint ret = ImHashStrNative((byte*)pdata, dataSize, seed);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static uint ImHashStr(ref byte data, nuint dataSize)
|
|
{
|
|
fixed (byte* pdata = &data)
|
|
{
|
|
uint ret = ImHashStrNative((byte*)pdata, dataSize, (uint)(0));
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static uint ImHashStr(ReadOnlySpan<byte> data, nuint dataSize, uint seed)
|
|
{
|
|
fixed (byte* pdata = data)
|
|
{
|
|
uint ret = ImHashStrNative((byte*)pdata, dataSize, seed);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static uint ImHashStr(ReadOnlySpan<byte> data, nuint dataSize)
|
|
{
|
|
fixed (byte* pdata = data)
|
|
{
|
|
uint ret = ImHashStrNative((byte*)pdata, dataSize, (uint)(0));
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static uint ImHashStr(string data, nuint dataSize, uint seed)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (data != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(data);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(data, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
uint ret = ImHashStrNative(pStr0, dataSize, seed);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static uint ImHashStr(string data, nuint dataSize)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (data != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(data);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(data, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
uint ret = ImHashStrNative(pStr0, dataSize, (uint)(0));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void ImQsortNative(void* baseValue, ulong count, ulong sizeOfElement, delegate*<void*, ulong, ulong, delegate*<void*, void*, int>, int> compareFunc)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<void*, ulong, ulong, delegate*<void*, ulong, ulong, delegate*<void*, void*, int>, int>, void>)funcTable[693])(baseValue, count, sizeOfElement, compareFunc);
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<nint, ulong, ulong, nint, void>)funcTable[693])((nint)baseValue, count, sizeOfElement, (nint)compareFunc);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void ImQsort(void* baseValue, ulong count, ulong sizeOfElement, delegate*<void*, ulong, ulong, delegate*<void*, void*, int>, int> compareFunc)
|
|
{
|
|
ImQsortNative(baseValue, count, sizeOfElement, compareFunc);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void ImQsort(void* baseValue, nuint count, ulong sizeOfElement, delegate*<void*, ulong, ulong, delegate*<void*, void*, int>, int> compareFunc)
|
|
{
|
|
ImQsortNative(baseValue, count, sizeOfElement, compareFunc);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void ImQsort(void* baseValue, ulong count, nuint sizeOfElement, delegate*<void*, ulong, ulong, delegate*<void*, void*, int>, int> compareFunc)
|
|
{
|
|
ImQsortNative(baseValue, count, sizeOfElement, compareFunc);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void ImQsort(void* baseValue, nuint count, nuint sizeOfElement, delegate*<void*, ulong, ulong, delegate*<void*, void*, int>, int> compareFunc)
|
|
{
|
|
ImQsortNative(baseValue, count, sizeOfElement, compareFunc);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static uint ImAlphaBlendColorsNative(uint colA, uint colB)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
return ((delegate* unmanaged[Cdecl]<uint, uint, uint>)funcTable[694])(colA, colB);
|
|
#else
|
|
return (uint)((delegate* unmanaged[Cdecl]<uint, uint, uint>)funcTable[694])(colA, colB);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static uint ImAlphaBlendColors(uint colA, uint colB)
|
|
{
|
|
uint ret = ImAlphaBlendColorsNative(colA, colB);
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static byte ImIsPowerOfTwoNative(int v)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
return ((delegate* unmanaged[Cdecl]<int, byte>)funcTable[695])(v);
|
|
#else
|
|
return (byte)((delegate* unmanaged[Cdecl]<int, byte>)funcTable[695])(v);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool ImIsPowerOfTwo(int v)
|
|
{
|
|
byte ret = ImIsPowerOfTwoNative(v);
|
|
return ret != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static byte ImIsPowerOfTwoNative(ulong v)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
return ((delegate* unmanaged[Cdecl]<ulong, byte>)funcTable[696])(v);
|
|
#else
|
|
return (byte)((delegate* unmanaged[Cdecl]<ulong, byte>)funcTable[696])(v);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static bool ImIsPowerOfTwo(ulong v)
|
|
{
|
|
byte ret = ImIsPowerOfTwoNative(v);
|
|
return ret != 0;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static int ImUpperPowerOfTwoNative(int v)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
return ((delegate* unmanaged[Cdecl]<int, int>)funcTable[697])(v);
|
|
#else
|
|
return (int)((delegate* unmanaged[Cdecl]<int, int>)funcTable[697])(v);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImUpperPowerOfTwo(int v)
|
|
{
|
|
int ret = ImUpperPowerOfTwoNative(v);
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static int ImStricmpNative(byte* str1, byte* str2)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
return ((delegate* unmanaged[Cdecl]<byte*, byte*, int>)funcTable[698])(str1, str2);
|
|
#else
|
|
return (int)((delegate* unmanaged[Cdecl]<nint, nint, int>)funcTable[698])((nint)str1, (nint)str2);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStricmp(byte* str1, byte* str2)
|
|
{
|
|
int ret = ImStricmpNative(str1, str2);
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStricmp(ref byte str1, byte* str2)
|
|
{
|
|
fixed (byte* pstr1 = &str1)
|
|
{
|
|
int ret = ImStricmpNative((byte*)pstr1, str2);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStricmp(ReadOnlySpan<byte> str1, byte* str2)
|
|
{
|
|
fixed (byte* pstr1 = str1)
|
|
{
|
|
int ret = ImStricmpNative((byte*)pstr1, str2);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStricmp(string str1, byte* str2)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str1 != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str1);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str1, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
int ret = ImStricmpNative(pStr0, str2);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStricmp(byte* str1, ref byte str2)
|
|
{
|
|
fixed (byte* pstr2 = &str2)
|
|
{
|
|
int ret = ImStricmpNative(str1, (byte*)pstr2);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStricmp(byte* str1, ReadOnlySpan<byte> str2)
|
|
{
|
|
fixed (byte* pstr2 = str2)
|
|
{
|
|
int ret = ImStricmpNative(str1, (byte*)pstr2);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStricmp(byte* str1, string str2)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str2 != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str2);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str2, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
int ret = ImStricmpNative(str1, pStr0);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStricmp(ref byte str1, ref byte str2)
|
|
{
|
|
fixed (byte* pstr1 = &str1)
|
|
{
|
|
fixed (byte* pstr2 = &str2)
|
|
{
|
|
int ret = ImStricmpNative((byte*)pstr1, (byte*)pstr2);
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStricmp(ReadOnlySpan<byte> str1, ReadOnlySpan<byte> str2)
|
|
{
|
|
fixed (byte* pstr1 = str1)
|
|
{
|
|
fixed (byte* pstr2 = str2)
|
|
{
|
|
int ret = ImStricmpNative((byte*)pstr1, (byte*)pstr2);
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStricmp(string str1, string str2)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str1 != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str1);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str1, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
byte* pStr1 = null;
|
|
int pStrSize1 = 0;
|
|
if (str2 != null)
|
|
{
|
|
pStrSize1 = Utils.GetByteCountUTF8(str2);
|
|
if (pStrSize1 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr1 = Utils.Alloc<byte>(pStrSize1 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack1 = stackalloc byte[pStrSize1 + 1];
|
|
pStr1 = pStrStack1;
|
|
}
|
|
int pStrOffset1 = Utils.EncodeStringUTF8(str2, pStr1, pStrSize1);
|
|
pStr1[pStrOffset1] = 0;
|
|
}
|
|
int ret = ImStricmpNative(pStr0, pStr1);
|
|
if (pStrSize1 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr1);
|
|
}
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStricmp(ref byte str1, ReadOnlySpan<byte> str2)
|
|
{
|
|
fixed (byte* pstr1 = &str1)
|
|
{
|
|
fixed (byte* pstr2 = str2)
|
|
{
|
|
int ret = ImStricmpNative((byte*)pstr1, (byte*)pstr2);
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStricmp(ref byte str1, string str2)
|
|
{
|
|
fixed (byte* pstr1 = &str1)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str2 != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str2);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str2, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
int ret = ImStricmpNative((byte*)pstr1, pStr0);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStricmp(ReadOnlySpan<byte> str1, ref byte str2)
|
|
{
|
|
fixed (byte* pstr1 = str1)
|
|
{
|
|
fixed (byte* pstr2 = &str2)
|
|
{
|
|
int ret = ImStricmpNative((byte*)pstr1, (byte*)pstr2);
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStricmp(ReadOnlySpan<byte> str1, string str2)
|
|
{
|
|
fixed (byte* pstr1 = str1)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str2 != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str2);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str2, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
int ret = ImStricmpNative((byte*)pstr1, pStr0);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStricmp(string str1, ref byte str2)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str1 != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str1);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str1, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
fixed (byte* pstr2 = &str2)
|
|
{
|
|
int ret = ImStricmpNative(pStr0, (byte*)pstr2);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStricmp(string str1, ReadOnlySpan<byte> str2)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str1 != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str1);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str1, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
fixed (byte* pstr2 = str2)
|
|
{
|
|
int ret = ImStricmpNative(pStr0, (byte*)pstr2);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static int ImStrnicmpNative(byte* str1, byte* str2, ulong count)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
return ((delegate* unmanaged[Cdecl]<byte*, byte*, ulong, int>)funcTable[699])(str1, str2, count);
|
|
#else
|
|
return (int)((delegate* unmanaged[Cdecl]<nint, nint, ulong, int>)funcTable[699])((nint)str1, (nint)str2, count);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStrnicmp(byte* str1, byte* str2, ulong count)
|
|
{
|
|
int ret = ImStrnicmpNative(str1, str2, count);
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStrnicmp(ref byte str1, byte* str2, ulong count)
|
|
{
|
|
fixed (byte* pstr1 = &str1)
|
|
{
|
|
int ret = ImStrnicmpNative((byte*)pstr1, str2, count);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStrnicmp(ReadOnlySpan<byte> str1, byte* str2, ulong count)
|
|
{
|
|
fixed (byte* pstr1 = str1)
|
|
{
|
|
int ret = ImStrnicmpNative((byte*)pstr1, str2, count);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStrnicmp(string str1, byte* str2, ulong count)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str1 != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str1);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str1, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
int ret = ImStrnicmpNative(pStr0, str2, count);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStrnicmp(byte* str1, ref byte str2, ulong count)
|
|
{
|
|
fixed (byte* pstr2 = &str2)
|
|
{
|
|
int ret = ImStrnicmpNative(str1, (byte*)pstr2, count);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStrnicmp(byte* str1, ReadOnlySpan<byte> str2, ulong count)
|
|
{
|
|
fixed (byte* pstr2 = str2)
|
|
{
|
|
int ret = ImStrnicmpNative(str1, (byte*)pstr2, count);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStrnicmp(byte* str1, string str2, ulong count)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str2 != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str2);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str2, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
int ret = ImStrnicmpNative(str1, pStr0, count);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStrnicmp(ref byte str1, ref byte str2, ulong count)
|
|
{
|
|
fixed (byte* pstr1 = &str1)
|
|
{
|
|
fixed (byte* pstr2 = &str2)
|
|
{
|
|
int ret = ImStrnicmpNative((byte*)pstr1, (byte*)pstr2, count);
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStrnicmp(ReadOnlySpan<byte> str1, ReadOnlySpan<byte> str2, ulong count)
|
|
{
|
|
fixed (byte* pstr1 = str1)
|
|
{
|
|
fixed (byte* pstr2 = str2)
|
|
{
|
|
int ret = ImStrnicmpNative((byte*)pstr1, (byte*)pstr2, count);
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStrnicmp(string str1, string str2, ulong count)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str1 != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str1);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str1, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
byte* pStr1 = null;
|
|
int pStrSize1 = 0;
|
|
if (str2 != null)
|
|
{
|
|
pStrSize1 = Utils.GetByteCountUTF8(str2);
|
|
if (pStrSize1 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr1 = Utils.Alloc<byte>(pStrSize1 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack1 = stackalloc byte[pStrSize1 + 1];
|
|
pStr1 = pStrStack1;
|
|
}
|
|
int pStrOffset1 = Utils.EncodeStringUTF8(str2, pStr1, pStrSize1);
|
|
pStr1[pStrOffset1] = 0;
|
|
}
|
|
int ret = ImStrnicmpNative(pStr0, pStr1, count);
|
|
if (pStrSize1 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr1);
|
|
}
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStrnicmp(ref byte str1, ReadOnlySpan<byte> str2, ulong count)
|
|
{
|
|
fixed (byte* pstr1 = &str1)
|
|
{
|
|
fixed (byte* pstr2 = str2)
|
|
{
|
|
int ret = ImStrnicmpNative((byte*)pstr1, (byte*)pstr2, count);
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStrnicmp(ref byte str1, string str2, ulong count)
|
|
{
|
|
fixed (byte* pstr1 = &str1)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str2 != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str2);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str2, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
int ret = ImStrnicmpNative((byte*)pstr1, pStr0, count);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStrnicmp(ReadOnlySpan<byte> str1, ref byte str2, ulong count)
|
|
{
|
|
fixed (byte* pstr1 = str1)
|
|
{
|
|
fixed (byte* pstr2 = &str2)
|
|
{
|
|
int ret = ImStrnicmpNative((byte*)pstr1, (byte*)pstr2, count);
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStrnicmp(ReadOnlySpan<byte> str1, string str2, ulong count)
|
|
{
|
|
fixed (byte* pstr1 = str1)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str2 != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str2);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str2, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
int ret = ImStrnicmpNative((byte*)pstr1, pStr0, count);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStrnicmp(string str1, ref byte str2, ulong count)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str1 != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str1);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str1, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
fixed (byte* pstr2 = &str2)
|
|
{
|
|
int ret = ImStrnicmpNative(pStr0, (byte*)pstr2, count);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStrnicmp(string str1, ReadOnlySpan<byte> str2, ulong count)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str1 != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str1);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str1, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
fixed (byte* pstr2 = str2)
|
|
{
|
|
int ret = ImStrnicmpNative(pStr0, (byte*)pstr2, count);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStrnicmp(byte* str1, byte* str2, nuint count)
|
|
{
|
|
int ret = ImStrnicmpNative(str1, str2, count);
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStrnicmp(ref byte str1, byte* str2, nuint count)
|
|
{
|
|
fixed (byte* pstr1 = &str1)
|
|
{
|
|
int ret = ImStrnicmpNative((byte*)pstr1, str2, count);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStrnicmp(ReadOnlySpan<byte> str1, byte* str2, nuint count)
|
|
{
|
|
fixed (byte* pstr1 = str1)
|
|
{
|
|
int ret = ImStrnicmpNative((byte*)pstr1, str2, count);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStrnicmp(string str1, byte* str2, nuint count)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str1 != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str1);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str1, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
int ret = ImStrnicmpNative(pStr0, str2, count);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStrnicmp(byte* str1, ref byte str2, nuint count)
|
|
{
|
|
fixed (byte* pstr2 = &str2)
|
|
{
|
|
int ret = ImStrnicmpNative(str1, (byte*)pstr2, count);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStrnicmp(byte* str1, ReadOnlySpan<byte> str2, nuint count)
|
|
{
|
|
fixed (byte* pstr2 = str2)
|
|
{
|
|
int ret = ImStrnicmpNative(str1, (byte*)pstr2, count);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStrnicmp(byte* str1, string str2, nuint count)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str2 != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str2);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str2, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
int ret = ImStrnicmpNative(str1, pStr0, count);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStrnicmp(ref byte str1, ref byte str2, nuint count)
|
|
{
|
|
fixed (byte* pstr1 = &str1)
|
|
{
|
|
fixed (byte* pstr2 = &str2)
|
|
{
|
|
int ret = ImStrnicmpNative((byte*)pstr1, (byte*)pstr2, count);
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStrnicmp(ReadOnlySpan<byte> str1, ReadOnlySpan<byte> str2, nuint count)
|
|
{
|
|
fixed (byte* pstr1 = str1)
|
|
{
|
|
fixed (byte* pstr2 = str2)
|
|
{
|
|
int ret = ImStrnicmpNative((byte*)pstr1, (byte*)pstr2, count);
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStrnicmp(string str1, string str2, nuint count)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str1 != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str1);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str1, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
byte* pStr1 = null;
|
|
int pStrSize1 = 0;
|
|
if (str2 != null)
|
|
{
|
|
pStrSize1 = Utils.GetByteCountUTF8(str2);
|
|
if (pStrSize1 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr1 = Utils.Alloc<byte>(pStrSize1 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack1 = stackalloc byte[pStrSize1 + 1];
|
|
pStr1 = pStrStack1;
|
|
}
|
|
int pStrOffset1 = Utils.EncodeStringUTF8(str2, pStr1, pStrSize1);
|
|
pStr1[pStrOffset1] = 0;
|
|
}
|
|
int ret = ImStrnicmpNative(pStr0, pStr1, count);
|
|
if (pStrSize1 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr1);
|
|
}
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStrnicmp(ref byte str1, ReadOnlySpan<byte> str2, nuint count)
|
|
{
|
|
fixed (byte* pstr1 = &str1)
|
|
{
|
|
fixed (byte* pstr2 = str2)
|
|
{
|
|
int ret = ImStrnicmpNative((byte*)pstr1, (byte*)pstr2, count);
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStrnicmp(ref byte str1, string str2, nuint count)
|
|
{
|
|
fixed (byte* pstr1 = &str1)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str2 != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str2);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str2, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
int ret = ImStrnicmpNative((byte*)pstr1, pStr0, count);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStrnicmp(ReadOnlySpan<byte> str1, ref byte str2, nuint count)
|
|
{
|
|
fixed (byte* pstr1 = str1)
|
|
{
|
|
fixed (byte* pstr2 = &str2)
|
|
{
|
|
int ret = ImStrnicmpNative((byte*)pstr1, (byte*)pstr2, count);
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStrnicmp(ReadOnlySpan<byte> str1, string str2, nuint count)
|
|
{
|
|
fixed (byte* pstr1 = str1)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str2 != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str2);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str2, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
int ret = ImStrnicmpNative((byte*)pstr1, pStr0, count);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStrnicmp(string str1, ref byte str2, nuint count)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str1 != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str1);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str1, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
fixed (byte* pstr2 = &str2)
|
|
{
|
|
int ret = ImStrnicmpNative(pStr0, (byte*)pstr2, count);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStrnicmp(string str1, ReadOnlySpan<byte> str2, nuint count)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str1 != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str1);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str1, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
fixed (byte* pstr2 = str2)
|
|
{
|
|
int ret = ImStrnicmpNative(pStr0, (byte*)pstr2, count);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static void ImStrncpyNative(byte* dst, byte* src, ulong count)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
((delegate* unmanaged[Cdecl]<byte*, byte*, ulong, void>)funcTable[700])(dst, src, count);
|
|
#else
|
|
((delegate* unmanaged[Cdecl]<nint, nint, ulong, void>)funcTable[700])((nint)dst, (nint)src, count);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void ImStrncpy(byte* dst, byte* src, ulong count)
|
|
{
|
|
ImStrncpyNative(dst, src, count);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void ImStrncpy(ref byte dst, byte* src, ulong count)
|
|
{
|
|
fixed (byte* pdst = &dst)
|
|
{
|
|
ImStrncpyNative((byte*)pdst, src, count);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void ImStrncpy(ref string dst, byte* src, ulong count)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (dst != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(dst);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(dst, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
ImStrncpyNative(pStr0, src, count);
|
|
dst = Utils.DecodeStringUTF8(pStr0);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void ImStrncpy(byte* dst, ref byte src, ulong count)
|
|
{
|
|
fixed (byte* psrc = &src)
|
|
{
|
|
ImStrncpyNative(dst, (byte*)psrc, count);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void ImStrncpy(byte* dst, ReadOnlySpan<byte> src, ulong count)
|
|
{
|
|
fixed (byte* psrc = src)
|
|
{
|
|
ImStrncpyNative(dst, (byte*)psrc, count);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void ImStrncpy(byte* dst, string src, ulong count)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (src != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(src);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(src, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
ImStrncpyNative(dst, pStr0, count);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void ImStrncpy(ref byte dst, ref byte src, ulong count)
|
|
{
|
|
fixed (byte* pdst = &dst)
|
|
{
|
|
fixed (byte* psrc = &src)
|
|
{
|
|
ImStrncpyNative((byte*)pdst, (byte*)psrc, count);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void ImStrncpy(ref byte dst, ReadOnlySpan<byte> src, ulong count)
|
|
{
|
|
fixed (byte* pdst = &dst)
|
|
{
|
|
fixed (byte* psrc = src)
|
|
{
|
|
ImStrncpyNative((byte*)pdst, (byte*)psrc, count);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void ImStrncpy(ref string dst, string src, ulong count)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (dst != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(dst);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(dst, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
byte* pStr1 = null;
|
|
int pStrSize1 = 0;
|
|
if (src != null)
|
|
{
|
|
pStrSize1 = Utils.GetByteCountUTF8(src);
|
|
if (pStrSize1 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr1 = Utils.Alloc<byte>(pStrSize1 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack1 = stackalloc byte[pStrSize1 + 1];
|
|
pStr1 = pStrStack1;
|
|
}
|
|
int pStrOffset1 = Utils.EncodeStringUTF8(src, pStr1, pStrSize1);
|
|
pStr1[pStrOffset1] = 0;
|
|
}
|
|
ImStrncpyNative(pStr0, pStr1, count);
|
|
dst = Utils.DecodeStringUTF8(pStr0);
|
|
if (pStrSize1 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr1);
|
|
}
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void ImStrncpy(ref byte dst, string src, ulong count)
|
|
{
|
|
fixed (byte* pdst = &dst)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (src != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(src);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(src, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
ImStrncpyNative((byte*)pdst, pStr0, count);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void ImStrncpy(ref string dst, ref byte src, ulong count)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (dst != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(dst);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(dst, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
fixed (byte* psrc = &src)
|
|
{
|
|
ImStrncpyNative(pStr0, (byte*)psrc, count);
|
|
dst = Utils.DecodeStringUTF8(pStr0);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void ImStrncpy(ref string dst, ReadOnlySpan<byte> src, ulong count)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (dst != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(dst);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(dst, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
fixed (byte* psrc = src)
|
|
{
|
|
ImStrncpyNative(pStr0, (byte*)psrc, count);
|
|
dst = Utils.DecodeStringUTF8(pStr0);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void ImStrncpy(byte* dst, byte* src, nuint count)
|
|
{
|
|
ImStrncpyNative(dst, src, count);
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void ImStrncpy(ref byte dst, byte* src, nuint count)
|
|
{
|
|
fixed (byte* pdst = &dst)
|
|
{
|
|
ImStrncpyNative((byte*)pdst, src, count);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void ImStrncpy(ref string dst, byte* src, nuint count)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (dst != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(dst);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(dst, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
ImStrncpyNative(pStr0, src, count);
|
|
dst = Utils.DecodeStringUTF8(pStr0);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void ImStrncpy(byte* dst, ref byte src, nuint count)
|
|
{
|
|
fixed (byte* psrc = &src)
|
|
{
|
|
ImStrncpyNative(dst, (byte*)psrc, count);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void ImStrncpy(byte* dst, ReadOnlySpan<byte> src, nuint count)
|
|
{
|
|
fixed (byte* psrc = src)
|
|
{
|
|
ImStrncpyNative(dst, (byte*)psrc, count);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void ImStrncpy(byte* dst, string src, nuint count)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (src != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(src);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(src, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
ImStrncpyNative(dst, pStr0, count);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void ImStrncpy(ref byte dst, ref byte src, nuint count)
|
|
{
|
|
fixed (byte* pdst = &dst)
|
|
{
|
|
fixed (byte* psrc = &src)
|
|
{
|
|
ImStrncpyNative((byte*)pdst, (byte*)psrc, count);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void ImStrncpy(ref byte dst, ReadOnlySpan<byte> src, nuint count)
|
|
{
|
|
fixed (byte* pdst = &dst)
|
|
{
|
|
fixed (byte* psrc = src)
|
|
{
|
|
ImStrncpyNative((byte*)pdst, (byte*)psrc, count);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void ImStrncpy(ref string dst, string src, nuint count)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (dst != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(dst);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(dst, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
byte* pStr1 = null;
|
|
int pStrSize1 = 0;
|
|
if (src != null)
|
|
{
|
|
pStrSize1 = Utils.GetByteCountUTF8(src);
|
|
if (pStrSize1 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr1 = Utils.Alloc<byte>(pStrSize1 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack1 = stackalloc byte[pStrSize1 + 1];
|
|
pStr1 = pStrStack1;
|
|
}
|
|
int pStrOffset1 = Utils.EncodeStringUTF8(src, pStr1, pStrSize1);
|
|
pStr1[pStrOffset1] = 0;
|
|
}
|
|
ImStrncpyNative(pStr0, pStr1, count);
|
|
dst = Utils.DecodeStringUTF8(pStr0);
|
|
if (pStrSize1 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr1);
|
|
}
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void ImStrncpy(ref byte dst, string src, nuint count)
|
|
{
|
|
fixed (byte* pdst = &dst)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (src != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(src);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(src, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
ImStrncpyNative((byte*)pdst, pStr0, count);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void ImStrncpy(ref string dst, ref byte src, nuint count)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (dst != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(dst);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(dst, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
fixed (byte* psrc = &src)
|
|
{
|
|
ImStrncpyNative(pStr0, (byte*)psrc, count);
|
|
dst = Utils.DecodeStringUTF8(pStr0);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static void ImStrncpy(ref string dst, ReadOnlySpan<byte> src, nuint count)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (dst != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(dst);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(dst, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
fixed (byte* psrc = src)
|
|
{
|
|
ImStrncpyNative(pStr0, (byte*)psrc, count);
|
|
dst = Utils.DecodeStringUTF8(pStr0);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static byte* ImStrdupNative(byte* str)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
return ((delegate* unmanaged[Cdecl]<byte*, byte*>)funcTable[701])(str);
|
|
#else
|
|
return (byte*)((delegate* unmanaged[Cdecl]<nint, nint>)funcTable[701])((nint)str);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrdup(byte* str)
|
|
{
|
|
byte* ret = ImStrdupNative(str);
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrdupS(byte* str)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStrdupNative(str));
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrdup(ref byte str)
|
|
{
|
|
fixed (byte* pstr = &str)
|
|
{
|
|
byte* ret = ImStrdupNative((byte*)pstr);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrdupS(ref byte str)
|
|
{
|
|
fixed (byte* pstr = &str)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStrdupNative((byte*)pstr));
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrdup(ReadOnlySpan<byte> str)
|
|
{
|
|
fixed (byte* pstr = str)
|
|
{
|
|
byte* ret = ImStrdupNative((byte*)pstr);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrdupS(ReadOnlySpan<byte> str)
|
|
{
|
|
fixed (byte* pstr = str)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStrdupNative((byte*)pstr));
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrdup(string str)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
byte* ret = ImStrdupNative(pStr0);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrdupS(string str)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
string ret = Utils.DecodeStringUTF8(ImStrdupNative(pStr0));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static byte* ImStrdupcpyNative(byte* dst, ulong* pDstSize, byte* str)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
return ((delegate* unmanaged[Cdecl]<byte*, ulong*, byte*, byte*>)funcTable[702])(dst, pDstSize, str);
|
|
#else
|
|
return (byte*)((delegate* unmanaged[Cdecl]<nint, nint, nint, nint>)funcTable[702])((nint)dst, (nint)pDstSize, (nint)str);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrdupcpy(byte* dst, ulong* pDstSize, byte* str)
|
|
{
|
|
byte* ret = ImStrdupcpyNative(dst, pDstSize, str);
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrdupcpyS(byte* dst, ulong* pDstSize, byte* str)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStrdupcpyNative(dst, pDstSize, str));
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrdupcpy(ref byte dst, ulong* pDstSize, byte* str)
|
|
{
|
|
fixed (byte* pdst = &dst)
|
|
{
|
|
byte* ret = ImStrdupcpyNative((byte*)pdst, pDstSize, str);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrdupcpyS(ref byte dst, ulong* pDstSize, byte* str)
|
|
{
|
|
fixed (byte* pdst = &dst)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStrdupcpyNative((byte*)pdst, pDstSize, str));
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrdupcpy(ref string dst, ulong* pDstSize, byte* str)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (dst != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(dst);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(dst, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
byte* ret = ImStrdupcpyNative(pStr0, pDstSize, str);
|
|
dst = Utils.DecodeStringUTF8(pStr0);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrdupcpyS(ref string dst, ulong* pDstSize, byte* str)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (dst != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(dst);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(dst, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
string ret = Utils.DecodeStringUTF8(ImStrdupcpyNative(pStr0, pDstSize, str));
|
|
dst = Utils.DecodeStringUTF8(pStr0);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrdupcpy(byte* dst, ref nuint pDstSize, byte* str)
|
|
{
|
|
fixed (nuint* ppDstSize = &pDstSize)
|
|
{
|
|
byte* ret = ImStrdupcpyNative(dst, (ulong*)ppDstSize, str);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrdupcpyS(byte* dst, ref nuint pDstSize, byte* str)
|
|
{
|
|
fixed (nuint* ppDstSize = &pDstSize)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStrdupcpyNative(dst, (ulong*)ppDstSize, str));
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrdupcpy(ref byte dst, ref nuint pDstSize, byte* str)
|
|
{
|
|
fixed (byte* pdst = &dst)
|
|
{
|
|
fixed (nuint* ppDstSize = &pDstSize)
|
|
{
|
|
byte* ret = ImStrdupcpyNative((byte*)pdst, (ulong*)ppDstSize, str);
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrdupcpyS(ref byte dst, ref nuint pDstSize, byte* str)
|
|
{
|
|
fixed (byte* pdst = &dst)
|
|
{
|
|
fixed (nuint* ppDstSize = &pDstSize)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStrdupcpyNative((byte*)pdst, (ulong*)ppDstSize, str));
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrdupcpy(ref string dst, ref nuint pDstSize, byte* str)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (dst != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(dst);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(dst, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
fixed (nuint* ppDstSize = &pDstSize)
|
|
{
|
|
byte* ret = ImStrdupcpyNative(pStr0, (ulong*)ppDstSize, str);
|
|
dst = Utils.DecodeStringUTF8(pStr0);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrdupcpyS(ref string dst, ref nuint pDstSize, byte* str)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (dst != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(dst);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(dst, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
fixed (nuint* ppDstSize = &pDstSize)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStrdupcpyNative(pStr0, (ulong*)ppDstSize, str));
|
|
dst = Utils.DecodeStringUTF8(pStr0);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrdupcpy(byte* dst, ulong* pDstSize, ref byte str)
|
|
{
|
|
fixed (byte* pstr = &str)
|
|
{
|
|
byte* ret = ImStrdupcpyNative(dst, pDstSize, (byte*)pstr);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrdupcpyS(byte* dst, ulong* pDstSize, ref byte str)
|
|
{
|
|
fixed (byte* pstr = &str)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStrdupcpyNative(dst, pDstSize, (byte*)pstr));
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrdupcpy(byte* dst, ulong* pDstSize, ReadOnlySpan<byte> str)
|
|
{
|
|
fixed (byte* pstr = str)
|
|
{
|
|
byte* ret = ImStrdupcpyNative(dst, pDstSize, (byte*)pstr);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrdupcpyS(byte* dst, ulong* pDstSize, ReadOnlySpan<byte> str)
|
|
{
|
|
fixed (byte* pstr = str)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStrdupcpyNative(dst, pDstSize, (byte*)pstr));
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrdupcpy(byte* dst, ulong* pDstSize, string str)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
byte* ret = ImStrdupcpyNative(dst, pDstSize, pStr0);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrdupcpyS(byte* dst, ulong* pDstSize, string str)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
string ret = Utils.DecodeStringUTF8(ImStrdupcpyNative(dst, pDstSize, pStr0));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrdupcpy(ref byte dst, ulong* pDstSize, ref byte str)
|
|
{
|
|
fixed (byte* pdst = &dst)
|
|
{
|
|
fixed (byte* pstr = &str)
|
|
{
|
|
byte* ret = ImStrdupcpyNative((byte*)pdst, pDstSize, (byte*)pstr);
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrdupcpyS(ref byte dst, ulong* pDstSize, ref byte str)
|
|
{
|
|
fixed (byte* pdst = &dst)
|
|
{
|
|
fixed (byte* pstr = &str)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStrdupcpyNative((byte*)pdst, pDstSize, (byte*)pstr));
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrdupcpy(ref byte dst, ulong* pDstSize, ReadOnlySpan<byte> str)
|
|
{
|
|
fixed (byte* pdst = &dst)
|
|
{
|
|
fixed (byte* pstr = str)
|
|
{
|
|
byte* ret = ImStrdupcpyNative((byte*)pdst, pDstSize, (byte*)pstr);
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrdupcpyS(ref byte dst, ulong* pDstSize, ReadOnlySpan<byte> str)
|
|
{
|
|
fixed (byte* pdst = &dst)
|
|
{
|
|
fixed (byte* pstr = str)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStrdupcpyNative((byte*)pdst, pDstSize, (byte*)pstr));
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrdupcpy(ref string dst, ulong* pDstSize, string str)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (dst != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(dst);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(dst, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
byte* pStr1 = null;
|
|
int pStrSize1 = 0;
|
|
if (str != null)
|
|
{
|
|
pStrSize1 = Utils.GetByteCountUTF8(str);
|
|
if (pStrSize1 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr1 = Utils.Alloc<byte>(pStrSize1 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack1 = stackalloc byte[pStrSize1 + 1];
|
|
pStr1 = pStrStack1;
|
|
}
|
|
int pStrOffset1 = Utils.EncodeStringUTF8(str, pStr1, pStrSize1);
|
|
pStr1[pStrOffset1] = 0;
|
|
}
|
|
byte* ret = ImStrdupcpyNative(pStr0, pDstSize, pStr1);
|
|
dst = Utils.DecodeStringUTF8(pStr0);
|
|
if (pStrSize1 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr1);
|
|
}
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrdupcpyS(ref string dst, ulong* pDstSize, string str)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (dst != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(dst);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(dst, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
byte* pStr1 = null;
|
|
int pStrSize1 = 0;
|
|
if (str != null)
|
|
{
|
|
pStrSize1 = Utils.GetByteCountUTF8(str);
|
|
if (pStrSize1 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr1 = Utils.Alloc<byte>(pStrSize1 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack1 = stackalloc byte[pStrSize1 + 1];
|
|
pStr1 = pStrStack1;
|
|
}
|
|
int pStrOffset1 = Utils.EncodeStringUTF8(str, pStr1, pStrSize1);
|
|
pStr1[pStrOffset1] = 0;
|
|
}
|
|
string ret = Utils.DecodeStringUTF8(ImStrdupcpyNative(pStr0, pDstSize, pStr1));
|
|
dst = Utils.DecodeStringUTF8(pStr0);
|
|
if (pStrSize1 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr1);
|
|
}
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrdupcpy(ref byte dst, ulong* pDstSize, string str)
|
|
{
|
|
fixed (byte* pdst = &dst)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
byte* ret = ImStrdupcpyNative((byte*)pdst, pDstSize, pStr0);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrdupcpyS(ref byte dst, ulong* pDstSize, string str)
|
|
{
|
|
fixed (byte* pdst = &dst)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
string ret = Utils.DecodeStringUTF8(ImStrdupcpyNative((byte*)pdst, pDstSize, pStr0));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrdupcpy(ref string dst, ulong* pDstSize, ref byte str)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (dst != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(dst);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(dst, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
fixed (byte* pstr = &str)
|
|
{
|
|
byte* ret = ImStrdupcpyNative(pStr0, pDstSize, (byte*)pstr);
|
|
dst = Utils.DecodeStringUTF8(pStr0);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrdupcpyS(ref string dst, ulong* pDstSize, ref byte str)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (dst != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(dst);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(dst, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
fixed (byte* pstr = &str)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStrdupcpyNative(pStr0, pDstSize, (byte*)pstr));
|
|
dst = Utils.DecodeStringUTF8(pStr0);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrdupcpy(ref string dst, ulong* pDstSize, ReadOnlySpan<byte> str)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (dst != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(dst);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(dst, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
fixed (byte* pstr = str)
|
|
{
|
|
byte* ret = ImStrdupcpyNative(pStr0, pDstSize, (byte*)pstr);
|
|
dst = Utils.DecodeStringUTF8(pStr0);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrdupcpyS(ref string dst, ulong* pDstSize, ReadOnlySpan<byte> str)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (dst != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(dst);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(dst, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
fixed (byte* pstr = str)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStrdupcpyNative(pStr0, pDstSize, (byte*)pstr));
|
|
dst = Utils.DecodeStringUTF8(pStr0);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrdupcpy(byte* dst, ref nuint pDstSize, ref byte str)
|
|
{
|
|
fixed (nuint* ppDstSize = &pDstSize)
|
|
{
|
|
fixed (byte* pstr = &str)
|
|
{
|
|
byte* ret = ImStrdupcpyNative(dst, (ulong*)ppDstSize, (byte*)pstr);
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrdupcpyS(byte* dst, ref nuint pDstSize, ref byte str)
|
|
{
|
|
fixed (nuint* ppDstSize = &pDstSize)
|
|
{
|
|
fixed (byte* pstr = &str)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStrdupcpyNative(dst, (ulong*)ppDstSize, (byte*)pstr));
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrdupcpy(byte* dst, ref nuint pDstSize, ReadOnlySpan<byte> str)
|
|
{
|
|
fixed (nuint* ppDstSize = &pDstSize)
|
|
{
|
|
fixed (byte* pstr = str)
|
|
{
|
|
byte* ret = ImStrdupcpyNative(dst, (ulong*)ppDstSize, (byte*)pstr);
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrdupcpyS(byte* dst, ref nuint pDstSize, ReadOnlySpan<byte> str)
|
|
{
|
|
fixed (nuint* ppDstSize = &pDstSize)
|
|
{
|
|
fixed (byte* pstr = str)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStrdupcpyNative(dst, (ulong*)ppDstSize, (byte*)pstr));
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrdupcpy(byte* dst, ref nuint pDstSize, string str)
|
|
{
|
|
fixed (nuint* ppDstSize = &pDstSize)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
byte* ret = ImStrdupcpyNative(dst, (ulong*)ppDstSize, pStr0);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrdupcpyS(byte* dst, ref nuint pDstSize, string str)
|
|
{
|
|
fixed (nuint* ppDstSize = &pDstSize)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
string ret = Utils.DecodeStringUTF8(ImStrdupcpyNative(dst, (ulong*)ppDstSize, pStr0));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrdupcpy(ref byte dst, ref nuint pDstSize, ref byte str)
|
|
{
|
|
fixed (byte* pdst = &dst)
|
|
{
|
|
fixed (nuint* ppDstSize = &pDstSize)
|
|
{
|
|
fixed (byte* pstr = &str)
|
|
{
|
|
byte* ret = ImStrdupcpyNative((byte*)pdst, (ulong*)ppDstSize, (byte*)pstr);
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrdupcpyS(ref byte dst, ref nuint pDstSize, ref byte str)
|
|
{
|
|
fixed (byte* pdst = &dst)
|
|
{
|
|
fixed (nuint* ppDstSize = &pDstSize)
|
|
{
|
|
fixed (byte* pstr = &str)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStrdupcpyNative((byte*)pdst, (ulong*)ppDstSize, (byte*)pstr));
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrdupcpy(ref byte dst, ref nuint pDstSize, ReadOnlySpan<byte> str)
|
|
{
|
|
fixed (byte* pdst = &dst)
|
|
{
|
|
fixed (nuint* ppDstSize = &pDstSize)
|
|
{
|
|
fixed (byte* pstr = str)
|
|
{
|
|
byte* ret = ImStrdupcpyNative((byte*)pdst, (ulong*)ppDstSize, (byte*)pstr);
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrdupcpyS(ref byte dst, ref nuint pDstSize, ReadOnlySpan<byte> str)
|
|
{
|
|
fixed (byte* pdst = &dst)
|
|
{
|
|
fixed (nuint* ppDstSize = &pDstSize)
|
|
{
|
|
fixed (byte* pstr = str)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStrdupcpyNative((byte*)pdst, (ulong*)ppDstSize, (byte*)pstr));
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrdupcpy(ref string dst, ref nuint pDstSize, string str)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (dst != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(dst);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(dst, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
fixed (nuint* ppDstSize = &pDstSize)
|
|
{
|
|
byte* pStr1 = null;
|
|
int pStrSize1 = 0;
|
|
if (str != null)
|
|
{
|
|
pStrSize1 = Utils.GetByteCountUTF8(str);
|
|
if (pStrSize1 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr1 = Utils.Alloc<byte>(pStrSize1 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack1 = stackalloc byte[pStrSize1 + 1];
|
|
pStr1 = pStrStack1;
|
|
}
|
|
int pStrOffset1 = Utils.EncodeStringUTF8(str, pStr1, pStrSize1);
|
|
pStr1[pStrOffset1] = 0;
|
|
}
|
|
byte* ret = ImStrdupcpyNative(pStr0, (ulong*)ppDstSize, pStr1);
|
|
dst = Utils.DecodeStringUTF8(pStr0);
|
|
if (pStrSize1 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr1);
|
|
}
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrdupcpyS(ref string dst, ref nuint pDstSize, string str)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (dst != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(dst);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(dst, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
fixed (nuint* ppDstSize = &pDstSize)
|
|
{
|
|
byte* pStr1 = null;
|
|
int pStrSize1 = 0;
|
|
if (str != null)
|
|
{
|
|
pStrSize1 = Utils.GetByteCountUTF8(str);
|
|
if (pStrSize1 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr1 = Utils.Alloc<byte>(pStrSize1 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack1 = stackalloc byte[pStrSize1 + 1];
|
|
pStr1 = pStrStack1;
|
|
}
|
|
int pStrOffset1 = Utils.EncodeStringUTF8(str, pStr1, pStrSize1);
|
|
pStr1[pStrOffset1] = 0;
|
|
}
|
|
string ret = Utils.DecodeStringUTF8(ImStrdupcpyNative(pStr0, (ulong*)ppDstSize, pStr1));
|
|
dst = Utils.DecodeStringUTF8(pStr0);
|
|
if (pStrSize1 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr1);
|
|
}
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrdupcpy(ref byte dst, ref nuint pDstSize, string str)
|
|
{
|
|
fixed (byte* pdst = &dst)
|
|
{
|
|
fixed (nuint* ppDstSize = &pDstSize)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
byte* ret = ImStrdupcpyNative((byte*)pdst, (ulong*)ppDstSize, pStr0);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrdupcpyS(ref byte dst, ref nuint pDstSize, string str)
|
|
{
|
|
fixed (byte* pdst = &dst)
|
|
{
|
|
fixed (nuint* ppDstSize = &pDstSize)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
string ret = Utils.DecodeStringUTF8(ImStrdupcpyNative((byte*)pdst, (ulong*)ppDstSize, pStr0));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrdupcpy(ref string dst, ref nuint pDstSize, ref byte str)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (dst != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(dst);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(dst, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
fixed (nuint* ppDstSize = &pDstSize)
|
|
{
|
|
fixed (byte* pstr = &str)
|
|
{
|
|
byte* ret = ImStrdupcpyNative(pStr0, (ulong*)ppDstSize, (byte*)pstr);
|
|
dst = Utils.DecodeStringUTF8(pStr0);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrdupcpyS(ref string dst, ref nuint pDstSize, ref byte str)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (dst != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(dst);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(dst, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
fixed (nuint* ppDstSize = &pDstSize)
|
|
{
|
|
fixed (byte* pstr = &str)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStrdupcpyNative(pStr0, (ulong*)ppDstSize, (byte*)pstr));
|
|
dst = Utils.DecodeStringUTF8(pStr0);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrdupcpy(ref string dst, ref nuint pDstSize, ReadOnlySpan<byte> str)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (dst != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(dst);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(dst, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
fixed (nuint* ppDstSize = &pDstSize)
|
|
{
|
|
fixed (byte* pstr = str)
|
|
{
|
|
byte* ret = ImStrdupcpyNative(pStr0, (ulong*)ppDstSize, (byte*)pstr);
|
|
dst = Utils.DecodeStringUTF8(pStr0);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrdupcpyS(ref string dst, ref nuint pDstSize, ReadOnlySpan<byte> str)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (dst != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(dst);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(dst, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
fixed (nuint* ppDstSize = &pDstSize)
|
|
{
|
|
fixed (byte* pstr = str)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStrdupcpyNative(pStr0, (ulong*)ppDstSize, (byte*)pstr));
|
|
dst = Utils.DecodeStringUTF8(pStr0);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static byte* ImStrchrRangeNative(byte* strBegin, byte* strEnd, byte c)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
return ((delegate* unmanaged[Cdecl]<byte*, byte*, byte, byte*>)funcTable[703])(strBegin, strEnd, c);
|
|
#else
|
|
return (byte*)((delegate* unmanaged[Cdecl]<nint, nint, byte, nint>)funcTable[703])((nint)strBegin, (nint)strEnd, c);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrchrRange(byte* strBegin, byte* strEnd, byte c)
|
|
{
|
|
byte* ret = ImStrchrRangeNative(strBegin, strEnd, c);
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrchrRangeS(byte* strBegin, byte* strEnd, byte c)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStrchrRangeNative(strBegin, strEnd, c));
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrchrRange(ref byte strBegin, byte* strEnd, byte c)
|
|
{
|
|
fixed (byte* pstrBegin = &strBegin)
|
|
{
|
|
byte* ret = ImStrchrRangeNative((byte*)pstrBegin, strEnd, c);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrchrRangeS(ref byte strBegin, byte* strEnd, byte c)
|
|
{
|
|
fixed (byte* pstrBegin = &strBegin)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStrchrRangeNative((byte*)pstrBegin, strEnd, c));
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrchrRange(ReadOnlySpan<byte> strBegin, byte* strEnd, byte c)
|
|
{
|
|
fixed (byte* pstrBegin = strBegin)
|
|
{
|
|
byte* ret = ImStrchrRangeNative((byte*)pstrBegin, strEnd, c);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrchrRangeS(ReadOnlySpan<byte> strBegin, byte* strEnd, byte c)
|
|
{
|
|
fixed (byte* pstrBegin = strBegin)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStrchrRangeNative((byte*)pstrBegin, strEnd, c));
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrchrRange(string strBegin, byte* strEnd, byte c)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (strBegin != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(strBegin);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(strBegin, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
byte* ret = ImStrchrRangeNative(pStr0, strEnd, c);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrchrRangeS(string strBegin, byte* strEnd, byte c)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (strBegin != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(strBegin);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(strBegin, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
string ret = Utils.DecodeStringUTF8(ImStrchrRangeNative(pStr0, strEnd, c));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrchrRange(byte* strBegin, ref byte strEnd, byte c)
|
|
{
|
|
fixed (byte* pstrEnd = &strEnd)
|
|
{
|
|
byte* ret = ImStrchrRangeNative(strBegin, (byte*)pstrEnd, c);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrchrRangeS(byte* strBegin, ref byte strEnd, byte c)
|
|
{
|
|
fixed (byte* pstrEnd = &strEnd)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStrchrRangeNative(strBegin, (byte*)pstrEnd, c));
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrchrRange(byte* strBegin, ReadOnlySpan<byte> strEnd, byte c)
|
|
{
|
|
fixed (byte* pstrEnd = strEnd)
|
|
{
|
|
byte* ret = ImStrchrRangeNative(strBegin, (byte*)pstrEnd, c);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrchrRangeS(byte* strBegin, ReadOnlySpan<byte> strEnd, byte c)
|
|
{
|
|
fixed (byte* pstrEnd = strEnd)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStrchrRangeNative(strBegin, (byte*)pstrEnd, c));
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrchrRange(byte* strBegin, string strEnd, byte c)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (strEnd != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(strEnd);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(strEnd, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
byte* ret = ImStrchrRangeNative(strBegin, pStr0, c);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrchrRangeS(byte* strBegin, string strEnd, byte c)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (strEnd != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(strEnd);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(strEnd, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
string ret = Utils.DecodeStringUTF8(ImStrchrRangeNative(strBegin, pStr0, c));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrchrRange(ref byte strBegin, ref byte strEnd, byte c)
|
|
{
|
|
fixed (byte* pstrBegin = &strBegin)
|
|
{
|
|
fixed (byte* pstrEnd = &strEnd)
|
|
{
|
|
byte* ret = ImStrchrRangeNative((byte*)pstrBegin, (byte*)pstrEnd, c);
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrchrRangeS(ref byte strBegin, ref byte strEnd, byte c)
|
|
{
|
|
fixed (byte* pstrBegin = &strBegin)
|
|
{
|
|
fixed (byte* pstrEnd = &strEnd)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStrchrRangeNative((byte*)pstrBegin, (byte*)pstrEnd, c));
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrchrRange(ReadOnlySpan<byte> strBegin, ReadOnlySpan<byte> strEnd, byte c)
|
|
{
|
|
fixed (byte* pstrBegin = strBegin)
|
|
{
|
|
fixed (byte* pstrEnd = strEnd)
|
|
{
|
|
byte* ret = ImStrchrRangeNative((byte*)pstrBegin, (byte*)pstrEnd, c);
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrchrRangeS(ReadOnlySpan<byte> strBegin, ReadOnlySpan<byte> strEnd, byte c)
|
|
{
|
|
fixed (byte* pstrBegin = strBegin)
|
|
{
|
|
fixed (byte* pstrEnd = strEnd)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStrchrRangeNative((byte*)pstrBegin, (byte*)pstrEnd, c));
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrchrRange(string strBegin, string strEnd, byte c)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (strBegin != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(strBegin);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(strBegin, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
byte* pStr1 = null;
|
|
int pStrSize1 = 0;
|
|
if (strEnd != null)
|
|
{
|
|
pStrSize1 = Utils.GetByteCountUTF8(strEnd);
|
|
if (pStrSize1 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr1 = Utils.Alloc<byte>(pStrSize1 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack1 = stackalloc byte[pStrSize1 + 1];
|
|
pStr1 = pStrStack1;
|
|
}
|
|
int pStrOffset1 = Utils.EncodeStringUTF8(strEnd, pStr1, pStrSize1);
|
|
pStr1[pStrOffset1] = 0;
|
|
}
|
|
byte* ret = ImStrchrRangeNative(pStr0, pStr1, c);
|
|
if (pStrSize1 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr1);
|
|
}
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrchrRangeS(string strBegin, string strEnd, byte c)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (strBegin != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(strBegin);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(strBegin, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
byte* pStr1 = null;
|
|
int pStrSize1 = 0;
|
|
if (strEnd != null)
|
|
{
|
|
pStrSize1 = Utils.GetByteCountUTF8(strEnd);
|
|
if (pStrSize1 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr1 = Utils.Alloc<byte>(pStrSize1 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack1 = stackalloc byte[pStrSize1 + 1];
|
|
pStr1 = pStrStack1;
|
|
}
|
|
int pStrOffset1 = Utils.EncodeStringUTF8(strEnd, pStr1, pStrSize1);
|
|
pStr1[pStrOffset1] = 0;
|
|
}
|
|
string ret = Utils.DecodeStringUTF8(ImStrchrRangeNative(pStr0, pStr1, c));
|
|
if (pStrSize1 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr1);
|
|
}
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrchrRange(ref byte strBegin, ReadOnlySpan<byte> strEnd, byte c)
|
|
{
|
|
fixed (byte* pstrBegin = &strBegin)
|
|
{
|
|
fixed (byte* pstrEnd = strEnd)
|
|
{
|
|
byte* ret = ImStrchrRangeNative((byte*)pstrBegin, (byte*)pstrEnd, c);
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrchrRangeS(ref byte strBegin, ReadOnlySpan<byte> strEnd, byte c)
|
|
{
|
|
fixed (byte* pstrBegin = &strBegin)
|
|
{
|
|
fixed (byte* pstrEnd = strEnd)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStrchrRangeNative((byte*)pstrBegin, (byte*)pstrEnd, c));
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrchrRange(ref byte strBegin, string strEnd, byte c)
|
|
{
|
|
fixed (byte* pstrBegin = &strBegin)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (strEnd != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(strEnd);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(strEnd, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
byte* ret = ImStrchrRangeNative((byte*)pstrBegin, pStr0, c);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrchrRangeS(ref byte strBegin, string strEnd, byte c)
|
|
{
|
|
fixed (byte* pstrBegin = &strBegin)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (strEnd != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(strEnd);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(strEnd, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
string ret = Utils.DecodeStringUTF8(ImStrchrRangeNative((byte*)pstrBegin, pStr0, c));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrchrRange(ReadOnlySpan<byte> strBegin, ref byte strEnd, byte c)
|
|
{
|
|
fixed (byte* pstrBegin = strBegin)
|
|
{
|
|
fixed (byte* pstrEnd = &strEnd)
|
|
{
|
|
byte* ret = ImStrchrRangeNative((byte*)pstrBegin, (byte*)pstrEnd, c);
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrchrRangeS(ReadOnlySpan<byte> strBegin, ref byte strEnd, byte c)
|
|
{
|
|
fixed (byte* pstrBegin = strBegin)
|
|
{
|
|
fixed (byte* pstrEnd = &strEnd)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStrchrRangeNative((byte*)pstrBegin, (byte*)pstrEnd, c));
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrchrRange(ReadOnlySpan<byte> strBegin, string strEnd, byte c)
|
|
{
|
|
fixed (byte* pstrBegin = strBegin)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (strEnd != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(strEnd);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(strEnd, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
byte* ret = ImStrchrRangeNative((byte*)pstrBegin, pStr0, c);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrchrRangeS(ReadOnlySpan<byte> strBegin, string strEnd, byte c)
|
|
{
|
|
fixed (byte* pstrBegin = strBegin)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (strEnd != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(strEnd);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(strEnd, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
string ret = Utils.DecodeStringUTF8(ImStrchrRangeNative((byte*)pstrBegin, pStr0, c));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrchrRange(string strBegin, ref byte strEnd, byte c)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (strBegin != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(strBegin);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(strBegin, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
fixed (byte* pstrEnd = &strEnd)
|
|
{
|
|
byte* ret = ImStrchrRangeNative(pStr0, (byte*)pstrEnd, c);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrchrRangeS(string strBegin, ref byte strEnd, byte c)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (strBegin != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(strBegin);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(strBegin, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
fixed (byte* pstrEnd = &strEnd)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStrchrRangeNative(pStr0, (byte*)pstrEnd, c));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStrchrRange(string strBegin, ReadOnlySpan<byte> strEnd, byte c)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (strBegin != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(strBegin);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(strBegin, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
fixed (byte* pstrEnd = strEnd)
|
|
{
|
|
byte* ret = ImStrchrRangeNative(pStr0, (byte*)pstrEnd, c);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStrchrRangeS(string strBegin, ReadOnlySpan<byte> strEnd, byte c)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (strBegin != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(strBegin);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(strBegin, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
fixed (byte* pstrEnd = strEnd)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStrchrRangeNative(pStr0, (byte*)pstrEnd, c));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static int ImStrlenWNative(ushort* str)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
return ((delegate* unmanaged[Cdecl]<ushort*, int>)funcTable[704])(str);
|
|
#else
|
|
return (int)((delegate* unmanaged[Cdecl]<nint, int>)funcTable[704])((nint)str);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStrlenW(ushort* str)
|
|
{
|
|
int ret = ImStrlenWNative(str);
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static int ImStrlenW(ref ushort str)
|
|
{
|
|
fixed (ushort* pstr = &str)
|
|
{
|
|
int ret = ImStrlenWNative((ushort*)pstr);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
internal static byte* ImStreolRangeNative(byte* str, byte* strEnd)
|
|
{
|
|
#if NET5_0_OR_GREATER
|
|
return ((delegate* unmanaged[Cdecl]<byte*, byte*, byte*>)funcTable[705])(str, strEnd);
|
|
#else
|
|
return (byte*)((delegate* unmanaged[Cdecl]<nint, nint, nint>)funcTable[705])((nint)str, (nint)strEnd);
|
|
#endif
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStreolRange(byte* str, byte* strEnd)
|
|
{
|
|
byte* ret = ImStreolRangeNative(str, strEnd);
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStreolRangeS(byte* str, byte* strEnd)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStreolRangeNative(str, strEnd));
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStreolRange(ref byte str, byte* strEnd)
|
|
{
|
|
fixed (byte* pstr = &str)
|
|
{
|
|
byte* ret = ImStreolRangeNative((byte*)pstr, strEnd);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStreolRangeS(ref byte str, byte* strEnd)
|
|
{
|
|
fixed (byte* pstr = &str)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStreolRangeNative((byte*)pstr, strEnd));
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStreolRange(ReadOnlySpan<byte> str, byte* strEnd)
|
|
{
|
|
fixed (byte* pstr = str)
|
|
{
|
|
byte* ret = ImStreolRangeNative((byte*)pstr, strEnd);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStreolRangeS(ReadOnlySpan<byte> str, byte* strEnd)
|
|
{
|
|
fixed (byte* pstr = str)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStreolRangeNative((byte*)pstr, strEnd));
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStreolRange(string str, byte* strEnd)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
byte* ret = ImStreolRangeNative(pStr0, strEnd);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStreolRangeS(string str, byte* strEnd)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
string ret = Utils.DecodeStringUTF8(ImStreolRangeNative(pStr0, strEnd));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStreolRange(byte* str, ref byte strEnd)
|
|
{
|
|
fixed (byte* pstrEnd = &strEnd)
|
|
{
|
|
byte* ret = ImStreolRangeNative(str, (byte*)pstrEnd);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStreolRangeS(byte* str, ref byte strEnd)
|
|
{
|
|
fixed (byte* pstrEnd = &strEnd)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStreolRangeNative(str, (byte*)pstrEnd));
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStreolRange(byte* str, ReadOnlySpan<byte> strEnd)
|
|
{
|
|
fixed (byte* pstrEnd = strEnd)
|
|
{
|
|
byte* ret = ImStreolRangeNative(str, (byte*)pstrEnd);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStreolRangeS(byte* str, ReadOnlySpan<byte> strEnd)
|
|
{
|
|
fixed (byte* pstrEnd = strEnd)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStreolRangeNative(str, (byte*)pstrEnd));
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStreolRange(byte* str, string strEnd)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (strEnd != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(strEnd);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(strEnd, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
byte* ret = ImStreolRangeNative(str, pStr0);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStreolRangeS(byte* str, string strEnd)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (strEnd != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(strEnd);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(strEnd, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
string ret = Utils.DecodeStringUTF8(ImStreolRangeNative(str, pStr0));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStreolRange(ref byte str, ref byte strEnd)
|
|
{
|
|
fixed (byte* pstr = &str)
|
|
{
|
|
fixed (byte* pstrEnd = &strEnd)
|
|
{
|
|
byte* ret = ImStreolRangeNative((byte*)pstr, (byte*)pstrEnd);
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStreolRangeS(ref byte str, ref byte strEnd)
|
|
{
|
|
fixed (byte* pstr = &str)
|
|
{
|
|
fixed (byte* pstrEnd = &strEnd)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStreolRangeNative((byte*)pstr, (byte*)pstrEnd));
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStreolRange(ReadOnlySpan<byte> str, ReadOnlySpan<byte> strEnd)
|
|
{
|
|
fixed (byte* pstr = str)
|
|
{
|
|
fixed (byte* pstrEnd = strEnd)
|
|
{
|
|
byte* ret = ImStreolRangeNative((byte*)pstr, (byte*)pstrEnd);
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStreolRangeS(ReadOnlySpan<byte> str, ReadOnlySpan<byte> strEnd)
|
|
{
|
|
fixed (byte* pstr = str)
|
|
{
|
|
fixed (byte* pstrEnd = strEnd)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStreolRangeNative((byte*)pstr, (byte*)pstrEnd));
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStreolRange(string str, string strEnd)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
byte* pStr1 = null;
|
|
int pStrSize1 = 0;
|
|
if (strEnd != null)
|
|
{
|
|
pStrSize1 = Utils.GetByteCountUTF8(strEnd);
|
|
if (pStrSize1 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr1 = Utils.Alloc<byte>(pStrSize1 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack1 = stackalloc byte[pStrSize1 + 1];
|
|
pStr1 = pStrStack1;
|
|
}
|
|
int pStrOffset1 = Utils.EncodeStringUTF8(strEnd, pStr1, pStrSize1);
|
|
pStr1[pStrOffset1] = 0;
|
|
}
|
|
byte* ret = ImStreolRangeNative(pStr0, pStr1);
|
|
if (pStrSize1 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr1);
|
|
}
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStreolRangeS(string str, string strEnd)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
byte* pStr1 = null;
|
|
int pStrSize1 = 0;
|
|
if (strEnd != null)
|
|
{
|
|
pStrSize1 = Utils.GetByteCountUTF8(strEnd);
|
|
if (pStrSize1 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr1 = Utils.Alloc<byte>(pStrSize1 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack1 = stackalloc byte[pStrSize1 + 1];
|
|
pStr1 = pStrStack1;
|
|
}
|
|
int pStrOffset1 = Utils.EncodeStringUTF8(strEnd, pStr1, pStrSize1);
|
|
pStr1[pStrOffset1] = 0;
|
|
}
|
|
string ret = Utils.DecodeStringUTF8(ImStreolRangeNative(pStr0, pStr1));
|
|
if (pStrSize1 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr1);
|
|
}
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStreolRange(ref byte str, ReadOnlySpan<byte> strEnd)
|
|
{
|
|
fixed (byte* pstr = &str)
|
|
{
|
|
fixed (byte* pstrEnd = strEnd)
|
|
{
|
|
byte* ret = ImStreolRangeNative((byte*)pstr, (byte*)pstrEnd);
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStreolRangeS(ref byte str, ReadOnlySpan<byte> strEnd)
|
|
{
|
|
fixed (byte* pstr = &str)
|
|
{
|
|
fixed (byte* pstrEnd = strEnd)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStreolRangeNative((byte*)pstr, (byte*)pstrEnd));
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStreolRange(ref byte str, string strEnd)
|
|
{
|
|
fixed (byte* pstr = &str)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (strEnd != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(strEnd);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(strEnd, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
byte* ret = ImStreolRangeNative((byte*)pstr, pStr0);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStreolRangeS(ref byte str, string strEnd)
|
|
{
|
|
fixed (byte* pstr = &str)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (strEnd != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(strEnd);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(strEnd, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
string ret = Utils.DecodeStringUTF8(ImStreolRangeNative((byte*)pstr, pStr0));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStreolRange(ReadOnlySpan<byte> str, ref byte strEnd)
|
|
{
|
|
fixed (byte* pstr = str)
|
|
{
|
|
fixed (byte* pstrEnd = &strEnd)
|
|
{
|
|
byte* ret = ImStreolRangeNative((byte*)pstr, (byte*)pstrEnd);
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStreolRangeS(ReadOnlySpan<byte> str, ref byte strEnd)
|
|
{
|
|
fixed (byte* pstr = str)
|
|
{
|
|
fixed (byte* pstrEnd = &strEnd)
|
|
{
|
|
string ret = Utils.DecodeStringUTF8(ImStreolRangeNative((byte*)pstr, (byte*)pstrEnd));
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStreolRange(ReadOnlySpan<byte> str, string strEnd)
|
|
{
|
|
fixed (byte* pstr = str)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (strEnd != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(strEnd);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(strEnd, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
byte* ret = ImStreolRangeNative((byte*)pstr, pStr0);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static string ImStreolRangeS(ReadOnlySpan<byte> str, string strEnd)
|
|
{
|
|
fixed (byte* pstr = str)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (strEnd != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(strEnd);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(strEnd, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
string ret = Utils.DecodeStringUTF8(ImStreolRangeNative((byte*)pstr, pStr0));
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// To be documented.
|
|
/// </summary>
|
|
public static byte* ImStreolRange(string str, ref byte strEnd)
|
|
{
|
|
byte* pStr0 = null;
|
|
int pStrSize0 = 0;
|
|
if (str != null)
|
|
{
|
|
pStrSize0 = Utils.GetByteCountUTF8(str);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
pStr0 = Utils.Alloc<byte>(pStrSize0 + 1);
|
|
}
|
|
else
|
|
{
|
|
byte* pStrStack0 = stackalloc byte[pStrSize0 + 1];
|
|
pStr0 = pStrStack0;
|
|
}
|
|
int pStrOffset0 = Utils.EncodeStringUTF8(str, pStr0, pStrSize0);
|
|
pStr0[pStrOffset0] = 0;
|
|
}
|
|
fixed (byte* pstrEnd = &strEnd)
|
|
{
|
|
byte* ret = ImStreolRangeNative(pStr0, (byte*)pstrEnd);
|
|
if (pStrSize0 >= Utils.MaxStackallocSize)
|
|
{
|
|
Utils.Free(pStr0);
|
|
}
|
|
return ret;
|
|
}
|
|
}
|
|
}
|
|
}
|