private unsafe void Issue990() { Data data = default(Data); Data *ptr = &data; ConvertIntToFloat(ptr->Position.GetHashCode()); }
public JsonStandardValidator(Allocator label = SerializationConfiguration.DefaultAllocatorLabel) { m_Label = label; m_Data = (Data *)UnsafeUtility.Malloc(sizeof(Data), UnsafeUtility.AlignOf <Data>(), label); m_Data->Stack = new JsonTypeStack(k_DefaultDepthLimit, label); Reset(); }
/* * [DllImport("kernel32.dll", SetLastError = true, CallingConvention = CallingConvention.Winapi)] * static extern IntPtr LoadLibrary(string lpFileName); * * [DllImport("kernel32.dll", SetLastError = true, CallingConvention = CallingConvention.Winapi)] * static extern bool FreeLibrary(IntPtr hModule); * * [DllImport("kernel32.dll", SetLastError = true, CallingConvention = CallingConvention.Winapi)] * static extern IntPtr GetProcAddress(IntPtr hModule, string lpProcName); */ static void Main(string[] args) { Console.WriteLine(string.Format("Size Of UnionData : {0}", Marshal.SizeOf(typeof(UnionData)))); Console.WriteLine(string.Format("Size Of Data : {0}", Marshal.SizeOf(typeof(Data)))); Data *dataPtr = CreateData(); Console.WriteLine(string.Format("FieldInteger Value : {0}", dataPtr->FieldInteger)); Console.WriteLine(string.Format("FieldDouble Value : {0}", dataPtr->FieldDouble)); switch (dataPtr->DataType) { case DataType.DtInteger: { Console.WriteLine(string.Format("UnionData.FieldInteger Value : {0}", dataPtr->UnionData.FieldInteger)); break; } case DataType.DtDouble: { Console.WriteLine(string.Format("UnionData.FieldDouble Value : {0}", dataPtr->UnionData.FieldDouble)); break; } default: { Console.WriteLine("UnKnown ?? "); break; } } RemoveData(dataPtr); }
public JsonTokenizer(int bufferSize = k_DefaultBufferSize, JsonValidationType validation = JsonValidationType.None, Allocator label = SerializationConfiguration.DefaultAllocatorLabel) { m_Label = label; m_Data = (Data *)UnsafeUtility.Malloc(sizeof(Data), UnsafeUtility.AlignOf <Data>(), label); UnsafeUtility.MemClear(m_Data, sizeof(Data)); m_Data->BufferSize = bufferSize; m_Data->ValidationType = validation; if (bufferSize <= 0) { throw new ArgumentException($"Token buffer size {bufferSize} <= 0"); } m_Data->JsonTokens = (Token *)UnsafeUtility.Malloc(bufferSize * sizeof(Token), 4, label); m_Data->DiscardRemap = (int *)UnsafeUtility.Malloc(bufferSize * sizeof(int), 4, label); switch (validation) { case JsonValidationType.Standard: m_Data->StandardValidator = new JsonStandardValidator(label); break; case JsonValidationType.Simple: m_Data->SimpleValidator = new JsonSimpleValidator(label); break; } m_Data->TokenNextIndex = 0; m_Data->TokenParentIndex = -1; m_Data->PrevChar = 0; }
/// <inheritdoc/> public void Dispose() { m_Buffer.Dispose(); m_Stack.Dispose(); UnsafeUtility.Free(m_Data, m_Label); m_Data = null; }
public LiveRange(int start, int end, LiveRange next = default) { _data = Allocators.LiveRanges.Allocate <Data>(); Start = start; End = end; Next = next; }
public void Dispose() { if (null != m_Data) { m_Data->Stack.Dispose(); UnsafeUtility.Free(m_Data, m_Label); m_Data = null; } }
/// <summary> /// Initializes a new instance of <see cref="Unsafe"/>. /// </summary> /// <param name="initialCapacity">The initial capacity to use for the internal buffer.</param> /// <param name="label">The allocator label to use.</param> /// <param name="options">Options to define custom behaviour.</param> public Unsafe(int initialCapacity, Allocator label, JsonWriterOptions options = default) { m_Label = label; m_Data = (Data *)UnsafeUtility.Malloc(sizeof(Data), UnsafeUtility.AlignOf <Data>(), label); UnsafeUtility.MemClear(m_Data, sizeof(Data)); m_Buffer = new NativeList <char>(initialCapacity, label); m_Stack = new NativeList <State>(label); m_Options = options; }
public void Dispose() { if (null == m_Data) { return; } UnsafeUtility.Free(m_Data, m_Label); m_Data = null; }
/// <summary> /// Initializes a new instance of <see cref="JsonStringBuffer"/>. /// </summary> /// <param name="initialCapacity">The initial capacity to use for the internal buffer.</param> /// <param name="label">The allocator label to use.</param> public JsonStringBuffer(int initialCapacity, Allocator label) { m_Label = label; m_Data = (Data *)UnsafeUtility.Malloc(sizeof(Data), UnsafeUtility.AlignOf <Data>(), label); m_Data->Buffer = null; m_Data->Capacity = 0; m_Data->Length = 0; SetCapacity(initialCapacity); }
/// <inheritdoc/> public void Dispose() { if (m_Label != Allocator.Invalid) { UnsafeUtility.Free(m_Data->Buffer, m_Label); } UnsafeUtility.Free(m_Data, m_Label); m_Data = null; }
public PackedBinaryWriter(PackedBinaryStream stream, JsonTokenizer tokenizer, Allocator label) { m_Label = label; m_Data = (Data *)UnsafeUtility.Malloc(sizeof(Data), UnsafeUtility.AlignOf <Data>(), label); UnsafeUtility.MemClear(m_Data, sizeof(Data)); m_Stream = stream; m_Tokenizer = tokenizer; m_Data->InputTokenNextIndex = 0; m_Data->InputTokenParentIndex = -1; }
public LiveInterval(Operand local = default, LiveInterval parent = default) { _data = Allocators.LiveIntervals.Allocate <Data>(); *_data = default; _data->IsFixed = false; _data->Local = local; Parent = parent == default ? this : parent; Uses = new UseList(); Children = new LiveIntervalList(); FirstRange = default; CurrRange = default; PrevRange = default; SpillOffset = -1; }
private static Operation Make(Instruction inst, int destCount, int srcCount) { Data *data = Allocators.Operations.Allocate <Data>(); *data = default; Operation result = new(); result._data = data; result.Instruction = inst; EnsureCapacity(ref result._data->Destinations, ref result._data->DestinationsCount, destCount); EnsureCapacity(ref result._data->Sources, ref result._data->SourcesCount, srcCount); result.Destinations.Clear(); result.Sources.Clear(); return(result); }
public NodeParser(JsonTokenizer tokenizer, int batchSize, Allocator label) { m_Label = label; m_Data = (Data *)UnsafeUtility.Malloc(sizeof(Data), UnsafeUtility.AlignOf <Data>(), label); UnsafeUtility.MemClear(m_Data, sizeof(Data)); m_Data->Tokenizer = tokenizer; m_Data->NodeType = NodeType.None; if (batchSize < 1) { throw new ArgumentException("batchSize < 1"); } m_Data->Nodes = (int *)UnsafeUtility.Malloc(sizeof(int) * batchSize, 4, m_Label); m_Data->NodeLength = batchSize; m_Data->NodeNextIndex = 0; m_Data->TokenNextIndex = 0; m_Data->TokenParentIndex = -1; }
public void Dispose() { if (null == m_Data) { return; } UnsafeUtility.Free(m_Data->JsonTokens, m_Label); UnsafeUtility.Free(m_Data->DiscardRemap, m_Label); switch (m_Data->ValidationType) { case JsonValidationType.Simple: case JsonValidationType.Standard: m_Data->Validator.Dispose(); break; } UnsafeUtility.Free(m_Data, m_Label); m_Data = null; }
public MemoryOperand(Operand operand) { Debug.Assert(operand.Kind == OperandKind.Memory); _data = (Data *)Unsafe.As <Operand, IntPtr>(ref operand); }
private static Operand Make(OperandKind kind, OperandType type, ulong value, Symbol symbol = default) { Debug.Assert(kind != OperandKind.None); Data *data = null; // If constant or register, then try to look up in the intern table before allocating. if (kind == OperandKind.Constant || kind == OperandKind.Register) { uint hash = (uint)HashCode.Combine(kind, type, value); // Look in the next InternTableProbeLength slots for a match. for (uint i = 0; i < InternTableProbeLength; i++) { Operand interned = new(); interned._data = &InternTable[(hash + i) % InternTableSize]; // If slot matches the allocation request then return that slot. if (interned.Kind == kind && interned.Type == type && interned.Value == value && interned.Symbol == symbol) { return(interned); } // Otherwise if the slot is not occupied, we store in that slot. else if (interned.Kind == OperandKind.None) { data = interned._data; break; } } } // If we could not get a slot from the intern table, we allocate somewhere else and store there. if (data == null) { data = Allocators.Operands.Allocate <Data>(); } *data = default; Operand result = new(); result._data = data; result.Value = value; result.Kind = kind; result.Type = type; if (kind != OperandKind.Memory) { result.Symbol = symbol; } // If local variable, then the use and def list is initialized with default sizes. if (kind == OperandKind.LocalVariable) { New(ref result._data->Assignments, ref result._data->AssignmentsCount, ref result._data->AssignmentsCapacity, 1); New(ref result._data->Uses, ref result._data->UsesCount, ref result._data->UsesCapacity, 4); } return(result); }
public A(Data *data) { this.data = data; }
static extern void RemoveData(Data *dataPtr);
public unsafe Foo(Data *data) { Value1 = data->Value1; Value2 = data->Value2; Value3 = data->Value3; }
public unsafe static int ReturnRefDataCMember([DNNE.C99Type("struct T*")] Data *d) { return(d->c); }