/// <inheritdoc /> public void WriteFloat32(int offset, Float32Value value) { if (IsKnown) { BasePointer.WriteFloat32(CurrentOffset + offset, value); } }
/// <inheritdoc /> public void WriteFloat32(int offset, Float32Value value) { if (IsKnown) { ReferencedMemory.WriteFloat32(CurrentOffset + offset, value); } }
public void ReadWriteFloat32() { var ptrValue = new MemoryBlockValue(4); var value = new Float32Value(0.12345678f); ptrValue.WriteFloat32(0, value); Assert.Equal(value.F32, ptrValue.ReadFloat32(0).F32); }
/// <inheritdoc /> public unsafe void WriteFloat32(int offset, Float32Value value) { AssertOffsetValidity(offset, sizeof(float)); // Note: There is unfortunately no BinaryPrimitives method for writing single or double values in // .NET Standard 2.0. Hence we go the unsafe route. using var handle = _memory.Pin(); *(float *)((byte *)handle.Pointer + offset) = value.F32; _knownBitMask.Span.Slice(offset, 4).Fill(0xFF); }
public void ReadWriteFloat32() { using var memoryOwner = MemoryPool <byte> .Shared.Rent(4); using var bitmaskOwner = MemoryPool <byte> .Shared.Rent(4); var ptrValue = new MemoryPointerValue(memoryOwner.Memory, bitmaskOwner.Memory, true); var value = new Float32Value(0.12345678f); ptrValue.WriteFloat32(0, value); Assert.Equal(value.F32, ptrValue.ReadFloat32(0).F32); }
public void PersistentBits() { const float testValue = 0.123f; var value = new Float32Value(testValue); Span <byte> buffer = stackalloc byte[sizeof(float)]; Span <byte> mask = stackalloc byte[sizeof(float)]; value.GetBits(buffer); value.GetMask(mask); value.SetBits(buffer, mask); Assert.Equal(testValue, value.F32); }
// Methods public override string ToString() { switch (typetag) { case TypeTag.OscInt32: return(Int32Value.ToString()); case TypeTag.OscFloat32: return(Float32Value.ToString()); case TypeTag.OscString: return(StringValue ?? "null"); case TypeTag.OscBlob: return(BlobValue != null ? BitConverter.ToString(BlobValue) : "null"); default: return("unknown"); } }
/// <inheritdoc /> public void WriteFloat32(int offset, Float32Value value) => Contents.WriteFloat32(offset, value);
public override void Execute(Context context, IEnumerable <MetadataMember> targets) { if (!context.IsReflectionCorlibSafe) { return; } foreach (var Method in targets.OfType <MethodDefinition>().Where(m => m.CilMethodBody is not null)) { var Instructions = Method.CilMethodBody.Instructions; Method.CilMethodBody.ConstructSymbolicFlowGraph(out var DFG); /* Dfg Constructing. */ for (int x = 0; x < Instructions.Count; x++) { var Instr = Instructions[x]; /* Some People Make It Callvirt To Deafet Public tools :p */ if ((Instr.IsCode(CilCode.Call) || Instr.IsCode(CilCode.Callvirt)) && Instr.IsFromNS("System", "Math") && DFG.Nodes.Contains(Instr.Offset)) { var CallNode = DFG.Nodes[Instr.Offset] .GetOrderedDependencies(DependencyCollectionFlags.IncludeStackDependencies) .ToList(); if (CallNode.Any(x => x.Contents.OpCode.OperandType == CilOperandType.InlineMethod)) { continue; } var vm = new CilVirtualMachine(Method.CilMethodBody, context.Module.Is32Module()); var ex = new CilExecutionContext(vm, vm.CurrentState, default); foreach (var Dep in CallNode) { var CInstr = Dep.Contents; vm.Dispatcher.Execute(ex, CInstr); CInstr.Nop(); } var ISlot = new object[((IMethodDescriptor)Instr.Operand) .Signature.GetTotalParameterCount()]; for (int i = 0; i < ISlot.Length; i++) { var Value = vm.CurrentState.Stack.Pop(); ISlot[i] = Value switch { I4Value I4 => I4.I32, I8Value I8 => I8.I64, FValue F => F.F64, Float32Value F32 => F32.F32, Float64Value F64 => F64.F64, Integer16Value I6 => I6.I16, Integer32Value I32 => I32.I32, Integer64Value I64 => I64.I64, _ => throw new NotSupportedException(nameof(Value)) }; } var InvocationValue = context.ReflectionCorlib.ResolveMethod(((IMethodDescriptor)Instr.Operand).MetadataToken.ToInt32()) .Invoke(null, ISlot); Instr.OpCode = ((IMethodDescriptor)Instr.Operand).Signature.ReturnType.ElementType switch { ElementType.I4 => CilOpCodes.Ldc_I4, ElementType.I8 => CilOpCodes.Ldc_I8, ElementType.R4 => CilOpCodes.Ldc_R4, ElementType.R8 => CilOpCodes.Ldc_R8, _ => CilOpCodes.Ldc_I4, }; Instr.Operand = InvocationValue; } } } } }