From 7f890e16726039e8ada1fc289cd0244068769174 Mon Sep 17 00:00:00 2001 From: KN4CK3R Date: Sun, 22 Nov 2020 20:02:15 +0100 Subject: [PATCH 1/5] Removed unused constructor. Prevent negative size. --- ReClass.NET/Memory/MemoryBuffer.cs | 14 +++----------- ReClass.NET_Tests/Memory/MemoryBufferTest.cs | 7 +++++-- 2 files changed, 8 insertions(+), 13 deletions(-) diff --git a/ReClass.NET/Memory/MemoryBuffer.cs b/ReClass.NET/Memory/MemoryBuffer.cs index 52f874b5..c6e847fe 100644 --- a/ReClass.NET/Memory/MemoryBuffer.cs +++ b/ReClass.NET/Memory/MemoryBuffer.cs @@ -20,7 +20,7 @@ public int Size get => data.Length; set { - if (value != data.Length) + if (value >= 0 && value != data.Length) { data = new byte[value]; historyData = new byte[value]; @@ -44,20 +44,12 @@ private void ObjectInvariants() } public MemoryBuffer() - : this(0) { Contract.Ensures(data != null); Contract.Ensures(historyData != null); - } - - public MemoryBuffer(int size) - { - Contract.Requires(size >= 0); - Contract.Ensures(data != null); - Contract.Ensures(historyData != null); - data = new byte[size]; - historyData = new byte[size]; + data = Array.Empty(); + historyData = Array.Empty(); } public MemoryBuffer(MemoryBuffer other) diff --git a/ReClass.NET_Tests/Memory/MemoryBufferTest.cs b/ReClass.NET_Tests/Memory/MemoryBufferTest.cs index 7e545f56..d9fb45a1 100644 --- a/ReClass.NET_Tests/Memory/MemoryBufferTest.cs +++ b/ReClass.NET_Tests/Memory/MemoryBufferTest.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Text; using NFluent; using ReClassNET.Memory; @@ -10,7 +10,10 @@ public class MemoryBufferTest { private static MemoryBuffer CreateFromBytes(params byte[] data) { - var buffer = new MemoryBuffer(data.Length); + var buffer = new MemoryBuffer + { + Size = data.Length + }; Array.Copy(data, buffer.RawData, data.Length); return buffer; } From 8f6bd4146a8e6ee843ed66209d26dae98b6a17cb Mon Sep 17 00:00:00 2001 From: KN4CK3R Date: Sun, 22 Nov 2020 20:16:10 +0100 Subject: [PATCH 2/5] Removed unused constant. --- ReClass.NET/ReClass.NET.csproj | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/ReClass.NET/ReClass.NET.csproj b/ReClass.NET/ReClass.NET.csproj index 9eb45804..76b54d3b 100644 --- a/ReClass.NET/ReClass.NET.csproj +++ b/ReClass.NET/ReClass.NET.csproj @@ -25,7 +25,7 @@ false $(SolutionDir)bin\Debug\x86\ $(SolutionDir)obj\$(Configuration)\x86\$(MSBuildProjectName)\ - TRACE;DEBUG;RECLASSNET32 + TRACE;DEBUG prompt 4 false @@ -79,7 +79,7 @@ true $(SolutionDir)bin\Release\x86\ $(SolutionDir)obj\$(Configuration)\x86\$(MSBuildProjectName)\ - TRACE;RECLASSNET32;RELEASE + TRACE;RELEASE prompt 4 From c0f7e53728dc3e794df2ef9d7b57882ed947b086 Mon Sep 17 00:00:00 2001 From: KN4CK3R Date: Sun, 22 Nov 2020 21:34:38 +0100 Subject: [PATCH 3/5] Added BigEndianBitConverter and LittleEndianBitConverter. --- ReClass.NET/ReClass.NET.csproj | 3 + .../Util/Conversion/BigEndianBitConverter.cs | 39 ++++++ .../Util/Conversion/EndianBitConverter.cs | 83 +++++++++++++ .../Conversion/LittleEndianBitConverter.cs | 39 ++++++ ReClass.NET_Tests/ReClass.NET_Tests.csproj | 3 + .../Conversion/BigEndianBitConverterTest.cs | 114 ++++++++++++++++++ .../Util/Conversion/EndianBitConverterTest.cs | 25 ++++ .../LittleEndianBitConverterTest.cs | 114 ++++++++++++++++++ 8 files changed, 420 insertions(+) create mode 100644 ReClass.NET/Util/Conversion/BigEndianBitConverter.cs create mode 100644 ReClass.NET/Util/Conversion/EndianBitConverter.cs create mode 100644 ReClass.NET/Util/Conversion/LittleEndianBitConverter.cs create mode 100644 ReClass.NET_Tests/Util/Conversion/BigEndianBitConverterTest.cs create mode 100644 ReClass.NET_Tests/Util/Conversion/EndianBitConverterTest.cs create mode 100644 ReClass.NET_Tests/Util/Conversion/LittleEndianBitConverterTest.cs diff --git a/ReClass.NET/ReClass.NET.csproj b/ReClass.NET/ReClass.NET.csproj index 76b54d3b..be3a033a 100644 --- a/ReClass.NET/ReClass.NET.csproj +++ b/ReClass.NET/ReClass.NET.csproj @@ -394,6 +394,9 @@ + + + diff --git a/ReClass.NET/Util/Conversion/BigEndianBitConverter.cs b/ReClass.NET/Util/Conversion/BigEndianBitConverter.cs new file mode 100644 index 00000000..4469dca0 --- /dev/null +++ b/ReClass.NET/Util/Conversion/BigEndianBitConverter.cs @@ -0,0 +1,39 @@ +using System; + +namespace ReClassNET.Util.Conversion +{ + public sealed class BigEndianBitConverter : EndianBitConverter + { + protected override long FromBytes(byte[] buffer, int index, int bytesToConvert) + { + if (buffer == null) + { + throw new ArgumentNullException(nameof(buffer)); + } + if (index + bytesToConvert > buffer.Length) + { + throw new ArgumentOutOfRangeException(nameof(index)); + } + + long ret = 0; + for (var i = 0; i < bytesToConvert; i++) + { + ret = unchecked((ret << 8) | buffer[index + i]); + } + return ret; + } + + protected override byte[] ToBytes(long value, int bytes) + { + var endOffset = bytes - 1; + + var buffer = new byte[bytes]; + for (var i = 0; i < bytes; i++) + { + buffer[endOffset - i] = unchecked((byte)(value & 0xFF)); + value >>= 8; + } + return buffer; + } + } +} diff --git a/ReClass.NET/Util/Conversion/EndianBitConverter.cs b/ReClass.NET/Util/Conversion/EndianBitConverter.cs new file mode 100644 index 00000000..eb231dd8 --- /dev/null +++ b/ReClass.NET/Util/Conversion/EndianBitConverter.cs @@ -0,0 +1,83 @@ +using System; +using System.Runtime.InteropServices; + +namespace ReClassNET.Util.Conversion +{ + public abstract class EndianBitConverter + { + public static LittleEndianBitConverter Little { get; } = new LittleEndianBitConverter(); + + public static BigEndianBitConverter Big { get; } = new BigEndianBitConverter(); + + public static EndianBitConverter System { get; } = BitConverter.IsLittleEndian ? (EndianBitConverter)Little : Big; + + + public bool ToBoolean(byte[] value, int startIndex) => BitConverter.ToBoolean(value, startIndex); + + public char ToChar(byte[] value, int startIndex) => unchecked((char)FromBytes(value, startIndex, 2)); + + public double ToDouble(byte[] value, int startIndex) => BitConverter.Int64BitsToDouble(ToInt64(value, startIndex)); + + public float ToSingle(byte[] value, int startIndex) => new Int32FloatUnion(ToInt32(value, startIndex)).FloatValue; + + public short ToInt16(byte[] value, int startIndex) => unchecked((short)FromBytes(value, startIndex, 2)); + + public int ToInt32(byte[] value, int startIndex) => unchecked((int)FromBytes(value, startIndex, 4)); + + public long ToInt64(byte[] value, int startIndex) => FromBytes(value, startIndex, 8); + + public ushort ToUInt16(byte[] value, int startIndex) => unchecked((ushort)FromBytes(value, startIndex, 2)); + + public uint ToUInt32(byte[] value, int startIndex) => unchecked((uint)FromBytes(value, startIndex, 4)); + + public ulong ToUInt64(byte[] value, int startIndex) => unchecked((ulong)FromBytes(value, startIndex, 8)); + + protected abstract long FromBytes(byte[] value, int index, int bytesToConvert); + + + public byte[] GetBytes(bool value) => BitConverter.GetBytes(value); + + public byte[] GetBytes(char value) => ToBytes(value, 2); + + public byte[] GetBytes(double value) => ToBytes(BitConverter.DoubleToInt64Bits(value), 8); + + public byte[] GetBytes(short value) => ToBytes(value, 2); + + public byte[] GetBytes(int value) => ToBytes(value, 4); + + public byte[] GetBytes(long value) => ToBytes(value, 8); + + public byte[] GetBytes(float value) => ToBytes(new Int32FloatUnion(value).IntValue, 4); + + public byte[] GetBytes(ushort value) => ToBytes(value, 2); + + public byte[] GetBytes(uint value) => ToBytes(value, 4); + + public byte[] GetBytes(ulong value) => ToBytes(unchecked((long)value), 8); + + protected abstract byte[] ToBytes(long value, int bytes); + + + [StructLayout(LayoutKind.Explicit)] + private readonly struct Int32FloatUnion + { + [FieldOffset(0)] + public readonly int IntValue; + + [FieldOffset(0)] + public readonly float FloatValue; + + internal Int32FloatUnion(int value) + { + FloatValue = 0.0f; + IntValue = value; + } + + internal Int32FloatUnion(float value) + { + IntValue = 0; + FloatValue = value; + } + } + } +} diff --git a/ReClass.NET/Util/Conversion/LittleEndianBitConverter.cs b/ReClass.NET/Util/Conversion/LittleEndianBitConverter.cs new file mode 100644 index 00000000..af12706a --- /dev/null +++ b/ReClass.NET/Util/Conversion/LittleEndianBitConverter.cs @@ -0,0 +1,39 @@ +using System; + +namespace ReClassNET.Util.Conversion +{ + public sealed class LittleEndianBitConverter : EndianBitConverter + { + protected override long FromBytes(byte[] buffer, int index, int bytesToConvert) + { + if (buffer == null) + { + throw new ArgumentNullException(nameof(buffer)); + } + if (index + bytesToConvert > buffer.Length) + { + throw new ArgumentOutOfRangeException(nameof(index)); + } + + var ret = 0L; + for (var i = 0; i < bytesToConvert; i++) + { + ret = unchecked((ret << 8) | buffer[index + bytesToConvert - 1 - i]); + } + return ret; + } + + protected override byte[] ToBytes(long value, int bytes) + { + var buffer = new byte[bytes]; + + for (var i = 0; i < bytes; i++) + { + buffer[i] = unchecked((byte)(value & 0xFF)); + value >>= 8; + } + + return buffer; + } + } +} diff --git a/ReClass.NET_Tests/ReClass.NET_Tests.csproj b/ReClass.NET_Tests/ReClass.NET_Tests.csproj index 1ed78ef2..02c7ae25 100644 --- a/ReClass.NET_Tests/ReClass.NET_Tests.csproj +++ b/ReClass.NET_Tests/ReClass.NET_Tests.csproj @@ -91,6 +91,9 @@ + + + diff --git a/ReClass.NET_Tests/Util/Conversion/BigEndianBitConverterTest.cs b/ReClass.NET_Tests/Util/Conversion/BigEndianBitConverterTest.cs new file mode 100644 index 00000000..a55599a3 --- /dev/null +++ b/ReClass.NET_Tests/Util/Conversion/BigEndianBitConverterTest.cs @@ -0,0 +1,114 @@ +using System; +using NFluent; +using ReClassNET.Util.Conversion; +using Xunit; + +namespace ReClass.NET_Tests.Util.Conversion +{ + public class BigEndianBitConverterTest + { + [Fact] + public void ToXXX_ThrowsOnNull() + { + var sut = new BigEndianBitConverter(); + + Check.ThatCode(() => sut.ToInt32(null, 0)).Throws(); + } + + [Fact] + public void ToXXX_ThrowsOnInvalidIndexOrSize() + { + var sut = new BigEndianBitConverter(); + + var data = new byte[3]; + Check.ThatCode(() => sut.ToInt32(data, 0)).Throws(); + + data = new byte[4]; + Check.ThatCode(() => sut.ToInt32(data, 1)).Throws(); + } + + [Fact] + public void GetBytes() + { + var sut = new BigEndianBitConverter(); + + Check.That(new byte[] { 0 }).ContainsExactly(sut.GetBytes(false)); + Check.That(new byte[] { 1 }).ContainsExactly(sut.GetBytes(true)); + + Check.That(new byte[] { 0, 0 }).ContainsExactly(sut.GetBytes((short)0)); + Check.That(new byte[] { 0, 1 }).ContainsExactly(sut.GetBytes((short)1)); + Check.That(new byte[] { 1, 0 }).ContainsExactly(sut.GetBytes((short)256)); + Check.That(new byte[] { 255, 255 }).ContainsExactly(sut.GetBytes((short)-1)); + + Check.That(new byte[] { 0, 0 }).ContainsExactly(sut.GetBytes((ushort)0)); + Check.That(new byte[] { 0, 1 }).ContainsExactly(sut.GetBytes((ushort)1)); + Check.That(new byte[] { 1, 0 }).ContainsExactly(sut.GetBytes((ushort)256)); + Check.That(new byte[] { 255, 255 }).ContainsExactly(sut.GetBytes(ushort.MaxValue)); + + Check.That(new byte[] { 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(0)); + Check.That(new byte[] { 0, 0, 0, 1 }).ContainsExactly(sut.GetBytes(1)); + Check.That(new byte[] { 0, 0, 1, 0 }).ContainsExactly(sut.GetBytes(256)); + Check.That(new byte[] { 0, 1, 0, 0 }).ContainsExactly(sut.GetBytes(65536)); + Check.That(new byte[] { 1, 0, 0, 0 }).ContainsExactly(sut.GetBytes(16777216)); + Check.That(new byte[] { 255, 255, 255, 255 }).ContainsExactly(sut.GetBytes(-1)); + + Check.That(new byte[] { 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(0u)); + Check.That(new byte[] { 0, 0, 0, 1 }).ContainsExactly(sut.GetBytes(1u)); + Check.That(new byte[] { 0, 0, 1, 0 }).ContainsExactly(sut.GetBytes(256u)); + Check.That(new byte[] { 0, 1, 0, 0 }).ContainsExactly(sut.GetBytes(65536u)); + Check.That(new byte[] { 1, 0, 0, 0 }).ContainsExactly(sut.GetBytes(16777216u)); + Check.That(new byte[] { 255, 255, 255, 255 }).ContainsExactly(sut.GetBytes(uint.MaxValue)); + + Check.That(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(0L)); + Check.That(new byte[] { 0, 0, 0, 0, 0, 0, 0, 1 }).ContainsExactly(sut.GetBytes(1L)); + Check.That(new byte[] { 0, 0, 0, 0, 0, 0, 1, 0 }).ContainsExactly(sut.GetBytes(256L)); + Check.That(new byte[] { 0, 0, 0, 0, 0, 1, 0, 0 }).ContainsExactly(sut.GetBytes(65536L)); + Check.That(new byte[] { 0, 0, 0, 0, 1, 0, 0, 0 }).ContainsExactly(sut.GetBytes(16777216L)); + Check.That(new byte[] { 0, 0, 0, 1, 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(4294967296L)); + Check.That(new byte[] { 0, 0, 1, 0, 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(1099511627776L)); + Check.That(new byte[] { 0, 1, 0, 0, 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(281474976710656L)); + Check.That(new byte[] { 1, 0, 0, 0, 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(72057594037927936L)); + Check.That(new byte[] { 255, 255, 255, 255, 255, 255, 255, 255 }).ContainsExactly(sut.GetBytes(-1L)); + + Check.That(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(0UL)); + Check.That(new byte[] { 0, 0, 0, 0, 0, 0, 0, 1 }).ContainsExactly(sut.GetBytes(1UL)); + Check.That(new byte[] { 0, 0, 0, 0, 0, 0, 1, 0 }).ContainsExactly(sut.GetBytes(256UL)); + Check.That(new byte[] { 0, 0, 0, 0, 0, 1, 0, 0 }).ContainsExactly(sut.GetBytes(65536UL)); + Check.That(new byte[] { 0, 0, 0, 0, 1, 0, 0, 0 }).ContainsExactly(sut.GetBytes(16777216UL)); + Check.That(new byte[] { 0, 0, 0, 1, 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(4294967296UL)); + Check.That(new byte[] { 0, 0, 1, 0, 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(1099511627776UL)); + Check.That(new byte[] { 0, 1, 0, 0, 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(281474976710656UL)); + Check.That(new byte[] { 1, 0, 0, 0, 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(72057594037927936UL)); + Check.That(new byte[] { 255, 255, 255, 255, 255, 255, 255, 255 }).ContainsExactly(sut.GetBytes(ulong.MaxValue)); + } + + [Fact] + public void ToXXX() + { + var sut = new BigEndianBitConverter(); + + var data = new byte[] { 0, 0, 0, 0, 0, 0, 0, 3 }; + Check.That(sut.ToBoolean(data, 0)).IsFalse(); + Check.That(sut.ToBoolean(data, 7)).IsTrue(); + Check.That(sut.ToChar(data, 0)).IsEqualTo('\0'); + Check.That(sut.ToChar(data, 6)).IsEqualTo('\u0003'); + Check.That(sut.ToInt16(data, 0)).IsEqualTo(0); + Check.That(sut.ToInt16(data, 6)).IsEqualTo(3); + Check.That(sut.ToUInt16(data, 0)).IsEqualTo(0u); + Check.That(sut.ToUInt16(data, 6)).IsEqualTo(3u); + Check.That(sut.ToInt32(data, 0)).IsEqualTo(0); + Check.That(sut.ToInt32(data, 4)).IsEqualTo(3); + Check.That(sut.ToUInt32(data, 0)).IsEqualTo(0u); + Check.That(sut.ToUInt32(data, 4)).IsEqualTo(3u); + Check.That(sut.ToInt64(data, 0)).IsEqualTo(3L); + Check.That(sut.ToUInt64(data, 0)).IsEqualTo(3UL); + + data = new byte[] { 0x41, 0x20, 0, 0, 0, 0, 0, 0 }; + Check.That(sut.ToSingle(data, 0)).IsEqualTo(10.0f); + Check.That(sut.ToSingle(data, 4)).IsEqualTo(0.0f); + + data = new byte[] { 0x40, 0x24, 0, 0, 0, 0, 0, 0 }; + Check.That(sut.ToDouble(data, 0)).IsEqualTo(10.0); + } + } +} diff --git a/ReClass.NET_Tests/Util/Conversion/EndianBitConverterTest.cs b/ReClass.NET_Tests/Util/Conversion/EndianBitConverterTest.cs new file mode 100644 index 00000000..1a5e54a1 --- /dev/null +++ b/ReClass.NET_Tests/Util/Conversion/EndianBitConverterTest.cs @@ -0,0 +1,25 @@ +using System; +using NFluent; +using ReClassNET.Util.Conversion; +using Xunit; + +namespace ReClass.NET_Tests.Util.Conversion +{ + public class EndianBitConverterTest + { + [Fact] + public void Properties_AreNotNull() + { + Check.That(EndianBitConverter.System).IsNotNull(); + Check.That(EndianBitConverter.Big).IsNotNull(); + Check.That(EndianBitConverter.Little).IsNotNull(); + } + + [Fact] + public void Types() + { + Check.That(EndianBitConverter.Big.GetType()).IsNotEqualTo(EndianBitConverter.Little.GetType()); + Check.That(EndianBitConverter.System.GetType()).IsEqualTo(BitConverter.IsLittleEndian ? EndianBitConverter.Little.GetType() : EndianBitConverter.Big.GetType()); + } + } +} diff --git a/ReClass.NET_Tests/Util/Conversion/LittleEndianBitConverterTest.cs b/ReClass.NET_Tests/Util/Conversion/LittleEndianBitConverterTest.cs new file mode 100644 index 00000000..5a740ef5 --- /dev/null +++ b/ReClass.NET_Tests/Util/Conversion/LittleEndianBitConverterTest.cs @@ -0,0 +1,114 @@ +using System; +using NFluent; +using ReClassNET.Util.Conversion; +using Xunit; + +namespace ReClass.NET_Tests.Util.Conversion +{ + public class LittleEndianBitConverterTest + { + [Fact] + public void ToXXX_ThrowsOnNull() + { + var sut = new LittleEndianBitConverter(); + + Check.ThatCode(() => sut.ToInt32(null, 0)).Throws(); + } + + [Fact] + public void ToXXX_ThrowsOnInvalidIndexOrSize() + { + var sut = new LittleEndianBitConverter(); + + var data = new byte[3]; + Check.ThatCode(() => sut.ToInt32(data, 0)).Throws(); + + data = new byte[4]; + Check.ThatCode(() => sut.ToInt32(data, 1)).Throws(); + } + + [Fact] + public void GetBytes() + { + var sut = new LittleEndianBitConverter(); + + Check.That(new byte[] { 0 }).ContainsExactly(sut.GetBytes(false)); + Check.That(new byte[] { 1 }).ContainsExactly(sut.GetBytes(true)); + + Check.That(new byte[] { 0, 0 }).ContainsExactly(sut.GetBytes((short)0)); + Check.That(new byte[] { 1, 0 }).ContainsExactly(sut.GetBytes((short)1)); + Check.That(new byte[] { 0, 1 }).ContainsExactly(sut.GetBytes((short)256)); + Check.That(new byte[] { 255, 255 }).ContainsExactly(sut.GetBytes((short)-1)); + + Check.That(new byte[] { 0, 0 }).ContainsExactly(sut.GetBytes((ushort)0)); + Check.That(new byte[] { 1, 0 }).ContainsExactly(sut.GetBytes((ushort)1)); + Check.That(new byte[] { 0, 1 }).ContainsExactly(sut.GetBytes((ushort)256)); + Check.That(new byte[] { 255, 255 }).ContainsExactly(sut.GetBytes(ushort.MaxValue)); + + Check.That(new byte[] { 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(0)); + Check.That(new byte[] { 1, 0, 0, 0 }).ContainsExactly(sut.GetBytes(1)); + Check.That(new byte[] { 0, 1, 0, 0 }).ContainsExactly(sut.GetBytes(256)); + Check.That(new byte[] { 0, 0, 1, 0 }).ContainsExactly(sut.GetBytes(65536)); + Check.That(new byte[] { 0, 0, 0, 1 }).ContainsExactly(sut.GetBytes(16777216)); + Check.That(new byte[] { 255, 255, 255, 255 }).ContainsExactly(sut.GetBytes(-1)); + + Check.That(new byte[] { 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(0u)); + Check.That(new byte[] { 1, 0, 0, 0 }).ContainsExactly(sut.GetBytes(1u)); + Check.That(new byte[] { 0, 1, 0, 0 }).ContainsExactly(sut.GetBytes(256u)); + Check.That(new byte[] { 0, 0, 1, 0 }).ContainsExactly(sut.GetBytes(65536u)); + Check.That(new byte[] { 0, 0, 0, 1 }).ContainsExactly(sut.GetBytes(16777216u)); + Check.That(new byte[] { 255, 255, 255, 255 }).ContainsExactly(sut.GetBytes(uint.MaxValue)); + + Check.That(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(0L)); + Check.That(new byte[] { 1, 0, 0, 0, 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(1L)); + Check.That(new byte[] { 0, 1, 0, 0, 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(256L)); + Check.That(new byte[] { 0, 0, 1, 0, 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(65536L)); + Check.That(new byte[] { 0, 0, 0, 1, 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(16777216L)); + Check.That(new byte[] { 0, 0, 0, 0, 1, 0, 0, 0 }).ContainsExactly(sut.GetBytes(4294967296L)); + Check.That(new byte[] { 0, 0, 0, 0, 0, 1, 0, 0 }).ContainsExactly(sut.GetBytes(1099511627776L)); + Check.That(new byte[] { 0, 0, 0, 0, 0, 0, 1, 0 }).ContainsExactly(sut.GetBytes(281474976710656L)); + Check.That(new byte[] { 0, 0, 0, 0, 0, 0, 0, 1 }).ContainsExactly(sut.GetBytes(72057594037927936L)); + Check.That(new byte[] { 255, 255, 255, 255, 255, 255, 255, 255 }).ContainsExactly(sut.GetBytes(-1L)); + + Check.That(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(0UL)); + Check.That(new byte[] { 1, 0, 0, 0, 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(1UL)); + Check.That(new byte[] { 0, 1, 0, 0, 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(256UL)); + Check.That(new byte[] { 0, 0, 1, 0, 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(65536UL)); + Check.That(new byte[] { 0, 0, 0, 1, 0, 0, 0, 0 }).ContainsExactly(sut.GetBytes(16777216UL)); + Check.That(new byte[] { 0, 0, 0, 0, 1, 0, 0, 0 }).ContainsExactly(sut.GetBytes(4294967296UL)); + Check.That(new byte[] { 0, 0, 0, 0, 0, 1, 0, 0 }).ContainsExactly(sut.GetBytes(1099511627776UL)); + Check.That(new byte[] { 0, 0, 0, 0, 0, 0, 1, 0 }).ContainsExactly(sut.GetBytes(281474976710656UL)); + Check.That(new byte[] { 0, 0, 0, 0, 0, 0, 0, 1 }).ContainsExactly(sut.GetBytes(72057594037927936UL)); + Check.That(new byte[] { 255, 255, 255, 255, 255, 255, 255, 255 }).ContainsExactly(sut.GetBytes(ulong.MaxValue)); + } + + [Fact] + public void ToXXX() + { + var sut = new LittleEndianBitConverter(); + + var data = new byte[] { 0x03, 0, 0, 0, 0, 0, 0, 0 }; + Check.That(sut.ToBoolean(data, 0)).IsTrue(); + Check.That(sut.ToBoolean(data, 7)).IsFalse(); + Check.That(sut.ToChar(data, 0)).IsEqualTo('\u0003'); + Check.That(sut.ToChar(data, 6)).IsEqualTo('\0'); + Check.That(sut.ToInt16(data, 0)).IsEqualTo(3); + Check.That(sut.ToInt16(data, 6)).IsEqualTo(0); + Check.That(sut.ToUInt16(data, 0)).IsEqualTo(3u); + Check.That(sut.ToUInt16(data, 6)).IsEqualTo(0u); + Check.That(sut.ToInt32(data, 0)).IsEqualTo(3); + Check.That(sut.ToInt32(data, 4)).IsEqualTo(0); + Check.That(sut.ToUInt32(data, 0)).IsEqualTo(3u); + Check.That(sut.ToUInt32(data, 4)).IsEqualTo(0u); + Check.That(sut.ToInt64(data, 0)).IsEqualTo(3L); + Check.That(sut.ToUInt64(data, 0)).IsEqualTo(3UL); + + data = new byte[] { 0, 0, 0, 0, 0, 0, 0x20, 0x41 }; + Check.That(sut.ToSingle(data, 0)).IsEqualTo(0.0f); + Check.That(sut.ToSingle(data, 4)).IsEqualTo(10.0f); + + data = new byte[] { 0, 0, 0, 0, 0, 0, 0x24, 0x40 }; + Check.That(sut.ToDouble(data, 0)).IsEqualTo(10.0); + } + } +} From 15b08867a6580db54937ec7d0e487d202d623b4d Mon Sep 17 00:00:00 2001 From: KN4CK3R Date: Sun, 22 Nov 2020 21:56:39 +0100 Subject: [PATCH 4/5] Replaced BitConverter with EndianBitConverter. --- ReClass.NET/Forms/MainForm.cs | 26 +++++++++--------- ReClass.NET/Forms/ScannerForm.cs | 10 +++---- ReClass.NET/Memory/IRemoteMemoryReader.cs | 3 +++ ReClass.NET/Memory/IRemoteMemoryWriter.cs | 5 +++- ReClass.NET/Memory/MemoryBuffer.cs | 27 +++++++++---------- ReClass.NET/Memory/RemoteProcess.cs | 3 +++ .../Comparer/DoubleMemoryComparer.cs | 19 ++++++++----- .../Comparer/FloatMemoryComparer.cs | 19 ++++++++----- .../Comparer/IntegerMemoryComparer.cs | 11 +++++--- .../Comparer/LongMemoryComparer.cs | 11 +++++--- .../Comparer/ShortMemoryComparer.cs | 11 +++++--- .../MemoryScanner/InputCorrelatedScanner.cs | 14 +++++----- ReClass.NET/MemoryScanner/MemoryRecord.cs | 22 +++++++-------- .../Comparer/FloatMemoryComparerTest.cs | 19 +++++++------ .../Comparer/IntegerMemoryComparerTest.cs | 17 +++++++----- .../Comparer/LongMemoryComparerTest.cs | 17 +++++++----- .../Comparer/ShortMemoryComparerTest.cs | 17 +++++++----- 17 files changed, 149 insertions(+), 102 deletions(-) diff --git a/ReClass.NET/Forms/MainForm.cs b/ReClass.NET/Forms/MainForm.cs index 0b3f3008..bff83d26 100644 --- a/ReClass.NET/Forms/MainForm.cs +++ b/ReClass.NET/Forms/MainForm.cs @@ -588,6 +588,8 @@ private void searchForEqualValuesToolStripMenuItem_Click(object sender, EventArg return; } + var bitConverter = Program.RemoteProcess.BitConverter; + IScanComparer comparer; switch (selectedNode.Node) { @@ -595,10 +597,10 @@ private void searchForEqualValuesToolStripMenuItem_Click(object sender, EventArg comparer = new ArrayOfBytesMemoryComparer(node.ReadValueFromMemory(selectedNode.Memory)); break; case FloatNode node: - comparer = new FloatMemoryComparer(ScanCompareType.Equal, ScanRoundMode.Normal, 2, node.ReadValueFromMemory(selectedNode.Memory), 0.0f); + comparer = new FloatMemoryComparer(ScanCompareType.Equal, ScanRoundMode.Normal, 2, node.ReadValueFromMemory(selectedNode.Memory), 0.0f, bitConverter); break; case DoubleNode node: - comparer = new DoubleMemoryComparer(ScanCompareType.Equal, ScanRoundMode.Normal, 2, node.ReadValueFromMemory(selectedNode.Memory), 0.0); + comparer = new DoubleMemoryComparer(ScanCompareType.Equal, ScanRoundMode.Normal, 2, node.ReadValueFromMemory(selectedNode.Memory), 0.0, bitConverter); break; case Int8Node node: comparer = new ByteMemoryComparer(ScanCompareType.Equal, (byte)node.ReadValueFromMemory(selectedNode.Memory), 0); @@ -607,30 +609,30 @@ private void searchForEqualValuesToolStripMenuItem_Click(object sender, EventArg comparer = new ByteMemoryComparer(ScanCompareType.Equal, node.ReadValueFromMemory(selectedNode.Memory), 0); break; case Int16Node node: - comparer = new ShortMemoryComparer(ScanCompareType.Equal, node.ReadValueFromMemory(selectedNode.Memory), 0); + comparer = new ShortMemoryComparer(ScanCompareType.Equal, node.ReadValueFromMemory(selectedNode.Memory), 0, bitConverter); break; case UInt16Node node: - comparer = new ShortMemoryComparer(ScanCompareType.Equal, (short)node.ReadValueFromMemory(selectedNode.Memory), 0); + comparer = new ShortMemoryComparer(ScanCompareType.Equal, (short)node.ReadValueFromMemory(selectedNode.Memory), 0, bitConverter); break; case Int32Node node: - comparer = new IntegerMemoryComparer(ScanCompareType.Equal, node.ReadValueFromMemory(selectedNode.Memory), 0); + comparer = new IntegerMemoryComparer(ScanCompareType.Equal, node.ReadValueFromMemory(selectedNode.Memory), 0, bitConverter); break; case UInt32Node node: - comparer = new IntegerMemoryComparer(ScanCompareType.Equal, (int)node.ReadValueFromMemory(selectedNode.Memory), 0); + comparer = new IntegerMemoryComparer(ScanCompareType.Equal, (int)node.ReadValueFromMemory(selectedNode.Memory), 0, bitConverter); break; case Int64Node node: - comparer = new LongMemoryComparer(ScanCompareType.Equal, node.ReadValueFromMemory(selectedNode.Memory), 0L); + comparer = new LongMemoryComparer(ScanCompareType.Equal, node.ReadValueFromMemory(selectedNode.Memory), 0L, bitConverter); break; case UInt64Node node: - comparer = new LongMemoryComparer(ScanCompareType.Equal, (long)node.ReadValueFromMemory(selectedNode.Memory), 0L); + comparer = new LongMemoryComparer(ScanCompareType.Equal, (long)node.ReadValueFromMemory(selectedNode.Memory), 0L, bitConverter); break; case NIntNode node: { var value = node.ReadValueFromMemory(selectedNode.Memory); #if RECLASSNET64 - comparer = new LongMemoryComparer(ScanCompareType.Equal, value.ToInt64(), 0L); + comparer = new LongMemoryComparer(ScanCompareType.Equal, value.ToInt64(), 0L, bitConverter); #else - comparer = new IntegerMemoryComparer(ScanCompareType.Equal, value.ToInt32(), 0); + comparer = new IntegerMemoryComparer(ScanCompareType.Equal, value.ToInt32(), 0, bitConverter); #endif break; } @@ -638,9 +640,9 @@ private void searchForEqualValuesToolStripMenuItem_Click(object sender, EventArg { var value = node.ReadValueFromMemory(selectedNode.Memory); #if RECLASSNET64 - comparer = new LongMemoryComparer(ScanCompareType.Equal, (long)value.ToUInt64(), 0L); + comparer = new LongMemoryComparer(ScanCompareType.Equal, (long)value.ToUInt64(), 0L, bitConverter); #else - comparer = new IntegerMemoryComparer(ScanCompareType.Equal, (int)value.ToUInt32(), 0); + comparer = new IntegerMemoryComparer(ScanCompareType.Equal, (int)value.ToUInt32(), 0, bitConverter); #endif break; } diff --git a/ReClass.NET/Forms/ScannerForm.cs b/ReClass.NET/Forms/ScannerForm.cs index c52e7187..0fb4d430 100644 --- a/ReClass.NET/Forms/ScannerForm.cs +++ b/ReClass.NET/Forms/ScannerForm.cs @@ -758,11 +758,11 @@ private IScanComparer CreateComparer(ScanSettings settings) case ScanValueType.Byte: return new ByteMemoryComparer(compareType, (byte)value1, (byte)value2); case ScanValueType.Short: - return new ShortMemoryComparer(compareType, (short)value1, (short)value2); + return new ShortMemoryComparer(compareType, (short)value1, (short)value2, process.BitConverter); case ScanValueType.Integer: - return new IntegerMemoryComparer(compareType, (int)value1, (int)value2); + return new IntegerMemoryComparer(compareType, (int)value1, (int)value2, process.BitConverter); case ScanValueType.Long: - return new LongMemoryComparer(compareType, value1, value2); + return new LongMemoryComparer(compareType, value1, value2, process.BitConverter); } } else if (settings.ValueType == ScanValueType.Float || settings.ValueType == ScanValueType.Double) @@ -806,9 +806,9 @@ int CalculateSignificantDigits(string input, NumberFormatInfo numberFormat) switch (settings.ValueType) { case ScanValueType.Float: - return new FloatMemoryComparer(compareType, roundMode, significantDigits, (float)value1, (float)value2); + return new FloatMemoryComparer(compareType, roundMode, significantDigits, (float)value1, (float)value2, process.BitConverter); case ScanValueType.Double: - return new DoubleMemoryComparer(compareType, roundMode, significantDigits, value1, value2); + return new DoubleMemoryComparer(compareType, roundMode, significantDigits, value1, value2, process.BitConverter); } } else if (settings.ValueType == ScanValueType.ArrayOfBytes) diff --git a/ReClass.NET/Memory/IRemoteMemoryReader.cs b/ReClass.NET/Memory/IRemoteMemoryReader.cs index 3f926c82..ed514ddd 100644 --- a/ReClass.NET/Memory/IRemoteMemoryReader.cs +++ b/ReClass.NET/Memory/IRemoteMemoryReader.cs @@ -1,10 +1,13 @@ using System; using System.Text; +using ReClassNET.Util.Conversion; namespace ReClassNET.Memory { public interface IRemoteMemoryReader { + EndianBitConverter BitConverter { get; set; } + /// Reads remote memory from the address into the buffer. /// The address to read from. /// [out] The data buffer to fill. If the remote process is not valid, the buffer will get filled with zeros. diff --git a/ReClass.NET/Memory/IRemoteMemoryWriter.cs b/ReClass.NET/Memory/IRemoteMemoryWriter.cs index bc466d42..57bba946 100644 --- a/ReClass.NET/Memory/IRemoteMemoryWriter.cs +++ b/ReClass.NET/Memory/IRemoteMemoryWriter.cs @@ -1,9 +1,12 @@ -using System; +using System; +using ReClassNET.Util.Conversion; namespace ReClassNET.Memory { public interface IRemoteMemoryWriter { + EndianBitConverter BitConverter { get; set; } + /// Writes the given to the in the remote process. /// The address to write to. /// The data to write. diff --git a/ReClass.NET/Memory/MemoryBuffer.cs b/ReClass.NET/Memory/MemoryBuffer.cs index c6e847fe..e1b515a4 100644 --- a/ReClass.NET/Memory/MemoryBuffer.cs +++ b/ReClass.NET/Memory/MemoryBuffer.cs @@ -1,8 +1,8 @@ using System; using System.Diagnostics.Contracts; -using System.Runtime.InteropServices; using System.Text; using ReClassNET.Extensions; +using ReClassNET.Util.Conversion; namespace ReClassNET.Memory { @@ -15,6 +15,8 @@ public class MemoryBuffer public byte[] RawData => data; + public EndianBitConverter BitConverter { get; set; } = EndianBitConverter.System; + public int Size { get => data.Length; @@ -52,25 +54,18 @@ public MemoryBuffer() historyData = Array.Empty(); } - public MemoryBuffer(MemoryBuffer other) - { - Contract.Requires(other != null); - Contract.Ensures(data != null); - Contract.Ensures(historyData != null); - - data = other.data; - historyData = other.historyData; - hasHistory = other.hasHistory; - - ContainsValidData = other.ContainsValidData; - } - public MemoryBuffer Clone() { Contract.Ensures(Contract.Result() != null); - return new MemoryBuffer(this) + return new MemoryBuffer { + data = data, + historyData = historyData, + hasHistory = hasHistory, + + BitConverter = BitConverter, + ContainsValidData = ContainsValidData, Offset = Offset }; } @@ -90,6 +85,8 @@ public void UpdateFrom(IRemoteMemoryReader reader, IntPtr address) hasHistory = ContainsValidData; + BitConverter = reader.BitConverter; + ContainsValidData = reader.ReadRemoteMemoryIntoBuffer(address, ref data); if (!ContainsValidData) { diff --git a/ReClass.NET/Memory/RemoteProcess.cs b/ReClass.NET/Memory/RemoteProcess.cs index b23286c0..bebdf175 100644 --- a/ReClass.NET/Memory/RemoteProcess.cs +++ b/ReClass.NET/Memory/RemoteProcess.cs @@ -13,6 +13,7 @@ using ReClassNET.MemoryScanner; using ReClassNET.Native; using ReClassNET.Symbols; +using ReClassNET.Util.Conversion; namespace ReClassNET.Memory { @@ -56,6 +57,8 @@ public class RemoteProcess : IDisposable, IRemoteMemoryReader, IRemoteMemoryWrit public SymbolStore Symbols => symbols; + public EndianBitConverter BitConverter { get; set; } = EndianBitConverter.System; + /// Gets a copy of the current modules list. This list may change if the remote process (un)loads a module. public IEnumerable Modules { diff --git a/ReClass.NET/MemoryScanner/Comparer/DoubleMemoryComparer.cs b/ReClass.NET/MemoryScanner/Comparer/DoubleMemoryComparer.cs index b8428041..5e866608 100644 --- a/ReClass.NET/MemoryScanner/Comparer/DoubleMemoryComparer.cs +++ b/ReClass.NET/MemoryScanner/Comparer/DoubleMemoryComparer.cs @@ -1,6 +1,7 @@ using System; using System.Diagnostics; using ReClassNET.Extensions; +using ReClassNET.Util.Conversion; namespace ReClassNET.MemoryScanner.Comparer { @@ -16,7 +17,9 @@ public class DoubleMemoryComparer : ISimpleScanComparer private readonly double minValue; private readonly double maxValue; - public DoubleMemoryComparer(ScanCompareType compareType, ScanRoundMode roundType, int significantDigits, double value1, double value2) + private readonly EndianBitConverter bitConverter; + + public DoubleMemoryComparer(ScanCompareType compareType, ScanRoundMode roundType, int significantDigits, double value1, double value2, EndianBitConverter bitConverter) { CompareType = compareType; @@ -29,11 +32,13 @@ public DoubleMemoryComparer(ScanCompareType compareType, ScanRoundMode roundType minValue = value1 - 1.0 / factor; maxValue = value1 + 1.0 / factor; + + this.bitConverter = bitConverter; } private bool CheckRoundedEquality(double value) => RoundType switch - { + { ScanRoundMode.Strict => Value1.IsNearlyEqual(Math.Round(value, significantDigits, MidpointRounding.AwayFromZero), 0.0001), ScanRoundMode.Normal => minValue < value && value < maxValue, ScanRoundMode.Truncate => (long)value == (long)Value1, @@ -46,7 +51,7 @@ public bool Compare(byte[] data, int index, out ScanResult result) data, index, value => CompareType switch - { + { ScanCompareType.Equal => CheckRoundedEquality(value), ScanCompareType.NotEqual => !CheckRoundedEquality(value), ScanCompareType.GreaterThan => value > Value1, @@ -60,7 +65,7 @@ public bool Compare(byte[] data, int index, out ScanResult result) }, out result ); - } + } public bool Compare(byte[] data, int index, ScanResult previous, out ScanResult result) { @@ -77,7 +82,7 @@ public bool Compare(byte[] data, int index, DoubleScanResult previous, out ScanR data, index, value => CompareType switch - { + { ScanCompareType.Equal => CheckRoundedEquality(value), ScanCompareType.NotEqual => !CheckRoundedEquality(value), ScanCompareType.Changed => value != previous.Value, @@ -98,11 +103,11 @@ out result ); } - private static bool CompareInternal(byte[] data, int index, Func matcher, out ScanResult result) + private bool CompareInternal(byte[] data, int index, Func matcher, out ScanResult result) { result = null; - var value = BitConverter.ToDouble(data, index); + var value = bitConverter.ToDouble(data, index); if (!matcher(value)) { diff --git a/ReClass.NET/MemoryScanner/Comparer/FloatMemoryComparer.cs b/ReClass.NET/MemoryScanner/Comparer/FloatMemoryComparer.cs index 27c8dd13..60a3acdf 100644 --- a/ReClass.NET/MemoryScanner/Comparer/FloatMemoryComparer.cs +++ b/ReClass.NET/MemoryScanner/Comparer/FloatMemoryComparer.cs @@ -1,6 +1,7 @@ using System; using System.Diagnostics; using ReClassNET.Extensions; +using ReClassNET.Util.Conversion; namespace ReClassNET.MemoryScanner.Comparer { @@ -16,7 +17,9 @@ public class FloatMemoryComparer : ISimpleScanComparer private readonly float minValue; private readonly float maxValue; - public FloatMemoryComparer(ScanCompareType compareType, ScanRoundMode roundType, int significantDigits, float value1, float value2) + private readonly EndianBitConverter bitConverter; + + public FloatMemoryComparer(ScanCompareType compareType, ScanRoundMode roundType, int significantDigits, float value1, float value2, EndianBitConverter bitConverter) { CompareType = compareType; @@ -29,11 +32,13 @@ public FloatMemoryComparer(ScanCompareType compareType, ScanRoundMode roundType, minValue = value1 - 1.0f / factor; maxValue = value1 + 1.0f / factor; + + this.bitConverter = bitConverter; } private bool CheckRoundedEquality(float value) => RoundType switch - { + { ScanRoundMode.Strict => Value1.IsNearlyEqual((float)Math.Round(value, significantDigits, MidpointRounding.AwayFromZero), 0.0001f), ScanRoundMode.Normal => minValue < value && value < maxValue, ScanRoundMode.Truncate => (int)value == (int)Value1, @@ -46,7 +51,7 @@ public bool Compare(byte[] data, int index, out ScanResult result) data, index, value => CompareType switch - { + { ScanCompareType.Equal => CheckRoundedEquality(value), ScanCompareType.NotEqual => !CheckRoundedEquality(value), ScanCompareType.GreaterThan => value > Value1, @@ -60,7 +65,7 @@ public bool Compare(byte[] data, int index, out ScanResult result) }, out result ); - } + } public bool Compare(byte[] data, int index, ScanResult previous, out ScanResult result) { @@ -77,7 +82,7 @@ public bool Compare(byte[] data, int index, FloatScanResult previous, out ScanRe data, index, value => CompareType switch - { + { ScanCompareType.Equal => CheckRoundedEquality(value), ScanCompareType.NotEqual => !CheckRoundedEquality(value), ScanCompareType.Changed => value != previous.Value, @@ -98,11 +103,11 @@ out result ); } - private static bool CompareInternal(byte[] data, int index, Func matcher, out ScanResult result) + private bool CompareInternal(byte[] data, int index, Func matcher, out ScanResult result) { result = null; - var value = BitConverter.ToSingle(data, index); + var value = bitConverter.ToSingle(data, index); if (!matcher(value)) { diff --git a/ReClass.NET/MemoryScanner/Comparer/IntegerMemoryComparer.cs b/ReClass.NET/MemoryScanner/Comparer/IntegerMemoryComparer.cs index 1935accf..44b372af 100644 --- a/ReClass.NET/MemoryScanner/Comparer/IntegerMemoryComparer.cs +++ b/ReClass.NET/MemoryScanner/Comparer/IntegerMemoryComparer.cs @@ -1,5 +1,6 @@ using System; using System.Diagnostics; +using ReClassNET.Util.Conversion; namespace ReClassNET.MemoryScanner.Comparer { @@ -10,12 +11,16 @@ public class IntegerMemoryComparer : ISimpleScanComparer public int Value2 { get; } public int ValueSize => sizeof(int); - public IntegerMemoryComparer(ScanCompareType compareType, int value1, int value2) + private readonly EndianBitConverter bitConverter; + + public IntegerMemoryComparer(ScanCompareType compareType, int value1, int value2, EndianBitConverter bitConverter) { CompareType = compareType; Value1 = value1; Value2 = value2; + + this.bitConverter = bitConverter; } public bool Compare(byte[] data, int index, out ScanResult result) @@ -76,11 +81,11 @@ out result ); } - private static bool CompareInternal(byte[] data, int index, Func matcher, out ScanResult result) + private bool CompareInternal(byte[] data, int index, Func matcher, out ScanResult result) { result = null; - var value = BitConverter.ToInt32(data, index); + var value = bitConverter.ToInt32(data, index); if (!matcher(value)) { diff --git a/ReClass.NET/MemoryScanner/Comparer/LongMemoryComparer.cs b/ReClass.NET/MemoryScanner/Comparer/LongMemoryComparer.cs index 3b1172cf..f95051ad 100644 --- a/ReClass.NET/MemoryScanner/Comparer/LongMemoryComparer.cs +++ b/ReClass.NET/MemoryScanner/Comparer/LongMemoryComparer.cs @@ -1,5 +1,6 @@ using System; using System.Diagnostics; +using ReClassNET.Util.Conversion; namespace ReClassNET.MemoryScanner.Comparer { @@ -10,12 +11,16 @@ public class LongMemoryComparer : ISimpleScanComparer public long Value2 { get; } public int ValueSize => sizeof(long); - public LongMemoryComparer(ScanCompareType compareType, long value1, long value2) + private readonly EndianBitConverter bitConverter; + + public LongMemoryComparer(ScanCompareType compareType, long value1, long value2, EndianBitConverter bitConverter) { CompareType = compareType; Value1 = value1; Value2 = value2; + + this.bitConverter = bitConverter; } public bool Compare(byte[] data, int index, out ScanResult result) @@ -76,11 +81,11 @@ out result ); } - private static bool CompareInternal(byte[] data, int index, Func matcher, out ScanResult result) + private bool CompareInternal(byte[] data, int index, Func matcher, out ScanResult result) { result = null; - var value = BitConverter.ToInt64(data, index); + var value = bitConverter.ToInt64(data, index); if (!matcher(value)) { diff --git a/ReClass.NET/MemoryScanner/Comparer/ShortMemoryComparer.cs b/ReClass.NET/MemoryScanner/Comparer/ShortMemoryComparer.cs index 5cdfbad0..6d8ba6a3 100644 --- a/ReClass.NET/MemoryScanner/Comparer/ShortMemoryComparer.cs +++ b/ReClass.NET/MemoryScanner/Comparer/ShortMemoryComparer.cs @@ -1,5 +1,6 @@ using System; using System.Diagnostics; +using ReClassNET.Util.Conversion; namespace ReClassNET.MemoryScanner.Comparer { @@ -10,12 +11,16 @@ public class ShortMemoryComparer : ISimpleScanComparer public short Value2 { get; } public int ValueSize => sizeof(short); - public ShortMemoryComparer(ScanCompareType compareType, short value1, short value2) + private readonly EndianBitConverter bitConverter; + + public ShortMemoryComparer(ScanCompareType compareType, short value1, short value2, EndianBitConverter bitConverter) { CompareType = compareType; Value1 = value1; Value2 = value2; + + this.bitConverter = bitConverter; } public bool Compare(byte[] data, int index, out ScanResult result) @@ -76,11 +81,11 @@ out result ); } - private static bool CompareInternal(byte[] data, int index, Func matcher, out ScanResult result) + private bool CompareInternal(byte[] data, int index, Func matcher, out ScanResult result) { result = null; - var value = BitConverter.ToInt16(data, index); + var value = bitConverter.ToInt16(data, index); if (!matcher(value)) { diff --git a/ReClass.NET/MemoryScanner/InputCorrelatedScanner.cs b/ReClass.NET/MemoryScanner/InputCorrelatedScanner.cs index 3a953d11..33e3b719 100644 --- a/ReClass.NET/MemoryScanner/InputCorrelatedScanner.cs +++ b/ReClass.NET/MemoryScanner/InputCorrelatedScanner.cs @@ -1,4 +1,4 @@ -using System; +using System; using System.Collections.Generic; using System.Diagnostics.Contracts; using System.Linq; @@ -13,6 +13,7 @@ namespace ReClassNET.MemoryScanner { public class InputCorrelatedScanner : Scanner { + private readonly RemoteProcess process; private readonly KeyboardInput input; private readonly List hotkeys; @@ -29,6 +30,7 @@ public InputCorrelatedScanner(RemoteProcess process, KeyboardInput input, IEnume Contract.Requires(hotkeys != null); Contract.Ensures(this.input != null); + this.process = process; this.input = input; this.hotkeys = hotkeys.ToList(); } @@ -59,11 +61,11 @@ private IScanComparer CreateScanComparer(ScanCompareType compareType) return Settings.ValueType switch { ScanValueType.Byte => new ByteMemoryComparer(compareType, 0, 0), - ScanValueType.Short => new ShortMemoryComparer(compareType, 0, 0), - ScanValueType.Integer => new IntegerMemoryComparer(compareType, 0, 0), - ScanValueType.Long => new LongMemoryComparer(compareType, 0, 0), - ScanValueType.Float => new FloatMemoryComparer(compareType, ScanRoundMode.Normal, 2, 0, 0), - ScanValueType.Double => new DoubleMemoryComparer(compareType, ScanRoundMode.Normal, 2, 0, 0), + ScanValueType.Short => new ShortMemoryComparer(compareType, 0, 0, process.BitConverter), + ScanValueType.Integer => new IntegerMemoryComparer(compareType, 0, 0, process.BitConverter), + ScanValueType.Long => new LongMemoryComparer(compareType, 0, 0, process.BitConverter), + ScanValueType.Float => new FloatMemoryComparer(compareType, ScanRoundMode.Normal, 2, 0, 0, process.BitConverter), + ScanValueType.Double => new DoubleMemoryComparer(compareType, ScanRoundMode.Normal, 2, 0, 0, process.BitConverter), _ => throw new InvalidOperationException(), }; } diff --git a/ReClass.NET/MemoryScanner/MemoryRecord.cs b/ReClass.NET/MemoryScanner/MemoryRecord.cs index 11361d5f..e40e3ff9 100644 --- a/ReClass.NET/MemoryScanner/MemoryRecord.cs +++ b/ReClass.NET/MemoryScanner/MemoryRecord.cs @@ -193,19 +193,19 @@ public void RefreshValue(RemoteProcess process) ValueStr = FormatValue(buffer[0], ShowValueHexadecimal); break; case ScanValueType.Short: - ValueStr = FormatValue(BitConverter.ToInt16(buffer, 0), ShowValueHexadecimal); + ValueStr = FormatValue(process.BitConverter.ToInt16(buffer, 0), ShowValueHexadecimal); break; case ScanValueType.Integer: - ValueStr = FormatValue(BitConverter.ToInt32(buffer, 0), ShowValueHexadecimal); + ValueStr = FormatValue(process.BitConverter.ToInt32(buffer, 0), ShowValueHexadecimal); break; case ScanValueType.Long: - ValueStr = FormatValue(BitConverter.ToInt64(buffer, 0), ShowValueHexadecimal); + ValueStr = FormatValue(process.BitConverter.ToInt64(buffer, 0), ShowValueHexadecimal); break; case ScanValueType.Float: - ValueStr = FormatValue(BitConverter.ToSingle(buffer, 0)); + ValueStr = FormatValue(process.BitConverter.ToSingle(buffer, 0)); break; case ScanValueType.Double: - ValueStr = FormatValue(BitConverter.ToDouble(buffer, 0)); + ValueStr = FormatValue(process.BitConverter.ToDouble(buffer, 0)); break; case ScanValueType.ArrayOfBytes: ValueStr = FormatValue(buffer); @@ -241,16 +241,16 @@ public void SetValue(RemoteProcess process, string input, bool isHex) switch (ValueType) { case ScanValueType.Byte: - data = BitConverter.GetBytes((byte)value); + data = process.BitConverter.GetBytes((byte)value); break; case ScanValueType.Short: - data = BitConverter.GetBytes((short)value); + data = process.BitConverter.GetBytes((short)value); break; case ScanValueType.Integer: - data = BitConverter.GetBytes((int)value); + data = process.BitConverter.GetBytes((int)value); break; case ScanValueType.Long: - data = BitConverter.GetBytes(value); + data = process.BitConverter.GetBytes(value); break; } } @@ -262,10 +262,10 @@ public void SetValue(RemoteProcess process, string input, bool isHex) switch (ValueType) { case ScanValueType.Float: - data = BitConverter.GetBytes((float)value); + data = process.BitConverter.GetBytes((float)value); break; case ScanValueType.Double: - data = BitConverter.GetBytes(value); + data = process.BitConverter.GetBytes(value); break; } } diff --git a/ReClass.NET_Tests/MemoryScanner/Comparer/FloatMemoryComparerTest.cs b/ReClass.NET_Tests/MemoryScanner/Comparer/FloatMemoryComparerTest.cs index 5084f442..b9824d4d 100644 --- a/ReClass.NET_Tests/MemoryScanner/Comparer/FloatMemoryComparerTest.cs +++ b/ReClass.NET_Tests/MemoryScanner/Comparer/FloatMemoryComparerTest.cs @@ -1,13 +1,16 @@ -using System; +using System; using NFluent; using ReClassNET.MemoryScanner; using ReClassNET.MemoryScanner.Comparer; +using ReClassNET.Util.Conversion; using Xunit; namespace ReClass.NET_Tests.MemoryScanner.Comparer { public class FloatMemoryComparerTest { + private static EndianBitConverter BitConverter { get; } = EndianBitConverter.System; + [Theory] [InlineData(ScanCompareType.Equal, ScanRoundMode.Normal, 0.0f, 0.0f)] [InlineData(ScanCompareType.Equal, ScanRoundMode.Strict, 1.0f, 2.0f)] @@ -17,7 +20,7 @@ public class FloatMemoryComparerTest [InlineData(ScanCompareType.NotEqual, ScanRoundMode.Truncate, 0.0f, 0.0f)] public void TestConstructor(ScanCompareType compareType, ScanRoundMode roundMode, float value1, float value2) { - var sut = new FloatMemoryComparer(compareType, roundMode, 1, value1, value2); + var sut = new FloatMemoryComparer(compareType, roundMode, 1, value1, value2, BitConverter); Check.That(sut.CompareType).IsEqualTo(compareType); Check.That(sut.RoundType).IsEqualTo(roundMode); @@ -35,7 +38,7 @@ public void TestConstructorSignificantDigits(int significantDigits) const float Value1 = 1.234567f; const float Value2 = 7.654321f; - var sut = new FloatMemoryComparer(ScanCompareType.Equal, ScanRoundMode.Normal, significantDigits, Value1, Value2); + var sut = new FloatMemoryComparer(ScanCompareType.Equal, ScanRoundMode.Normal, significantDigits, Value1, Value2, BitConverter); Check.That(sut.Value1).IsEqualTo((float)Math.Round(Value1, significantDigits, MidpointRounding.AwayFromZero)); Check.That(sut.Value2).IsEqualTo((float)Math.Round(Value2, significantDigits, MidpointRounding.AwayFromZero)); @@ -74,7 +77,7 @@ public void TestConstructorSignificantDigits(int significantDigits) [MemberData(nameof(GetTestCompareScanCompareTypeUnknownData))] public void TestCompare(ScanCompareType compareType, float value1, float value2, byte[] data, bool expectedResult, ScanResult expectedScanResult) { - var sut = new FloatMemoryComparer(compareType, ScanRoundMode.Normal, 1, value1, value2); + var sut = new FloatMemoryComparer(compareType, ScanRoundMode.Normal, 1, value1, value2, BitConverter); Check.That(sut.Compare(data, 0, out var scanResult)).IsEqualTo(expectedResult); Check.That(scanResult).IsEqualTo(expectedScanResult); @@ -93,7 +96,7 @@ public void TestCompare(ScanCompareType compareType, float value1, float value2, [InlineData(ScanCompareType.IncreasedOrEqual)] public void TestCompareInvalidCompareTypeThrows(ScanCompareType compareType) { - var sut = new FloatMemoryComparer(compareType, ScanRoundMode.Normal, 1, 0.0f, 0.0f); + var sut = new FloatMemoryComparer(compareType, ScanRoundMode.Normal, 1, 0.0f, 0.0f, BitConverter); Check.ThatCode(() => sut.Compare(BitConverter.GetBytes(0.0f), 0, out _)).Throws(); } @@ -109,7 +112,7 @@ public void TestCompareInvalidCompareTypeThrows(ScanCompareType compareType) [MemberData(nameof(GetTestCompareThrowsData))] public void TestCompareInvalidDataThrows(byte[] data, int index, Type expectedExceptionType) { - var sut = new FloatMemoryComparer(ScanCompareType.Unknown, ScanRoundMode.Normal, 1, 0.0f, 0.0f); + var sut = new FloatMemoryComparer(ScanCompareType.Unknown, ScanRoundMode.Normal, 1, 0.0f, 0.0f, BitConverter); Check.ThatCode(() => sut.Compare(data, index, out _)).ThrowsType(expectedExceptionType); } @@ -149,7 +152,7 @@ public static TheoryData sut.Compare(BitConverter.GetBytes(0.0f), 0, new FloatScanResult(0.0f), out _)).Throws(); } diff --git a/ReClass.NET_Tests/MemoryScanner/Comparer/IntegerMemoryComparerTest.cs b/ReClass.NET_Tests/MemoryScanner/Comparer/IntegerMemoryComparerTest.cs index acbfd201..0d6b8e1d 100644 --- a/ReClass.NET_Tests/MemoryScanner/Comparer/IntegerMemoryComparerTest.cs +++ b/ReClass.NET_Tests/MemoryScanner/Comparer/IntegerMemoryComparerTest.cs @@ -1,13 +1,16 @@ -using System; +using System; using NFluent; using ReClassNET.MemoryScanner; using ReClassNET.MemoryScanner.Comparer; +using ReClassNET.Util.Conversion; using Xunit; namespace ReClass.NET_Tests.MemoryScanner.Comparer { public class IntegerMemoryComparerTest { + private static EndianBitConverter BitConverter { get; } = EndianBitConverter.System; + [Theory] [InlineData(ScanCompareType.Equal, 0, 0)] [InlineData(ScanCompareType.Equal, 1, 2)] @@ -17,7 +20,7 @@ public class IntegerMemoryComparerTest [InlineData(ScanCompareType.NotEqual, 0, 0)] public void TestConstructor(ScanCompareType compareType, int value1, int value2) { - var sut = new IntegerMemoryComparer(compareType, value1, value2); + var sut = new IntegerMemoryComparer(compareType, value1, value2, BitConverter); Check.That(sut.CompareType).IsEqualTo(compareType); Check.That(sut.ValueSize).IsEqualTo(sizeof(int)); @@ -64,7 +67,7 @@ public void TestConstructor(ScanCompareType compareType, int value1, int value2) [MemberData(nameof(GetTestCompareScanCompareTypeUnknownData))] public void TestCompare(ScanCompareType compareType, int value1, int value2, byte[] data, bool expectedResult, ScanResult expectedScanResult) { - var sut = new IntegerMemoryComparer(compareType, value1, value2); + var sut = new IntegerMemoryComparer(compareType, value1, value2, BitConverter); Check.That(sut.Compare(data, 0, out var scanResult)).IsEqualTo(expectedResult); Check.That(scanResult).IsEqualTo(expectedScanResult); @@ -83,7 +86,7 @@ public void TestCompare(ScanCompareType compareType, int value1, int value2, byt [InlineData(ScanCompareType.IncreasedOrEqual)] public void TestCompareInvalidCompareTypeThrows(ScanCompareType compareType) { - var sut = new IntegerMemoryComparer(compareType, 0, 0); + var sut = new IntegerMemoryComparer(compareType, 0, 0, BitConverter); Check.ThatCode(() => sut.Compare(BitConverter.GetBytes(0), 0, out _)).Throws(); } @@ -101,7 +104,7 @@ public void TestCompareInvalidCompareTypeThrows(ScanCompareType compareType) [MemberData(nameof(GetTestCompareThrowsData))] public void TestCompareInvalidDataThrows(byte[] data, int index, Type expectedExceptionType) { - var sut = new IntegerMemoryComparer(ScanCompareType.Equal, 0, 0); + var sut = new IntegerMemoryComparer(ScanCompareType.Equal, 0, 0, BitConverter); Check.ThatCode(() => sut.Compare(data, index, out _)).ThrowsType(expectedExceptionType); } @@ -141,7 +144,7 @@ public static TheoryData sut.Compare(BitConverter.GetBytes(0), 0, new IntegerScanResult(0), out _)).Throws(); } diff --git a/ReClass.NET_Tests/MemoryScanner/Comparer/LongMemoryComparerTest.cs b/ReClass.NET_Tests/MemoryScanner/Comparer/LongMemoryComparerTest.cs index f2790648..a298ebb3 100644 --- a/ReClass.NET_Tests/MemoryScanner/Comparer/LongMemoryComparerTest.cs +++ b/ReClass.NET_Tests/MemoryScanner/Comparer/LongMemoryComparerTest.cs @@ -1,13 +1,16 @@ -using System; +using System; using NFluent; using ReClassNET.MemoryScanner; using ReClassNET.MemoryScanner.Comparer; +using ReClassNET.Util.Conversion; using Xunit; namespace ReClass.NET_Tests.MemoryScanner.Comparer { public class LongMemoryComparerTest { + private static EndianBitConverter BitConverter { get; } = EndianBitConverter.System; + [Theory] [InlineData(ScanCompareType.Equal, 0L, 0L)] [InlineData(ScanCompareType.Equal, 1L, 2L)] @@ -17,7 +20,7 @@ public class LongMemoryComparerTest [InlineData(ScanCompareType.NotEqual, 0L, 0L)] public void TestConstructor(ScanCompareType compareType, long value1, long value2) { - var sut = new LongMemoryComparer(compareType, value1, value2); + var sut = new LongMemoryComparer(compareType, value1, value2, BitConverter); Check.That(sut.CompareType).IsEqualTo(compareType); Check.That(sut.ValueSize).IsEqualTo(sizeof(long)); @@ -64,7 +67,7 @@ public void TestConstructor(ScanCompareType compareType, long value1, long value [MemberData(nameof(GetTestCompareScanCompareTypeUnknownData))] public void TestCompare(ScanCompareType compareType, long value1, long value2, byte[] data, bool expectedResult, ScanResult expectedScanResult) { - var sut = new LongMemoryComparer(compareType, value1, value2); + var sut = new LongMemoryComparer(compareType, value1, value2, BitConverter); Check.That(sut.Compare(data, 0, out var scanResult)).IsEqualTo(expectedResult); Check.That(scanResult).IsEqualTo(expectedScanResult); @@ -83,7 +86,7 @@ public void TestCompare(ScanCompareType compareType, long value1, long value2, b [InlineData(ScanCompareType.IncreasedOrEqual)] public void TestCompareInvalidCompareTypeThrows(ScanCompareType compareType) { - var sut = new LongMemoryComparer(compareType, 0L, 0L); + var sut = new LongMemoryComparer(compareType, 0L, 0L, BitConverter); Check.ThatCode(() => sut.Compare(BitConverter.GetBytes(0L), 0, out _)).Throws(); } @@ -101,7 +104,7 @@ public void TestCompareInvalidCompareTypeThrows(ScanCompareType compareType) [MemberData(nameof(GetTestCompareThrowsData))] public void TestCompareInvalidDataThrows(byte[] data, int index, Type expectedExceptionType) { - var sut = new LongMemoryComparer(ScanCompareType.Equal, 0L, 0L); + var sut = new LongMemoryComparer(ScanCompareType.Equal, 0L, 0L, BitConverter); Check.ThatCode(() => sut.Compare(data, index, out _)).ThrowsType(expectedExceptionType); } @@ -141,7 +144,7 @@ public static TheoryData sut.Compare(BitConverter.GetBytes(0L), 0, new LongScanResult(0L), out _)).Throws(); } diff --git a/ReClass.NET_Tests/MemoryScanner/Comparer/ShortMemoryComparerTest.cs b/ReClass.NET_Tests/MemoryScanner/Comparer/ShortMemoryComparerTest.cs index 7c3109fe..b87f37ef 100644 --- a/ReClass.NET_Tests/MemoryScanner/Comparer/ShortMemoryComparerTest.cs +++ b/ReClass.NET_Tests/MemoryScanner/Comparer/ShortMemoryComparerTest.cs @@ -1,13 +1,16 @@ -using System; +using System; using NFluent; using ReClassNET.MemoryScanner; using ReClassNET.MemoryScanner.Comparer; +using ReClassNET.Util.Conversion; using Xunit; namespace ReClass.NET_Tests.MemoryScanner.Comparer { public class ShortMemoryComparerTest { + private static EndianBitConverter BitConverter { get; } = EndianBitConverter.System; + [Theory] [InlineData(ScanCompareType.Equal, 0, 0)] [InlineData(ScanCompareType.Equal, 1, 2)] @@ -17,7 +20,7 @@ public class ShortMemoryComparerTest [InlineData(ScanCompareType.NotEqual, 0, 0)] public void TestConstructor(ScanCompareType compareType, short value1, short value2) { - var sut = new ShortMemoryComparer(compareType, value1, value2); + var sut = new ShortMemoryComparer(compareType, value1, value2, BitConverter); Check.That(sut.CompareType).IsEqualTo(compareType); Check.That(sut.ValueSize).IsEqualTo(sizeof(short)); @@ -64,7 +67,7 @@ public void TestConstructor(ScanCompareType compareType, short value1, short val [MemberData(nameof(GetTestCompareScanCompareTypeUnknownData))] public void TestCompare(ScanCompareType compareType, short value1, short value2, byte[] data, bool expectedResult, ScanResult expectedScanResult) { - var sut = new ShortMemoryComparer(compareType, value1, value2); + var sut = new ShortMemoryComparer(compareType, value1, value2, BitConverter); Check.That(sut.Compare(data, 0, out var scanResult)).IsEqualTo(expectedResult); Check.That(scanResult).IsEqualTo(expectedScanResult); @@ -83,7 +86,7 @@ public void TestCompare(ScanCompareType compareType, short value1, short value2, [InlineData(ScanCompareType.IncreasedOrEqual)] public void TestCompareInvalidCompareTypeThrows(ScanCompareType compareType) { - var sut = new ShortMemoryComparer(compareType, 0, 0); + var sut = new ShortMemoryComparer(compareType, 0, 0, BitConverter); Check.ThatCode(() => sut.Compare(BitConverter.GetBytes((short)0), 0, out _)).Throws(); } @@ -101,7 +104,7 @@ public void TestCompareInvalidCompareTypeThrows(ScanCompareType compareType) [MemberData(nameof(GetTestCompareThrowsData))] public void TestCompareInvalidDataThrows(byte[] data, int index, Type expectedExceptionType) { - var sut = new ShortMemoryComparer(ScanCompareType.Equal, 0, 0); + var sut = new ShortMemoryComparer(ScanCompareType.Equal, 0, 0, BitConverter); Check.ThatCode(() => sut.Compare(data, index, out _)).ThrowsType(expectedExceptionType); } @@ -141,7 +144,7 @@ public static TheoryData sut.Compare(BitConverter.GetBytes((short)0), 0, new ShortScanResult(0), out _)).Throws(); } From 4c50197e7cdfe88b0c7f03a73d84a2e3506d6f7c Mon Sep 17 00:00:00 2001 From: KN4CK3R Date: Sun, 22 Nov 2020 22:05:24 +0100 Subject: [PATCH 5/5] Added converter switch to menu. --- ReClass.NET/Forms/MainForm.Designer.cs | 105 +++++++++++++++---------- ReClass.NET/Forms/MainForm.cs | 7 ++ 2 files changed, 69 insertions(+), 43 deletions(-) diff --git a/ReClass.NET/Forms/MainForm.Designer.cs b/ReClass.NET/Forms/MainForm.Designer.cs index 71a1a118..e2b2a199 100644 --- a/ReClass.NET/Forms/MainForm.Designer.cs +++ b/ReClass.NET/Forms/MainForm.Designer.cs @@ -34,7 +34,7 @@ private void InitializeComponent() System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(MainForm)); this.processUpdateTimer = new System.Windows.Forms.Timer(this.components); this.splitContainer = new System.Windows.Forms.SplitContainer(); - this.projectView = new ProjectView(); + this.projectView = new ReClassNET.Controls.ProjectView(); this.projectClassContextMenuStrip = new System.Windows.Forms.ContextMenuStrip(this.components); this.deleteClassToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); this.toolStripSeparator19 = new System.Windows.Forms.ToolStripSeparator(); @@ -53,26 +53,26 @@ private void InitializeComponent() this.editEnumToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); this.projectEnumsContextMenuStrip = new System.Windows.Forms.ContextMenuStrip(this.components); this.editEnumsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.memoryViewControl = new MemoryViewControl(); + this.memoryViewControl = new ReClassNET.Controls.MemoryViewControl(); this.selectedNodeContextMenuStrip = new System.Windows.Forms.ContextMenuStrip(this.components); this.changeTypeToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); this.addBytesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.integerToolStripMenuItem1 = new IntegerToolStripMenuItem(); - this.integerToolStripMenuItem2 = new IntegerToolStripMenuItem(); - this.integerToolStripMenuItem3 = new IntegerToolStripMenuItem(); - this.integerToolStripMenuItem4 = new IntegerToolStripMenuItem(); - this.integerToolStripMenuItem5 = new IntegerToolStripMenuItem(); - this.integerToolStripMenuItem6 = new IntegerToolStripMenuItem(); - this.integerToolStripMenuItem7 = new IntegerToolStripMenuItem(); + this.integerToolStripMenuItem1 = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.integerToolStripMenuItem2 = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.integerToolStripMenuItem3 = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.integerToolStripMenuItem4 = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.integerToolStripMenuItem5 = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.integerToolStripMenuItem6 = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.integerToolStripMenuItem7 = new ReClassNET.Controls.IntegerToolStripMenuItem(); this.toolStripMenuItem1 = new System.Windows.Forms.ToolStripMenuItem(); this.insertBytesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); - this.integerToolStripMenuItem8 = new IntegerToolStripMenuItem(); - this.integerToolStripMenuItem9 = new IntegerToolStripMenuItem(); - this.integerToolStripMenuItem10 = new IntegerToolStripMenuItem(); - this.integerToolStripMenuItem11 = new IntegerToolStripMenuItem(); - this.integerToolStripMenuItem12 = new IntegerToolStripMenuItem(); - this.integerToolStripMenuItem13 = new IntegerToolStripMenuItem(); - this.integerToolStripMenuItem14 = new IntegerToolStripMenuItem(); + this.integerToolStripMenuItem8 = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.integerToolStripMenuItem9 = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.integerToolStripMenuItem10 = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.integerToolStripMenuItem11 = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.integerToolStripMenuItem12 = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.integerToolStripMenuItem13 = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.integerToolStripMenuItem14 = new ReClassNET.Controls.IntegerToolStripMenuItem(); this.toolStripMenuItem2 = new System.Windows.Forms.ToolStripMenuItem(); this.toolStripSeparator8 = new System.Windows.Forms.ToolStripSeparator(); this.createClassFromNodesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); @@ -107,22 +107,22 @@ private void InitializeComponent() this.toolStripSeparator7 = new System.Windows.Forms.ToolStripSeparator(); this.newClassToolStripButton = new System.Windows.Forms.ToolStripButton(); this.addBytesToolStripDropDownButton = new System.Windows.Forms.ToolStripDropDownButton(); - this.add4BytesToolStripMenuItem = new IntegerToolStripMenuItem(); - this.add8BytesToolStripMenuItem = new IntegerToolStripMenuItem(); - this.add64BytesToolStripMenuItem = new IntegerToolStripMenuItem(); - this.add256BytesToolStripMenuItem = new IntegerToolStripMenuItem(); - this.add1024BytesToolStripMenuItem = new IntegerToolStripMenuItem(); - this.add2048BytesToolStripMenuItem = new IntegerToolStripMenuItem(); - this.add4096BytesToolStripMenuItem = new IntegerToolStripMenuItem(); + this.add4BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.add8BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.add64BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.add256BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.add1024BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.add2048BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.add4096BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); this.addXBytesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); this.insertBytesToolStripDropDownButton = new System.Windows.Forms.ToolStripDropDownButton(); - this.insert4BytesToolStripMenuItem = new IntegerToolStripMenuItem(); - this.insert8BytesToolStripMenuItem = new IntegerToolStripMenuItem(); - this.insert64BytesToolStripMenuItem = new IntegerToolStripMenuItem(); - this.insert256BytesToolStripMenuItem = new IntegerToolStripMenuItem(); - this.insert1024BytesToolStripMenuItem = new IntegerToolStripMenuItem(); - this.insert2048BytesToolStripMenuItem = new IntegerToolStripMenuItem(); - this.insert4096BytesToolStripMenuItem = new IntegerToolStripMenuItem(); + this.insert4BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.insert8BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.insert64BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.insert256BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.insert1024BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.insert2048BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); + this.insert4096BytesToolStripMenuItem = new ReClassNET.Controls.IntegerToolStripMenuItem(); this.insertXBytesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); this.nodeTypesToolStripSeparator = new System.Windows.Forms.ToolStripSeparator(); this.statusStrip = new System.Windows.Forms.StatusStrip(); @@ -149,6 +149,8 @@ private void InitializeComponent() this.processInformationsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); this.memorySearcherToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); this.namedAddressesToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); + this.toolStripSeparator23 = new System.Windows.Forms.ToolStripSeparator(); + this.isLittleEndianToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); this.toolStripSeparator17 = new System.Windows.Forms.ToolStripSeparator(); this.loadSymbolToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); this.loadSymbolsToolStripMenuItem = new System.Windows.Forms.ToolStripMenuItem(); @@ -215,7 +217,7 @@ private void InitializeComponent() this.projectView.Name = "projectView"; this.projectView.Size = new System.Drawing.Size(201, 524); this.projectView.TabIndex = 0; - this.projectView.SelectionChanged += new ProjectView.SelectionChangedEvent(this.classesView_ClassSelected); + this.projectView.SelectionChanged += new ReClassNET.Controls.ProjectView.SelectionChangedEvent(this.classesView_ClassSelected); // // projectClassContextMenuStrip // @@ -273,33 +275,33 @@ private void InitializeComponent() this.toolStripSeparator22, this.addNewClassToolStripMenuItem}); this.projectClassesContextMenuStrip.Name = "rootContextMenuStrip"; - this.projectClassesContextMenuStrip.Size = new System.Drawing.Size(221, 126); + this.projectClassesContextMenuStrip.Size = new System.Drawing.Size(222, 126); // // enableHierarchyViewToolStripMenuItem // this.enableHierarchyViewToolStripMenuItem.Name = "enableHierarchyViewToolStripMenuItem"; - this.enableHierarchyViewToolStripMenuItem.Size = new System.Drawing.Size(220, 22); + this.enableHierarchyViewToolStripMenuItem.Size = new System.Drawing.Size(221, 22); this.enableHierarchyViewToolStripMenuItem.Text = "Enable hierarchy view"; this.enableHierarchyViewToolStripMenuItem.Click += new System.EventHandler(this.enableHierarchyViewToolStripMenuItem_Click); // // autoExpandHierarchyViewToolStripMenuItem // this.autoExpandHierarchyViewToolStripMenuItem.Name = "autoExpandHierarchyViewToolStripMenuItem"; - this.autoExpandHierarchyViewToolStripMenuItem.Size = new System.Drawing.Size(220, 22); + this.autoExpandHierarchyViewToolStripMenuItem.Size = new System.Drawing.Size(221, 22); this.autoExpandHierarchyViewToolStripMenuItem.Text = "Auto expand hierarchy view"; this.autoExpandHierarchyViewToolStripMenuItem.Click += new System.EventHandler(this.autoExpandHierarchyViewToolStripMenuItem_Click); // // toolStripSeparator21 // this.toolStripSeparator21.Name = "toolStripSeparator21"; - this.toolStripSeparator21.Size = new System.Drawing.Size(217, 6); + this.toolStripSeparator21.Size = new System.Drawing.Size(218, 6); // // expandAllClassesToolStripMenuItem // this.expandAllClassesToolStripMenuItem.Enabled = false; this.expandAllClassesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Tree_Expand; this.expandAllClassesToolStripMenuItem.Name = "expandAllClassesToolStripMenuItem"; - this.expandAllClassesToolStripMenuItem.Size = new System.Drawing.Size(220, 22); + this.expandAllClassesToolStripMenuItem.Size = new System.Drawing.Size(221, 22); this.expandAllClassesToolStripMenuItem.Text = "Expand all classes"; this.expandAllClassesToolStripMenuItem.Click += new System.EventHandler(this.expandAllClassesToolStripMenuItem_Click); // @@ -308,20 +310,20 @@ private void InitializeComponent() this.collapseAllClassesToolStripMenuItem.Enabled = false; this.collapseAllClassesToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Tree_Collapse; this.collapseAllClassesToolStripMenuItem.Name = "collapseAllClassesToolStripMenuItem"; - this.collapseAllClassesToolStripMenuItem.Size = new System.Drawing.Size(220, 22); + this.collapseAllClassesToolStripMenuItem.Size = new System.Drawing.Size(221, 22); this.collapseAllClassesToolStripMenuItem.Text = "Collapse all classes"; this.collapseAllClassesToolStripMenuItem.Click += new System.EventHandler(this.collapseAllClassesToolStripMenuItem_Click); // // toolStripSeparator22 // this.toolStripSeparator22.Name = "toolStripSeparator22"; - this.toolStripSeparator22.Size = new System.Drawing.Size(217, 6); + this.toolStripSeparator22.Size = new System.Drawing.Size(218, 6); // // addNewClassToolStripMenuItem // this.addNewClassToolStripMenuItem.Image = global::ReClassNET.Properties.Resources.B16x16_Button_Class_Add; this.addNewClassToolStripMenuItem.Name = "addNewClassToolStripMenuItem"; - this.addNewClassToolStripMenuItem.Size = new System.Drawing.Size(220, 22); + this.addNewClassToolStripMenuItem.Size = new System.Drawing.Size(221, 22); this.addNewClassToolStripMenuItem.Text = "Add new class"; this.addNewClassToolStripMenuItem.Click += new System.EventHandler(this.newClassToolStripButton_Click); // @@ -364,11 +366,11 @@ private void InitializeComponent() this.memoryViewControl.NodeContextMenuStrip = this.selectedNodeContextMenuStrip; this.memoryViewControl.Size = new System.Drawing.Size(936, 524); this.memoryViewControl.TabIndex = 0; - this.memoryViewControl.DrawContextRequested += new DrawContextRequestEventHandler(this.memoryViewControl_DrawContextRequested); + this.memoryViewControl.DrawContextRequested += new ReClassNET.Controls.DrawContextRequestEventHandler(this.memoryViewControl_DrawContextRequested); this.memoryViewControl.SelectionChanged += new System.EventHandler(this.memoryViewControl_SelectionChanged); - this.memoryViewControl.ChangeClassTypeClick += new NodeClickEventHandler(this.memoryViewControl_ChangeClassTypeClick); - this.memoryViewControl.ChangeWrappedTypeClick += new NodeClickEventHandler(this.memoryViewControl_ChangeWrappedTypeClick); - this.memoryViewControl.ChangeEnumTypeClick += new NodeClickEventHandler(this.memoryViewControl_ChangeEnumTypeClick); + this.memoryViewControl.ChangeClassTypeClick += new ReClassNET.Controls.NodeClickEventHandler(this.memoryViewControl_ChangeClassTypeClick); + this.memoryViewControl.ChangeWrappedTypeClick += new ReClassNET.Controls.NodeClickEventHandler(this.memoryViewControl_ChangeWrappedTypeClick); + this.memoryViewControl.ChangeEnumTypeClick += new ReClassNET.Controls.NodeClickEventHandler(this.memoryViewControl_ChangeEnumTypeClick); this.memoryViewControl.KeyDown += new System.Windows.Forms.KeyEventHandler(this.memoryViewControl_KeyDown); // // selectedNodeContextMenuStrip @@ -1190,6 +1192,8 @@ private void InitializeComponent() this.processInformationsToolStripMenuItem, this.memorySearcherToolStripMenuItem, this.namedAddressesToolStripMenuItem, + this.toolStripSeparator23, + this.isLittleEndianToolStripMenuItem, this.toolStripSeparator17, this.loadSymbolToolStripMenuItem, this.loadSymbolsToolStripMenuItem, @@ -1225,6 +1229,19 @@ private void InitializeComponent() this.namedAddressesToolStripMenuItem.Text = "Named Addresses..."; this.namedAddressesToolStripMenuItem.Click += new System.EventHandler(this.namedAddressesToolStripMenuItem_Click); // + // toolStripSeparator23 + // + this.toolStripSeparator23.Name = "toolStripSeparator23"; + this.toolStripSeparator23.Size = new System.Drawing.Size(191, 6); + // + // isLittleEndianToolStripMenuItem + // + this.isLittleEndianToolStripMenuItem.CheckOnClick = true; + this.isLittleEndianToolStripMenuItem.Name = "isLittleEndianToolStripMenuItem"; + this.isLittleEndianToolStripMenuItem.Size = new System.Drawing.Size(194, 22); + this.isLittleEndianToolStripMenuItem.Text = "Is Little Endian"; + this.isLittleEndianToolStripMenuItem.Click += new System.EventHandler(this.isLittleEndianToolStripMenuItem_Click); + // // toolStripSeparator17 // this.toolStripSeparator17.Name = "toolStripSeparator17"; @@ -1523,6 +1540,8 @@ private void InitializeComponent() private System.Windows.Forms.ContextMenuStrip projectEnumsContextMenuStrip; private System.Windows.Forms.ToolStripMenuItem editEnumsToolStripMenuItem; private System.Windows.Forms.ToolStripMenuItem showEnumsToolStripMenuItem; + private System.Windows.Forms.ToolStripSeparator toolStripSeparator23; + private System.Windows.Forms.ToolStripMenuItem isLittleEndianToolStripMenuItem; } } diff --git a/ReClass.NET/Forms/MainForm.cs b/ReClass.NET/Forms/MainForm.cs index bff83d26..e9a18b38 100644 --- a/ReClass.NET/Forms/MainForm.cs +++ b/ReClass.NET/Forms/MainForm.cs @@ -21,6 +21,7 @@ using ReClassNET.Project; using ReClassNET.UI; using ReClassNET.Util; +using ReClassNET.Util.Conversion; namespace ReClassNET.Forms { @@ -78,6 +79,7 @@ public MainForm() mainMenuStrip.Renderer = new CustomToolStripProfessionalRenderer(true, true); toolStrip.Renderer = new CustomToolStripProfessionalRenderer(true, false); + isLittleEndianToolStripMenuItem.Checked = BitConverter.IsLittleEndian; Program.RemoteProcess.ProcessAttached += sender => { @@ -351,6 +353,11 @@ private void namedAddressesToolStripMenuItem_Click(object sender, EventArgs e) new NamedAddressesForm(Program.RemoteProcess).Show(); } + private void isLittleEndianToolStripMenuItem_Click(object sender, EventArgs e) + { + Program.RemoteProcess.BitConverter = isLittleEndianToolStripMenuItem.Checked ? (EndianBitConverter)EndianBitConverter.Little : EndianBitConverter.Big; + } + private void loadSymbolToolStripMenuItem_Click(object sender, EventArgs e) { using var ofd = new OpenFileDialog