public static int CheckOption(LuaStatePtr l, int narg, string def, string[] lst) {
sbyte *[] lst_ = new sbyte*[lst.Length];
for (int i = 0; i < lst.Length; ++i) {
fixed(char * c = &lst[i].ToCharArray()[0]) {
sbyte * b = (sbyte *)c;
lst_[i] = b;
}
}
return LuaLDelegates.luaL_checkoption(l, narg, def, lst_);
}
public unsafe bool AddListener(IntPtr gameEventListner2, sbyte *Event, bool bServerSide) => GetFunction <NativeAddListener>(Functions.AddListener)(ObjectAddress, gameEventListner2, Event, bServerSide);
public ID3D10EffectVariable *GetMemberBySemantic([NativeTypeName("LPCSTR")] sbyte *Semantic)
{
return(((delegate * unmanaged <ID3D10EffectConstantBuffer *, sbyte *, ID3D10EffectVariable *>)(lpVtbl[7]))((ID3D10EffectConstantBuffer *)Unsafe.AsPointer(ref this), Semantic));
}
unsafe internal static extern int nativeCompareOrdinalIgnoreCaseWC(String strA, sbyte *strBBytes);
internal static extern unsafe void SelectFontFace(FontWeight weight, FontSlant slant, sbyte *family, uint cr);
static unsafe int Main(string[] args)
{
int testResult = Pass;
if (Sse2.IsSupported)
{
{
double *inArray = stackalloc double[2];
byte * outBuffer = stackalloc byte[32];
double *outArray = (double *)Align(outBuffer, 16);
var vf = Unsafe.Read <Vector128 <double> >(inArray);
Sse2.StoreAlignedNonTemporal(outArray, vf);
for (var i = 0; i < 2; i++)
{
if (BitConverter.DoubleToInt64Bits(inArray[i]) != BitConverter.DoubleToInt64Bits(outArray[i]))
{
Console.WriteLine("Sse2 StoreAlignedNonTemporal failed on double:");
for (var n = 0; n < 2; n++)
{
Console.Write(outArray[n] + ", ");
}
Console.WriteLine();
testResult = Fail;
break;
}
}
}
{
long *inArray = stackalloc long[2];
byte *outBuffer = stackalloc byte[32];
long *outArray = (long *)Align(outBuffer, 16);
var vf = Unsafe.Read <Vector128 <long> >(inArray);
Sse2.StoreAlignedNonTemporal(outArray, vf);
for (var i = 0; i < 2; i++)
{
if (inArray[i] != outArray[i])
{
Console.WriteLine("Sse2 StoreAlignedNonTemporal failed on long:");
for (var n = 0; n < 2; n++)
{
Console.Write(outArray[n] + ", ");
}
Console.WriteLine();
testResult = Fail;
break;
}
}
}
{
ulong *inArray = stackalloc ulong[2];
byte * outBuffer = stackalloc byte[32];
ulong *outArray = (ulong *)Align(outBuffer, 16);
var vf = Unsafe.Read <Vector128 <ulong> >(inArray);
Sse2.StoreAlignedNonTemporal(outArray, vf);
for (var i = 0; i < 2; i++)
{
if (inArray[i] != outArray[i])
{
Console.WriteLine("Sse2 StoreAlignedNonTemporal failed on ulong:");
for (var n = 0; n < 2; n++)
{
Console.Write(outArray[n] + ", ");
}
Console.WriteLine();
testResult = Fail;
break;
}
}
}
{
int * inArray = stackalloc int[4];
byte *outBuffer = stackalloc byte[32];
int * outArray = (int *)Align(outBuffer, 16);
var vf = Unsafe.Read <Vector128 <int> >(inArray);
Sse2.StoreAlignedNonTemporal(outArray, vf);
for (var i = 0; i < 4; i++)
{
if (inArray[i] != outArray[i])
{
Console.WriteLine("Sse2 StoreAlignedNonTemporal failed on int:");
for (var n = 0; n < 4; n++)
{
Console.Write(outArray[n] + ", ");
}
Console.WriteLine();
testResult = Fail;
break;
}
}
}
{
uint *inArray = stackalloc uint[4];
byte *outBuffer = stackalloc byte[32];
uint *outArray = (uint *)Align(outBuffer, 16);
var vf = Unsafe.Read <Vector128 <uint> >(inArray);
Sse2.StoreAlignedNonTemporal(outArray, vf);
for (var i = 0; i < 4; i++)
{
if (inArray[i] != outArray[i])
{
Console.WriteLine("Sse2 StoreAlignedNonTemporal failed on uint:");
for (var n = 0; n < 4; n++)
{
Console.Write(outArray[n] + ", ");
}
Console.WriteLine();
testResult = Fail;
break;
}
}
}
{
short *inArray = stackalloc short[8];
byte * outBuffer = stackalloc byte[32];
short *outArray = (short *)Align(outBuffer, 16);
var vf = Unsafe.Read <Vector128 <short> >(inArray);
Sse2.StoreAlignedNonTemporal(outArray, vf);
for (var i = 0; i < 8; i++)
{
if (inArray[i] != outArray[i])
{
Console.WriteLine("Sse2 StoreAlignedNonTemporal failed on short:");
for (var n = 0; n < 8; n++)
{
Console.Write(outArray[n] + ", ");
}
Console.WriteLine();
testResult = Fail;
break;
}
}
}
{
ushort *inArray = stackalloc ushort[8];
byte * outBuffer = stackalloc byte[32];
ushort *outArray = (ushort *)Align(outBuffer, 16);
var vf = Unsafe.Read <Vector128 <ushort> >(inArray);
Sse2.StoreAlignedNonTemporal(outArray, vf);
for (var i = 0; i < 8; i++)
{
if (inArray[i] != outArray[i])
{
Console.WriteLine("Sse2 StoreAlignedNonTemporal failed on ushort:");
for (var n = 0; n < 8; n++)
{
Console.Write(outArray[n] + ", ");
}
Console.WriteLine();
testResult = Fail;
break;
}
}
}
{
byte *inArray = stackalloc byte[16];
byte *outBuffer = stackalloc byte[32];
byte *outArray = (byte *)Align(outBuffer, 16);
var vf = Unsafe.Read <Vector128 <byte> >(inArray);
Sse2.StoreAlignedNonTemporal(outArray, vf);
for (var i = 0; i < 16; i++)
{
if (inArray[i] != outArray[i])
{
Console.WriteLine("Sse2 StoreAlignedNonTemporal failed on byte:");
for (var n = 0; n < 16; n++)
{
Console.Write(outArray[n] + ", ");
}
Console.WriteLine();
testResult = Fail;
break;
}
}
}
{
sbyte *inArray = stackalloc sbyte[16];
byte * outBuffer = stackalloc byte[32];
sbyte *outArray = (sbyte *)Align(outBuffer, 16);
var vf = Unsafe.Read <Vector128 <sbyte> >(inArray);
Sse2.StoreAlignedNonTemporal(outArray, vf);
for (var i = 0; i < 16; i++)
{
if (inArray[i] != outArray[i])
{
Console.WriteLine("Sse2 StoreAlignedNonTemporal failed on byte:");
for (var n = 0; n < 16; n++)
{
Console.Write(outArray[n] + ", ");
}
Console.WriteLine();
testResult = Fail;
break;
}
}
}
}
return(testResult);
}
public static IntPtr getStringIntPtr(string inString)
{
sbyte *stringPointer = (sbyte *)Marshal.StringToHGlobalAnsi(inString).ToPointer();
return(new IntPtr((void *)stringPointer));
}
public CString(int len)
{
freeableString = Marshal.AllocHGlobal(len);
nativeString = (sbyte *)freeableString.ToPointer();
}
private unsafe static extern void _EASharpBinding_56(void *_ThisPtr, sbyte *pResponse);
private unsafe static extern void _EASharpBinding_1117(void *_ThisPtr, sbyte *value);
public static extern OneByteBoolean StringIsEqualToUtf8CString([NativeTypeName("JSStringRef")] JsString *a, [NativeTypeName("const char *")] sbyte *b);
public static extern UIntPtr StringGetUtf8CString([NativeTypeName("JSStringRef")] JsString * @string, [NativeTypeName("char *")] sbyte *buffer, [NativeTypeName("size_t")] UIntPtr bufferSize);
public void SetStream(Stream Stream)
{
_base = (sbyte*)(GCHandle.ToIntPtr(GCHandle.Alloc(new SpecialCStream(Stream), GCHandleType.Normal)).ToPointer());
}
public int CheckCounter([NativeTypeName("const D3D11_COUNTER_DESC *")] D3D11_COUNTER_DESC *pDesc, [NativeTypeName("D3D11_COUNTER_TYPE *")] D3D11_COUNTER_TYPE *pType, [NativeTypeName("UINT *")] uint *pActiveCounters, [NativeTypeName("LPSTR")] sbyte *szName, [NativeTypeName("UINT *")] uint *pNameLength, [NativeTypeName("LPSTR")] sbyte *szUnits, [NativeTypeName("UINT *")] uint *pUnitsLength, [NativeTypeName("LPSTR")] sbyte *szDescription, [NativeTypeName("UINT *")] uint *pDescriptionLength)
{
return(((delegate * stdcall <ID3D11Device3 *, D3D11_COUNTER_DESC *, D3D11_COUNTER_TYPE *, uint *, sbyte *, uint *, sbyte *, uint *, sbyte *, uint *, int>)(lpVtbl[32]))((ID3D11Device3 *)Unsafe.AsPointer(ref this), pDesc, pType, pActiveCounters, szName, pNameLength, szUnits, pUnitsLength, szDescription, pDescriptionLength));
}
public extern unsafe String(sbyte *value);
/// <summary>
/// Creates a new CudaRegisteredHostMemory_sbyte from an existing IntPtr. IntPtr must be page size aligned (4KBytes)!
/// </summary>
/// <param name="hostPointer">must be page size aligned (4KBytes)</param>
/// <param name="size">In elements</param>
public CudaRegisteredHostMemory_sbyte(IntPtr hostPointer, SizeT size)
{
_intPtr = hostPointer;
_size = size;
_typeSize = (SizeT)Marshal.SizeOf(typeof(sbyte));
_ptr = (sbyte*)_intPtr;
}
public extern unsafe String(sbyte *value, int startIndex, int length);
/// <summary>
/// Create JVM.
/// </summary>
/// <returns>JVM.</returns>
private static void* CreateJvm(IgniteConfiguration cfg, UnmanagedCallbacks cbs)
{
var cp = Classpath.CreateClasspath(cfg);
var jvmOpts = GetMergedJvmOptions(cfg);
var opts = new sbyte*[1 + jvmOpts.Count];
int idx = 0;
opts[idx++] = IgniteUtils.StringToUtf8Unmanaged(cp);
foreach (string cfgOpt in jvmOpts)
opts[idx++] = IgniteUtils.StringToUtf8Unmanaged(cfgOpt);
try
{
IntPtr mem = Marshal.AllocHGlobal(opts.Length * 8);
fixed (sbyte** opts0 = opts)
{
PlatformMemoryUtils.CopyMemory(opts0, mem.ToPointer(), opts.Length * 8);
}
try
{
return UU.CreateContext(mem.ToPointer(), opts.Length, cbs.CallbacksPointer);
}
finally
{
Marshal.FreeHGlobal(mem);
}
}
finally
{
foreach (sbyte* opt in opts)
Marshal.FreeHGlobal((IntPtr)opt);
}
}
public extern unsafe String(sbyte *value, int startIndex, int length, Encoding enc);
static unsafe Map()
{
Debug.TimeBlock("Initializing Map");
m_MapDataBuffer = new byte[0xc4];
m_StaIndexBuffer = new byte[12];
m_StaDataBuffer = new byte[0x100];
m_pAnims = (sbyte*) Memory.Alloc(0x100000);
string path = "Data/QuickLoad/TileData.mul";
string str2 = Engine.FileManager.BasePath(path);
FileInfo info = new FileInfo(Engine.FileManager.ResolveMUL(Files.Tiledata));
FileInfo info2 = new FileInfo(Engine.FileManager.ResolveMUL(Files.Animdata));
FileInfo info3 = new FileInfo(Engine.FileManager.ResolveMUL(Files.Verdata));
if (File.Exists(str2))
{
BinaryReader reader = new BinaryReader(Engine.FileManager.OpenBaseMUL(path));
DateTime time = DateTime.FromFileTime(reader.ReadInt64());
DateTime time2 = DateTime.FromFileTime(reader.ReadInt64());
DateTime time3 = DateTime.FromFileTime(reader.ReadInt64());
if (((reader.BaseStream.Length == ((((((0x4000 * sizeof(LandData)) + (0x4000 * sizeof(ItemData))) + 0x110000) + 8) + 8) + 8)) && (info.LastWriteTime == time)) && ((info2.LastWriteTime == time2) && (info3.LastWriteTime == time3)))
{
byte[] buffer = new byte[((0x4000 * sizeof(LandData)) + (0x4000 * sizeof(ItemData))) + 0x110000];
reader.BaseStream.Read(buffer, 0, buffer.Length);
m_Land = new LandData[0x4000];
m_Item = new ItemData[0x4000];
m_Anim = new AnimData[0x4000];
fixed (LandData* dataRef = m_Land)
{
LandData* dataPtr = dataRef;
fixed (ItemData* dataRef2 = m_Item)
{
ItemData* dataPtr2 = dataRef2;
fixed (AnimData* dataRef3 = m_Anim)
{
AnimData* dataPtr3 = dataRef3;
fixed (byte* numRef = buffer)
{
byte* numPtr = numRef;
LandData* dataPtr4 = (LandData*) numPtr;
int num = 0x4000;
while (--num >= 0)
{
dataPtr++;
dataPtr4++;
dataPtr[0] = dataPtr4[0];
}
ItemData* dataPtr5 = (ItemData*) dataPtr4;
num = 0x4000;
int num2 = -1;
m_ItemFlags = new TileFlags[0x4000];
while (--num >= 0)
{
m_ItemFlags[++num2].Value = dataPtr5->m_Flags;
dataPtr2++;
dataPtr5++;
dataPtr2[0] = dataPtr5[0];
}
num = 0x4000;
numPtr = (byte*) dataPtr5;
sbyte* pAnims = m_pAnims;
while (--num >= 0)
{
dataPtr3->pvFrames = pAnims;
pAnims += 0x40;
int* pvFrames = (int*) dataPtr3->pvFrames;
int* numPtr4 = (int*) numPtr;
pvFrames[0] = numPtr4[0];
pvFrames[1] = numPtr4[1];
pvFrames[2] = numPtr4[2];
pvFrames[3] = numPtr4[3];
pvFrames[4] = numPtr4[4];
pvFrames[5] = numPtr4[5];
pvFrames[6] = numPtr4[6];
pvFrames[7] = numPtr4[7];
pvFrames[8] = numPtr4[8];
pvFrames[9] = numPtr4[9];
pvFrames[10] = numPtr4[10];
pvFrames[11] = numPtr4[11];
pvFrames[12] = numPtr4[12];
pvFrames[13] = numPtr4[13];
pvFrames[14] = numPtr4[14];
pvFrames[15] = numPtr4[15];
numPtr += 0x40;
dataPtr3->unknown = *(numPtr++);
dataPtr3->frameCount = *(numPtr++);
dataPtr3->frameInterval = *(numPtr++);
dataPtr3->frameStartInterval = *(numPtr++);
dataPtr3++;
}
}
}
}
}
reader.Close();
Debug.EndBlock();
return;
}
reader.Close();
}
m_Land = new LandData[0x4000];
m_Item = new ItemData[0x4000];
int count = 0x68800;
byte[] buffer2 = new byte[count];
Stream stream = Engine.FileManager.OpenMUL(Files.Tiledata);
stream.Read(buffer2, 0, count);
fixed (LandData* dataRef4 = m_Land)
{
LandData* dataPtr6 = dataRef4;
fixed (byte* numRef2 = buffer2)
{
int num4 = 0;
byte* numPtr5 = numRef2;
while (num4++ < 0x200)
{
numPtr5 += 4;
int num5 = 0;
while (num5++ < 0x20)
{
dataPtr6->m_Flags = *((int*) numPtr5);
dataPtr6->m_Texture = *((short*) (numPtr5 + 4));
dataPtr6++;
numPtr5 += 0x1a;
}
}
}
}
count = 0x94800;
buffer2 = new byte[count];
stream.Read(buffer2, 0, count);
fixed (ItemData* dataRef5 = m_Item)
{
ItemData* dataPtr7 = dataRef5;
fixed (byte* numRef3 = buffer2)
{
int num6 = 0;
byte* numPtr6 = numRef3;
int num7 = 0;
while (num6++ < 0x200)
{
numPtr6 += 4;
int num8 = 0;
while (num8++ < 0x20)
{
num7++;
dataPtr7->m_Flags = *((int*) numPtr6);
dataPtr7->m_Weight = numPtr6[4];
dataPtr7->m_Quality = numPtr6[5];
dataPtr7->m_Extra = numPtr6[6];
dataPtr7->m_Quantity = numPtr6[9];
dataPtr7->m_Animation = *((short*) (numPtr6 + 10));
dataPtr7->m_Value = numPtr6[15];
dataPtr7->m_Height = numPtr6[0x10];
dataPtr7++;
numPtr6 += 0x25;
}
}
}
}
stream.Close();
m_Anim = new AnimData[0x4000];
count = 0x112000;
buffer2 = new byte[count];
Stream stream2 = Engine.FileManager.OpenMUL(Files.Animdata);
stream2.Read(buffer2, 0, count);
stream2.Close();
fixed (AnimData* dataRef6 = m_Anim)
{
AnimData* dataPtr8 = dataRef6;
fixed (byte* numRef4 = buffer2)
{
byte* numPtr7 = numRef4;
int num9 = 0;
sbyte* numPtr8 = m_pAnims;
while (num9++ < 0x800)
{
numPtr7 += 4;
int num10 = 0;
while (num10++ < 8)
{
dataPtr8->pvFrames = numPtr8;
numPtr8 += 0x40;
sbyte* numPtr9 = (sbyte*) numPtr7;
for (int i = 0; i < 0x40; i++)
{
dataPtr8->pvFrames[i] = *(numPtr9++);
}
numPtr7 += 0x40;
dataPtr8->unknown = *(numPtr7++);
dataPtr8->frameCount = *(numPtr7++);
dataPtr8->frameInterval = *(numPtr7++);
dataPtr8->frameStartInterval = *(numPtr7++);
dataPtr8++;
}
}
}
}
Stream stream3 = Engine.FileManager.OpenMUL(Files.Verdata);
buffer2 = new byte[stream3.Length];
stream3.Read(buffer2, 0, buffer2.Length);
stream3.Close();
fixed (byte* numRef5 = buffer2)
{
int* numPtr10 = (int*) numRef5;
numPtr10++;
int num12 = numPtr10[0];
int num13 = 0;
while (num13++ < num12)
{
numPtr10++;
int num14 = numPtr10[0];
if (num14 == 30)
{
numPtr10++;
int num15 = numPtr10[0];
numPtr10++;
int num16 = numPtr10[0];
numPtr10++;
int num17 = numPtr10[0];
numPtr10++;
int num18 = numPtr10[0];
if (num15 < 0x200)
{
fixed (LandData* dataRef7 = m_Land)
{
LandData* dataPtr9 = dataRef7;
dataPtr9 += num15 * 0x20;
byte* numPtr11 = (numRef5 + num16) + 4;
int num19 = 0;
while (num19++ < 0x20)
{
dataPtr9->m_Flags = *((int*) numPtr11);
dataPtr9->m_Texture = *((short*) (numPtr11 + 4));
dataPtr9++;
numPtr11 += 0x1a;
}
}
}
else if (num15 < 0x400)
{
fixed (ItemData* dataRef8 = m_Item)
{
ItemData* dataPtr10 = dataRef8;
dataPtr10 += (num15 - 0x200) * 0x20;
byte* numPtr12 = (numRef5 + num16) + 4;
int num20 = 0;
while (num20++ < 0x20)
{
dataPtr10->m_Flags = *((int*) numPtr12);
dataPtr10->m_Weight = numPtr12[4];
dataPtr10->m_Quality = numPtr12[5];
dataPtr10->m_Quantity = numPtr12[9];
dataPtr10->m_Animation = *((short*) (numPtr12 + 10));
dataPtr10->m_Value = numPtr12[15];
dataPtr10->m_Height = numPtr12[0x10];
dataPtr10++;
numPtr12 += 0x25;
}
}
}
}
else
{
numPtr10 += 4;
}
}
}
BinaryWriter writer = new BinaryWriter(Engine.FileManager.CreateBaseMUL(path));
writer.Write(info.LastWriteTime.ToFileTime());
writer.Write(info2.LastWriteTime.ToFileTime());
writer.Write(info3.LastWriteTime.ToFileTime());
fixed (LandData* dataRef9 = m_Land)
{
LandData* dataPtr11 = dataRef9;
fixed (ItemData* dataRef10 = m_Item)
{
ItemData* dataPtr12 = dataRef10;
fixed (AnimData* dataRef11 = m_Anim)
{
AnimData* dataPtr13 = dataRef11;
byte[] buffer3 = new byte[(0x4000 * sizeof(LandData)) + (0x4000 * sizeof(ItemData))];
fixed (byte* numRef6 = buffer3)
{
LandData* dataPtr14 = (LandData*) numRef6;
for (int k = 0; k < 0x4000; k++)
{
dataPtr14++;
dataPtr11++;
dataPtr14[0] = dataPtr11[0];
}
ItemData* dataPtr15 = (ItemData*) dataPtr14;
m_ItemFlags = new TileFlags[0x4000];
for (int m = 0; m < 0x4000; m++)
{
m_ItemFlags[m].Value = dataPtr12->m_Flags;
dataPtr15++;
dataPtr12++;
dataPtr15[0] = dataPtr12[0];
}
}
writer.Write(buffer3);
for (int j = 0; j < 0x4000; j++)
{
for (int n = 0; n < 0x40; n++)
{
writer.Write(dataPtr13->pvFrames[n]);
}
writer.Write(dataPtr13->unknown);
writer.Write(dataPtr13->frameCount);
writer.Write(dataPtr13->frameInterval);
writer.Write(dataPtr13->frameStartInterval);
dataPtr13++;
}
}
}
}
writer.Flush();
writer.Close();
Debug.EndBlock();
}
public static unsafe void ExecuteComman_Unrestricted(string command)
{
sbyte *execute = MemoryManager.StringToChar(command);
CEngineClient.Instance.ClientCmd_Unrestricted(execute);
}
internal static extern unsafe void ShowText(sbyte *utf8, uint cr);
public static unsafe Vector128 <sbyte> LoadDquVector128(sbyte *address)
{
throw new PlatformNotSupportedException();
}
internal static extern unsafe uint ImageSurfaceFromPng(sbyte *filename);
public static extern NrtResult Nrt_WindowingService_initialiseWindow([NativeTypeName("NrtWindowingServiceHandle")] IntPtr service, [NativeTypeName("int32_t")] int displayNumber, [NativeTypeName("const char *")] sbyte *windowTitle, NrtWindowMode windowMode, [NativeTypeName("int32_t")] int transparencyEnabled);
public ID3D10EffectVariable *GetAnnotationByName([NativeTypeName("LPCSTR")] sbyte *Name)
{
return(((delegate * unmanaged <ID3D10EffectConstantBuffer *, sbyte *, ID3D10EffectVariable *>)(lpVtbl[4]))((ID3D10EffectConstantBuffer *)Unsafe.AsPointer(ref this), Name));
}
public static extern NrtResult Nrt_WindowingService_setWindowTitle([NativeTypeName("NrtWindowingServiceHandle")] IntPtr service, [NativeTypeName("const char *")] sbyte *value);
public static unsafe string GetUTF8String(sbyte *bytes)
{
return(Marshal.PtrToStringUTF8((IntPtr)bytes));
}
//[Verify(PlatformInvoke)] static extern unsafe NSString RTCFileName(sbyte* filePath);
public ID3D12ShaderReflectionType *GetMemberTypeByName([NativeTypeName("LPCSTR")] sbyte *Name)
{
return(((delegate * unmanaged <ID3D12ShaderReflectionType *, sbyte *, ID3D12ShaderReflectionType *>)(lpVtbl[2]))((ID3D12ShaderReflectionType *)Unsafe.AsPointer(ref this), Name));
}
public static extern pa_channel_position_t pa_channel_position_from_string([NativeTypeName("const char *")] sbyte *s);
static unsafe int Main(string[] args)
{
int testResult = Pass;
if (Avx.IsSupported)
{
{
byte * inBuffer = stackalloc byte[64];
float *inArray = (float *)Align(inBuffer, 32);
float *outArray = stackalloc float[8];
var vf = Avx.LoadAlignedVector256(inArray);
Unsafe.Write(outArray, vf);
for (var i = 0; i < 8; i++)
{
if (BitConverter.SingleToInt32Bits(inArray[i]) != BitConverter.SingleToInt32Bits(outArray[i]))
{
Console.WriteLine("AVX LoadAlignedVector256 failed on float:");
for (var n = 0; n < 8; n++)
{
Console.Write(outArray[n] + ", ");
}
Console.WriteLine();
testResult = Fail;
break;
}
}
}
{
byte * inBuffer = stackalloc byte[64];
double *inArray = (double *)Align(inBuffer, 32);
double *outArray = stackalloc double[4];
var vf = Avx.LoadAlignedVector256(inArray);
Unsafe.Write(outArray, vf);
for (var i = 0; i < 4; i++)
{
if (BitConverter.DoubleToInt64Bits(inArray[i]) != BitConverter.DoubleToInt64Bits(outArray[i]))
{
Console.WriteLine("AVX LoadAlignedVector256 failed on double:");
for (var n = 0; n < 4; n++)
{
Console.Write(outArray[n] + ", ");
}
Console.WriteLine();
testResult = Fail;
break;
}
}
}
{
byte *inBuffer = stackalloc byte[64];
int * inArray = (int *)Align(inBuffer, 32);
int * outArray = stackalloc int[8];
var vf = Avx.LoadAlignedVector256(inArray);
Unsafe.Write(outArray, vf);
for (var i = 0; i < 8; i++)
{
if (inArray[i] != outArray[i])
{
Console.WriteLine("AVX LoadAlignedVector256 failed on int:");
for (var n = 0; n < 8; n++)
{
Console.Write(outArray[n] + ", ");
}
Console.WriteLine();
testResult = Fail;
break;
}
}
}
{
byte *inBuffer = stackalloc byte[64];
long *inArray = (long *)Align(inBuffer, 32);
long *outArray = stackalloc long[4];
var vf = Avx.LoadAlignedVector256(inArray);
Unsafe.Write(outArray, vf);
for (var i = 0; i < 4; i++)
{
if (inArray[i] != outArray[i])
{
Console.WriteLine("AVX LoadAlignedVector256 failed on long:");
for (var n = 0; n < 4; n++)
{
Console.Write(outArray[n] + ", ");
}
Console.WriteLine();
testResult = Fail;
break;
}
}
}
{
byte *inBuffer = stackalloc byte[64];
uint *inArray = (uint *)Align(inBuffer, 32);
uint *outArray = stackalloc uint[8];
var vf = Avx.LoadAlignedVector256(inArray);
Unsafe.Write(outArray, vf);
for (var i = 0; i < 8; i++)
{
if (inArray[i] != outArray[i])
{
Console.WriteLine("AVX LoadAlignedVector256 failed on uint:");
for (var n = 0; n < 8; n++)
{
Console.Write(outArray[n] + ", ");
}
Console.WriteLine();
testResult = Fail;
break;
}
}
}
{
byte * inBuffer = stackalloc byte[64];
ulong *inArray = (ulong *)Align(inBuffer, 32);
ulong *outArray = stackalloc ulong[4];
var vf = Avx.LoadAlignedVector256(inArray);
Unsafe.Write(outArray, vf);
for (var i = 0; i < 4; i++)
{
if (inArray[i] != outArray[i])
{
Console.WriteLine("AVX LoadAlignedVector256 failed on ulong:");
for (var n = 0; n < 4; n++)
{
Console.Write(outArray[n] + ", ");
}
Console.WriteLine();
testResult = Fail;
break;
}
}
}
{
byte * inBuffer = stackalloc byte[64];
short *inArray = (short *)Align(inBuffer, 32);
short *outArray = stackalloc short[16];
var vf = Avx.LoadAlignedVector256(inArray);
Unsafe.Write(outArray, vf);
for (var i = 0; i < 16; i++)
{
if (inArray[i] != outArray[i])
{
Console.WriteLine("AVX LoadAlignedVector256 failed on short:");
for (var n = 0; n < 16; n++)
{
Console.Write(outArray[n] + ", ");
}
Console.WriteLine();
testResult = Fail;
break;
}
}
}
{
byte * inBuffer = stackalloc byte[64];
ushort *inArray = (ushort *)Align(inBuffer, 32);
ushort *outArray = stackalloc ushort[16];
var vf = Avx.LoadAlignedVector256(inArray);
Unsafe.Write(outArray, vf);
for (var i = 0; i < 16; i++)
{
if (inArray[i] != outArray[i])
{
Console.WriteLine("AVX LoadAlignedVector256 failed on ushort:");
for (var n = 0; n < 16; n++)
{
Console.Write(outArray[n] + ", ");
}
Console.WriteLine();
testResult = Fail;
break;
}
}
}
{
byte * inBuffer = stackalloc byte[64];
sbyte *inArray = (sbyte *)Align(inBuffer, 32);
sbyte *outArray = stackalloc sbyte[32];
var vf = Avx.LoadAlignedVector256(inArray);
Unsafe.Write(outArray, vf);
for (var i = 0; i < 32; i++)
{
if (inArray[i] != outArray[i])
{
Console.WriteLine("AVX LoadAlignedVector256 failed on sbyte:");
for (var n = 0; n < 32; n++)
{
Console.Write(outArray[n] + ", ");
}
Console.WriteLine();
testResult = Fail;
break;
}
}
}
{
byte *inBuffer = stackalloc byte[64];
byte *inArray = (byte *)Align(inBuffer, 32);
byte *outArray = stackalloc byte[32];
var vf = Avx.LoadAlignedVector256(inArray);
Unsafe.Write(outArray, vf);
for (var i = 0; i < 32; i++)
{
if (inArray[i] != outArray[i])
{
Console.WriteLine("AVX LoadAlignedVector256 failed on byte:");
for (var n = 0; n < 32; n++)
{
Console.Write(outArray[n] + ", ");
}
Console.WriteLine();
testResult = Fail;
break;
}
}
}
}
return(testResult);
}
public static extern sbyte *pa_channel_map_snprint([NativeTypeName("char *")] sbyte *s, [NativeTypeName("size_t")] nuint l, [NativeTypeName("const pa_channel_map *")] pa_channel_map *map);
public CString(byte *str)
{
nativeString = (sbyte *)str;
}
public static extern pa_channel_map *pa_channel_map_parse(pa_channel_map *map, [NativeTypeName("const char *")] sbyte *s);
/// <summary>
/// Create JVM.
/// </summary>
/// <returns>JVM.</returns>
private static void* CreateJvm(IgniteConfiguration cfg, UnmanagedCallbacks cbs)
{
var ggHome = GetIgniteHome(cfg);
var cp = CreateClasspath(ggHome, cfg, false);
var jvmOpts = GetMergedJvmOptions(cfg);
var hasGgHome = !string.IsNullOrWhiteSpace(ggHome);
var opts = new sbyte*[1 + jvmOpts.Count + (hasGgHome ? 1 : 0)];
int idx = 0;
opts[idx++] = IgniteUtils.StringToUtf8Unmanaged(cp);
if (hasGgHome)
opts[idx++] = IgniteUtils.StringToUtf8Unmanaged("-DIGNITE_HOME=" + ggHome);
foreach (string cfgOpt in jvmOpts)
opts[idx++] = IgniteUtils.StringToUtf8Unmanaged(cfgOpt);
try
{
IntPtr mem = Marshal.AllocHGlobal(opts.Length * 8);
fixed (sbyte** opts0 = opts)
{
PlatformMemoryUtils.CopyMemory(opts0, mem.ToPointer(), opts.Length * 8);
}
try
{
return UU.CreateContext(mem.ToPointer(), opts.Length, cbs.CallbacksPointer);
}
finally
{
Marshal.FreeHGlobal(mem);
}
}
finally
{
foreach (sbyte* opt in opts)
Marshal.FreeHGlobal((IntPtr)opt);
}
}
public ID3D10EffectVariable *GetMemberByName([NativeTypeName("LPCSTR")] sbyte *Name)
{
return(((delegate * unmanaged <ID3D10EffectSamplerVariable *, sbyte *, ID3D10EffectVariable *>)(lpVtbl[6]))((ID3D10EffectSamplerVariable *)Unsafe.AsPointer(ref this), Name));
}
/// <summary>
///
/// </summary>
/// <param name="Type"></param>
/// <param name="Args"></param>
public static int RunTypeMain(Type Type, string[] Args)
{
try
{
//Marshal.PrelinkAll(Type);
Args = new string[] { Process.GetCurrentProcess().MainModule.FileName }.Concat(Args).ToArray();
var MainMethod = Type.GetMethod("main");
var MainParameters = MainMethod.GetParameters();
object Result = null;
if (MainParameters.Length == 0)
{
Result = MainMethod.Invoke(null, new object[] { });
}
else if (MainParameters.Length == 2)
{
if (MainParameters[0].ParameterType == typeof(int) && MainParameters[1].ParameterType == typeof(sbyte**))
{
var ArgArray = new sbyte*[Args.Length];
fixed (sbyte** ArgArrayPointer = ArgArray)
{
for (int n = 0; n < ArgArray.Length; n++) ArgArrayPointer[n] = GetLiteralStringPointer(Args[n]);
CInternals._argc = Args.Length;
CInternals._argv = ArgArrayPointer;
Result = MainMethod.Invoke(null, new object[] { Args.Length, (IntPtr)ArgArrayPointer });
}
}
else
{
throw (new InvalidProgramException("Invalid 'main' signature : wrong parameters"));
}
}
else
{
throw (new InvalidProgramException(String.Format("Invalid number of 'main' parameters expected [0 or 2] and have {0}", MainParameters.Length)));
}
if (Result == null)
{
return -1;
}
else if (MainMethod.ReturnType == typeof(void))
{
return 0;
}
else if (MainMethod.ReturnType == typeof(int))
{
return (int)Result;
}
else
{
throw (new InvalidProgramException("Function 'main' signature should return int or void"));
}
}
catch (Exception Exception)
{
Console.Error.WriteLine(Exception);
return -1;
}
}
public unsafe long PointerSubtraction4(sbyte *p, sbyte *q)
{
return(p - q);
}
public void InternalRelease()
{
lock (ReleaseLock)
{
if (Picture != null)
ffmpeg.av_free(Picture);
if (PictureBuffer != null)
ffmpeg.av_free(PictureBuffer);
Picture = null;
PictureBuffer = null;
PictureBufferPtr = IntPtr.Zero;
PictureBufferLength = 0;
}
}
public sp_nativeinfo_s(string name, IntPtr function)
{
var bytes = Encoding.ASCII.GetBytes(name);
var b = new byte[bytes.Length + 1];
bytes.CopyTo(b, 0);
var buffer = Marshal.AllocHGlobal(b.Length);
Marshal.Copy(b, 0, buffer, b.Length);
this.name = (sbyte *)buffer;
this.function = function;
}
