/// <summary>
/// Initializes a new instance of the <see cref="ListBase"/> class.
/// </summary>
/// <param name="variable">The value.</param>
/// <param name="savedData">Data returned from VerifyCodeType function.</param>
public ListBase(Variable variable, object savedData)
{
data = (ExtractedData)savedData;
ulong address = variable.GetPointerAddress();
length = data.ReadLength(address);
headAddress = data.Process.ReadPointer(address + (uint)data.HeadOffset);
}
/// <summary>
/// Initializes a new instance of the <see cref="OptionalBase"/> class.
/// </summary>
/// <param name="variable">The value.</param>
/// <param name="savedData">Data returned from VerifyCodeType function.</param>
public OptionalBase(Variable variable, object savedData)
{
data = (ExtractedData)savedData;
ulong address = variable.GetPointerAddress();
valueAddress = address + (uint)data.ValueOffset;
HasValue = data.Process.ReadByte(address + (uint)data.HasValueOffset) != 0;
}
/// <summary>
/// Initializes a new instance of the <see cref="VisualStudio"/> class.
/// </summary>
/// <param name="variable">The variable.</param>
/// <param name="savedData">Data returned from VerifyCodeType function.</param>
public VisualStudio(Variable variable, object savedData)
{
data = (ExtractedData)savedData;
address = variable.GetPointerAddress();
length = data.ReadSize(address);
reserved = data.ReadReserved(address);
text = UserMember.Create(() => GetText());
}
public void VirtualMultiClassInheritance2()
{
Variable e = DefaultModule.GetVariable("virtualMultiClassInheritanceTest2");
Assert.Equal(42, (int)e.GetField("e"));
Assert.Equal(42, (double)e.GetField("b"));
Assert.Equal(42, (float)e.GetField("c"));
Assert.Equal(42, (sbyte)e.GetField("a"));
Variable a = e.GetBaseClass("VirtualMultiClassInheritanceA");
Assert.Equal(42, (sbyte)a.GetField("a"));
Variable b = e.GetBaseClass("VirtualMultiClassInheritanceB");
Assert.Equal(42, (double)b.GetField("b"));
Variable ba = b.GetBaseClass("VirtualMultiClassInheritanceA");
Assert.Equal(42, (sbyte)ba.GetField("a"));
Variable c = e.GetBaseClass("VirtualMultiClassInheritanceC");
Assert.Equal(42, (float)c.GetField("c"));
Variable ca = c.GetBaseClass("VirtualMultiClassInheritanceA");
Assert.Equal(42, (sbyte)ca.GetField("a"));
Assert.Equal(a.GetPointerAddress(), ba.GetPointerAddress());
Assert.Equal(ca.GetPointerAddress(), ba.GetPointerAddress());
Assert.Equal(e.GetPointerAddress(), b.DowncastInterface().GetPointerAddress());
Assert.Equal(ba.GetPointerAddress(), ba.DowncastInterface().GetPointerAddress());
Assert.Equal(e.GetPointerAddress(), c.DowncastInterface().GetPointerAddress());
Assert.Equal(ca.GetPointerAddress(), ca.DowncastInterface().GetPointerAddress());
if (ExecuteCodeGen)
{
InterpretInteractive($@"
Variable global = Process.Current.GetGlobal(""{DefaultModuleName}!virtualMultiClassInheritanceTest2"");
var e = new VirtualMultiClassInheritanceE(global);
var a = e.BaseClass_VirtualMultiClassInheritanceA;
var b = e.BaseClass_VirtualMultiClassInheritanceB;
var ba = b.BaseClass;
var c = e.BaseClass_VirtualMultiClassInheritanceC;
var ca = c.BaseClass;
AreEqual(42, e.e);
AreEqual(42, a.a);
AreEqual(42, b.b);
AreEqual(42, ba.a);
AreEqual(42, c.c);
AreEqual(42, ca.a);
IsTrue(a.GetDowncast() is VirtualMultiClassInheritanceE);
IsTrue(b.GetDowncast() is VirtualMultiClassInheritanceE);
IsTrue(ba.GetDowncast() is VirtualMultiClassInheritanceE);
IsTrue(c.GetDowncast() is VirtualMultiClassInheritanceE);
IsTrue(ca.GetDowncast() is VirtualMultiClassInheritanceE);
AreEqual(42, b.As<VirtualMultiClassInheritanceC>().c);
AreEqual(42, a.As<VirtualMultiClassInheritanceB>().b);
AreEqual(42, ba.As<VirtualMultiClassInheritanceC>().c);
AreEqual(42, ca.As<VirtualMultiClassInheritanceB>().b);
");
}
}
private static void AddVariable(string name, Variable variable, InteractiveWindowContent contentControl)
{
StackFrame currentFrame = variable.GetCodeType().Module.Process.CurrentThread.StackTrace.CurrentFrame;
Variable local, argument;
string scriptText;
if (currentFrame.Locals.TryGetValue(variable.GetName(), out local) && local == variable)
{
scriptText = "Locals." + variable.GetName();
}
else if (currentFrame.Arguments.TryGetValue(variable.GetName(), out argument) && argument == variable)
{
scriptText = "Arguments." + variable.GetName();
}
else
{
CodeType codeType = variable.GetCodeType();
CodeType baseCodeType = codeType;
int pointer = 0;
while (baseCodeType.IsPointer)
{
baseCodeType = baseCodeType.ElementType;
pointer++;
}
StringBuilder sb = new StringBuilder();
sb.Append("dynamic ");
sb.Append(name);
sb.Append(" = ");
sb.Append(pointer > 0 ? "Variable.CreatePointer(" : "Variable.Create(");
sb.Append("CodeType.Create(");
if (baseCodeType.Module.Process != Process.Current)
{
sb.Append($"Process.All.First(p => p.SystemId == {baseCodeType.Module.Process.SystemId}), ");
}
sb.Append('"');
sb.Append(baseCodeType.Module.Name);
sb.Append("!");
sb.Append(baseCodeType.Name);
sb.Append('"');
sb.Append(")");
for (int i = 0; i < pointer; i++)
{
sb.Append(".PointerToType");
}
sb.Append(", ");
sb.Append(variable.GetPointerAddress());
sb.Append(");");
sb.AppendLine();
sb.Append(name);
scriptText = sb.ToString();
}
contentControl.TextEditor.Text = scriptText;
contentControl.TextEditor.TextArea_ExecuteCSharpScript(null, null);
}
/// <summary>
/// Initializes a new instance of the <see cref="CodeFunction"/> class.
/// </summary>
/// <param name="variable">The variable.</param>
public CodeFunction(Variable variable)
: this(variable.GetPointerAddress(), variable.GetCodeType().Module.Process)
{
// Verify code type
if (!VerifyCodeType(variable.GetCodeType()))
{
throw new WrongCodeTypeException(variable, nameof(variable), "function");
}
}
/// <summary>
/// Initializes a new instance of the <see cref="SharedPtrBase"/> class.
/// </summary>
/// <param name="variable">The variable.</param>
/// <param name="savedData">Data returned from VerifyCodeType function.</param>
public SharedPtrBase(Variable variable, object savedData)
{
data = (ExtractedData)savedData;
ulong address = variable.GetPointerAddress();
pointerAddress = data.Process.ReadPointer(address + (uint)data.PointerOffset);
referenceCountAddress = data.Process.ReadPointer(address + (uint)data.ReferenceCountPointerOffset);
isCreatedWithMakeShared = UserMember.Create(() => data.TestCreatedWithMakeShared(Variable.Create(data.ReferenceCountCodeType, referenceCountAddress).DowncastInterface().GetCodeType()));
}
/// <summary>
/// Cast Variable to NakedPointer.
/// </summary>
/// <param name="variable">The Variable.</param>
/// <returns>Returns NakePointer to Variable pointer address.</returns>
public static NakedPointer ToNakedPointer(this Variable variable)
{
if (variable == null)
{
return(null);
}
return(new NakedPointer(variable.GetCodeType().Module.Process, variable.GetPointerAddress()));
}
/// <summary>
/// Initializes a new instance of the <see cref="CodeFunction"/> class.
/// </summary>
/// <param name="variable">The variable.</param>
public CodeFunction(Variable variable)
: this(variable.GetPointerAddress(), variable.GetCodeType().Module.Process)
{
// Verify code type
if (!VerifyCodeType(variable.GetCodeType()))
{
throw new WrongCodeTypeException(variable, nameof(variable), "function");
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CodeFunction"/> class.
/// </summary>
/// <param name="variable">The variable.</param>
public CodeFunction(Variable variable)
: this(variable.GetPointerAddress(), variable.GetCodeType().Module.Process)
{
// Verify code type
if (!VerifyCodeType(variable.GetCodeType()))
{
throw new Exception("Wrong code type of passed variable " + variable.GetCodeType().Name);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="VectorBase"/> class.
/// </summary>
/// <param name="variable">The variable.</param>
/// <param name="savedData">Data returned from VerifyCodeType function.</param>
public VectorBase(Variable variable, object savedData)
{
data = (ExtractedData)savedData;
ulong address = variable.GetPointerAddress();
firstAddress = data.Process.ReadPointer(address + (uint)data.FirstOffset);
lastAddress = data.Process.ReadPointer(address + (uint)data.LastOffset);
endAddress = data.Process.ReadPointer(address + (uint)data.EndOffset);
}
/// <summary>
/// Initializes a new instance of the <see cref="VisualStudioBool" /> class.
/// </summary>
/// <param name="variable">The variable.</param>
/// <param name="savedData">Data returned from VerifyCodeType function.</param>
public VisualStudioBool(Variable variable, object savedData)
{
data = (ExtractedData)savedData;
ulong address = variable.GetPointerAddress();
Variable vectorVariable = Variable.Create(data.CompressedVectorCodeType, address + (uint)data.CompressedVectorOffset);
compressedVector = new vector <uint>(vectorVariable);
Count = data.ReadLength(address);
}
/// <summary>
/// Initializes a new instance of the <see cref="LibStdCpp6_NoAbi"/> class.
/// </summary>
/// <param name="variable">The variable.</param>
/// <param name="savedData">Data returned from VerifyCodeType function.</param>
public LibStdCpp6_NoAbi(Variable variable, object savedData)
{
data = (ExtractedData)savedData;
address = variable.GetPointerAddress();
ulong stringAddress = data.Process.ReadPointer(address + (uint)data.PointerOffset);
length = data.ReadLength(stringAddress);
reserved = data.ReadCapacity(stringAddress);
text = UserMember.Create(() => data.Process.ReadString(stringAddress, data.CharSize, length));
}
/// <summary>
/// Enumerates this unordered_map.
/// </summary>
private IEnumerable <KeyValuePair <TKey, TValue> > Enumerate()
{
//foreach (Variable bucket in buckets.Value)
Variable bucket = beforeBegin.Value;
{
Variable element = bucket;
while (element != null && !element.IsNullPointer())
{
if (element.GetPointerAddress() != beforeBegin.Value.GetPointerAddress())
{
ulong itemAddress = element.GetPointerAddress() + element.GetCodeType().ElementType.Size;
pair <TKey, TValue> item = new pair <TKey, TValue>(Variable.Create(elementCodeType, itemAddress));
yield return(new KeyValuePair <TKey, TValue>(item.First, item.Second));
}
element = element.GetField("_M_nxt");
}
}
}
/// <summary>
/// Reads the memory from the specified process.
/// </summary>
/// <param name="process">The process.</param>
/// <param name="pointer">The pointer.</param>
/// <param name="size">The size.</param>
/// <returns>Buffer containing read memory</returns>
public static MemoryBuffer ReadMemory(Process process, Variable pointer, uint size)
{
if (pointer.GetCodeType().IsPointer)
{
return(ReadMemory(process, pointer.GetPointerAddress(), size));
}
else
{
return(ReadMemory(process, (ulong)pointer, size));
}
}
public void ReadingFloatPointTypes()
{
Variable doubleTest = DefaultModule.GetVariable("doubleTest");
Assert.AreEqual(3.5, (double)doubleTest.GetField("d"));
Assert.AreEqual(2.5, (float)doubleTest.GetField("f"));
Assert.AreEqual(5, (int)doubleTest.GetField("i"));
Variable doubleTest2 = Process.Current.GetGlobal($"{DefaultModuleName}!doubleTest");
Assert.AreEqual(doubleTest.GetPointerAddress(), doubleTest2.GetPointerAddress());
Assert.AreEqual(doubleTest.GetCodeType(), doubleTest2.GetCodeType());
}
/// <summary>
/// Initializes this instance of the <see cref="CodeArray{T}"/> class.
/// </summary>
/// <param name="variable">The variable.</param>
/// <param name="length">The array length.</param>
private void Initialize(Variable variable, int length)
{
this.variable = variable;
Length = length;
preCalculatedArray = ReadArray();
if (preCalculatedArray == null && variable.GetCodeType().ElementType.IsPointer&& length > 0)
{
var process = variable.GetCodeType().Module.Process;
var pointerSize = process.GetPointerSize();
var buffer = Debugger.ReadMemory(process, variable.GetPointerAddress(), (uint)Length * pointerSize);
addressesArray = UserType.ReadPointerArray(buffer, 0, Length, pointerSize);
}
}
private static void TestReading <T>(Variable var, T expectedValue)
{
Assert.Equal(expectedValue, var.CastAs <T>());
Assert.Equal(expectedValue, (T)Convert.ChangeType(var, typeof(T)));
NakedPointer pointer = new NakedPointer(var.GetPointerAddress());
CodePointer <T> codePointer = new CodePointer <T>(pointer);
Assert.Equal(expectedValue, codePointer.Element);
codePointer = new CodePointer <T>(pointer.GetPointerAddress());
Assert.Equal(expectedValue, codePointer.Element);
codePointer = new CodePointer <T>(var.GetPointer());
Assert.Equal(expectedValue, codePointer.Element);
CodeArray <T> codeArray = new CodeArray <T>(pointer, 1);
Assert.Equal(expectedValue, codeArray[0]);
}
/// <summary>
/// Initializes a new instance of the <see cref="ClangLibCpp"/> class.
/// </summary>
/// <param name="variable">The variable.</param>
/// <param name="savedData">Data returned from VerifyCodeType function.</param>
public ClangLibCpp(Variable variable, object savedData)
{
data = (ExtractedData)savedData;
address = variable.GetPointerAddress();
ulong managerAddress = data.Process.ReadPointer(address + (uint)data.ManagerPointerOffset);
if (managerAddress != 0)
{
Tuple <string, ulong> nameAndOffset = Context.SymbolProvider.GetSymbolNameByAddress(data.Process, managerAddress);
if (nameAndOffset != null)
{
managerName = nameAndOffset.Item1;
}
}
if (HasValue)
{
string codeTypeName;
string handlerCodeTypeName;
if (IsSmall)
{
string moduleName = managerName.Substring(0, managerName.IndexOf('!') + 1);
codeTypeName = moduleName + managerName.Substring(moduleName.Length + SmallHandlerNameStart.Length, managerName.Length - moduleName.Length - SmallHandlerNameStart.Length - SmallHandlerNameEnd.Length);
handlerCodeTypeName = $"{moduleName}std::__1::__any_imp::_SmallHandler<{codeTypeName.Substring(moduleName.Length)}>";
}
else if (IsLarge)
{
string moduleName = managerName.Substring(0, managerName.IndexOf('!') + 1);
codeTypeName = moduleName + managerName.Substring(moduleName.Length + LargeHandlerNameStart.Length, managerName.Length - moduleName.Length - LargeHandlerNameStart.Length - LargeHandlerNameEnd.Length);
handlerCodeTypeName = $"{moduleName}std::__1::__any_imp::_LargeHandler<{codeTypeName.Substring(moduleName.Length)}>";
}
else
{
throw new NotImplementedException();
}
CodeType handlerCodeType = CodeType.Create(handlerCodeTypeName);
valueCodeType = handlerCodeType.TemplateArguments[0] as CodeType ?? CodeType.Create(codeTypeName.Trim());
}
}
/// <summary>
/// Initializes a new instance of the <see cref="VisualStudio"/> class.
/// </summary>
/// <param name="variable">The variable.</param>
/// <param name="savedData">Data returned from VerifyCodeType function.</param>
public VisualStudio(Variable variable, object savedData)
{
data = (ExtractedData)savedData;
address = variable.GetPointerAddress();
typeData = data.Process.ReadPointer(address + (uint)data.TypeDataOffset);
if (HasValue)
{
Tuple <string, ulong> nameAndOffset = Context.SymbolProvider.GetSymbolNameByAddress(data.Process, TypeInfoAddress);
if (nameAndOffset != null)
{
string name = nameAndOffset.Item1;
if (name.EndsWith(rttiSignature))
{
name = name.Substring(0, name.Length - rttiSignature.Length);
valueCodeType = CodeType.Create(name);
}
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="LibStdCpp6_NoAbi"/> class.
/// </summary>
/// <param name="variable">The variable.</param>
public LibStdCpp6_NoAbi(Variable variable)
{
CodeType codeType = variable.GetCodeType();
CodeType templateCodeType = (CodeType)codeType.TemplateArguments[0];
CodeType listNodeCodeType = GetListNodeCodeType(codeType);
count = UserMember.Create(() =>
{
int count = 0;
Variable start = anchor.Value;
Variable next = start.GetField("_M_next");
while (next.GetPointerAddress() != start.GetPointerAddress())
{
next = next.GetField("_M_next");
count++;
}
return(count);
});
anchor = UserMember.Create(() => variable.GetField("_M_impl").GetField("_M_node"));
head = UserMember.Create(() => new item(anchor.Value.GetField("_M_next").CastAs(listNodeCodeType), templateCodeType));
}
/// <summary>
/// Initializes a new instance of the <see cref="VectorBoolBase" /> class.
/// </summary>
/// <param name="variable">The variable.</param>
/// <param name="savedData">Data returned from VerifyCodeType function.</param>
public VectorBoolBase(Variable variable, object savedData)
{
data = (ExtractedData)savedData;
ulong address = variable.GetPointerAddress();
ulong bufferAddress = data.Process.ReadPointer(address + (uint)data.CompressedBufferOffset);
Variable vectorVariable = Variable.CreatePointer(data.CompressedElementCodeType.PointerToType, bufferAddress);
int compressedLength = data.ReadCompressedLength(address);
if (data.CompressedElementCodeType.Size == 4)
{
compressedBuffer32 = new CodeArray <uint>(vectorVariable, compressedLength);
}
else if (data.CompressedElementCodeType.Size == 8)
{
compressedBuffer64 = new CodeArray <ulong>(vectorVariable, compressedLength);
}
else
{
throw new NotImplementedException();
}
Count = data.ReadLength(address);
}
/// <summary>
/// Initializes a new instance of the <see cref="LibStdCpp7"/> class.
/// </summary>
/// <param name="variable">The variable.</param>
/// <param name="savedData">Data returned from VerifyCodeType function.</param>
public LibStdCpp7(Variable variable, object savedData)
{
data = (ExtractedData)savedData;
address = variable.GetPointerAddress();
ulong managerAddress = data.Process.ReadPointer(address + (uint)data.ManagerPointerOffset);
if (managerAddress != 0)
{
Tuple <string, ulong> nameAndOffset = Context.SymbolProvider.GetSymbolNameByAddress(data.Process, managerAddress);
if (nameAndOffset != null)
{
managerName = nameAndOffset.Item1;
}
}
if (HasValue)
{
string codeTypeName;
if (IsInternal)
{
string moduleName = managerName.Substring(0, managerName.IndexOf('!') + 1);
codeTypeName = moduleName + managerName.Substring(moduleName.Length + InternalManagerNameStart.Length, managerName.Length - moduleName.Length - InternalManagerNameStart.Length - InternalManagerNameEnd.Length);
}
else if (IsExternal)
{
string moduleName = managerName.Substring(0, managerName.IndexOf('!') + 1);
codeTypeName = moduleName + managerName.Substring(moduleName.Length + ExternalManagerNameStart.Length, managerName.Length - moduleName.Length - ExternalManagerNameStart.Length - ExternalManagerNameEnd.Length);
}
else
{
throw new NotImplementedException();
}
valueCodeType = CodeType.Create(codeTypeName.Trim());
}
}
/// <summary>
/// Creates <see cref="IBitmap"/> with the specified pixel type.
/// </summary>
/// <typeparam name="PixelType">Type of the pixel.</typeparam>
/// <param name="width">Width of the image.</param>
/// <param name="height">Height of the image.</param>
/// <param name="data">Bitmap data.</param>
/// <param name="channels">Description of the image channels.</param>
/// <param name="stride">Bitmap stride.</param>
/// <returns>Instance of the <see cref="IBitmap"/> object.</returns>
public IBitmap CreateImage <PixelType>(dynamic width, dynamic height, dynamic data, ChannelType[] channels, dynamic stride = null)
{
int imageWidth = Convert.ToInt32(width);
int imageHeight = Convert.ToInt32(width);
int dataStride = stride == null ? -1 : Convert.ToInt32(stride);
Variable dataVariable = data as Variable;
NakedPointer dataPointer;
if (dataVariable != null)
{
dataPointer = new NakedPointer(dataVariable.GetCodeType().Module.Process, dataVariable.GetPointerAddress());
}
else
{
dataPointer = new NakedPointer(Convert.ToUInt64(data));
}
// pixels will be PixelType[], but if we use dynamic, compiler will do the magic to call the right function.
dynamic pixels = ReadPixels <PixelType>(imageWidth, imageHeight, dataPointer, dataStride, channels.Length);
return(Graphics.CreateBitmap(imageWidth, imageHeight, channels, pixels));
}
/// <summary>
/// Does the full downcast, looks up the type based on virtual table and shifts variable address if multi-inheritance was involved.
/// </summary>
/// <param name="variable">The variable.</param>
public static Variable DowncastInterface(this Variable variable)
{
if (variable == null)
{
return(null);
}
var runtimeTypeAndOffset = variable.runtimeCodeTypeAndOffset.Value;
if (runtimeTypeAndOffset.Item2 != 0 || variable.GetCodeType() != runtimeTypeAndOffset.Item1)
{
return(Variable.CreatePointer(runtimeTypeAndOffset.Item1.PointerToType, variable.GetPointerAddress() - (uint)runtimeTypeAndOffset.Item2));
}
return(variable);
}
/// <summary>
/// Initializes a new instance of the <see cref="VariantBase"/> class.
/// </summary>
/// <param name="variable">The variable.</param>
/// <param name="savedData">Data returned from VerifyCodeType function.</param>
public VariantBase(Variable variable, object savedData)
{
data = (ExtractedData)savedData;
address = variable.GetPointerAddress();
Index = data.ReadIndex(address);
}
public void GetStackTraceFromContext()
{
DbgEngDll debugger = Context.Debugger as DbgEngDll;
StackFrame frame = GetFrame($"{DefaultModuleName}!TestDbgEngDll");
VariableCollection locals = frame.Locals;
Variable context = locals["context"];
Assert.NotNull(debugger);
Assert.NotNull(debugger.GetStackTraceFromContext(context.GetCodeType().Module.Process, context.GetPointerAddress()));
}
/// <summary>
/// Initializes a new instance of the <see cref="MapBase"/> class.
/// </summary>
/// <param name="variable">The variable.</param>
/// <param name="savedData">Data returned from VerifyCodeType function.</param>
public MapBase(Variable variable, object savedData)
{
data = (ExtractedData)savedData;
address = variable.GetPointerAddress();
size = data.ReadSize(address);
}
/// <summary>
/// Creates <see cref="IBitmap"/> with pixel type read from data element type.
/// </summary>
/// <remarks>
/// If <paramref name="data"/> is <see cref="Variable"/> of <see cref="CodeType"/> <code>unsigned char*</code>,
/// then pixel type is read as <code>byte</code>.
/// </remarks>
/// <param name="width">Width of the image.</param>
/// <param name="height">Height of the image.</param>
/// <param name="data">Bitmap data.</param>
/// <param name="channels">Description of the image channels.</param>
/// <param name="stride">Bitmap stride.</param>
/// <returns>Instance of the <see cref="IBitmap"/> object.</returns>
public IBitmap CreateImage(dynamic width, dynamic height, dynamic data, ChannelType[] channels, dynamic stride = null)
{
int imageWidth = Convert.ToInt32(width);
int imageHeight = Convert.ToInt32(width);
int dataStride = stride == null ? -1 : Convert.ToInt32(stride);
Variable dataVariable = data as Variable;
BuiltinType dataType;
NakedPointer dataPointer;
if (dataVariable != null)
{
dataPointer = new NakedPointer(dataVariable.GetCodeType().Module.Process, dataVariable.GetPointerAddress());
try
{
dataType = dataVariable.GetCodeType().ElementType.BuiltinType;
}
catch
{
dataType = dataVariable.GetCodeType().BuiltinType;
}
}
else
{
// Consider data as memory pointer and data type as byte
dataPointer = new NakedPointer(Convert.ToUInt64(data));
dataType = BuiltinType.UInt8;
}
switch (dataType)
{
case BuiltinType.Float32:
return(Graphics.CreateBitmap(imageWidth, imageHeight, channels, ReadPixels <float>(imageWidth, imageHeight, dataPointer, dataStride, channels.Length)));
case BuiltinType.Float64:
return(Graphics.CreateBitmap(imageWidth, imageHeight, channels, ReadPixels <double>(imageWidth, imageHeight, dataPointer, dataStride, channels.Length)));
case BuiltinType.Int8:
return(Graphics.CreateBitmap(imageWidth, imageHeight, channels, ReadPixels <sbyte>(imageWidth, imageHeight, dataPointer, dataStride, channels.Length)));
case BuiltinType.Int16:
return(Graphics.CreateBitmap(imageWidth, imageHeight, channels, ReadPixels <short>(imageWidth, imageHeight, dataPointer, dataStride, channels.Length)));
case BuiltinType.Int32:
return(Graphics.CreateBitmap(imageWidth, imageHeight, channels, ReadPixels <int>(imageWidth, imageHeight, dataPointer, dataStride, channels.Length)));
case BuiltinType.NoType:
case BuiltinType.Char8:
case BuiltinType.Void:
case BuiltinType.UInt8:
return(Graphics.CreateBitmap(imageWidth, imageHeight, channels, ReadPixels <byte>(imageWidth, imageHeight, dataPointer, dataStride, channels.Length)));
case BuiltinType.UInt16:
return(Graphics.CreateBitmap(imageWidth, imageHeight, channels, ReadPixels <ushort>(imageWidth, imageHeight, dataPointer, dataStride, channels.Length)));
default:
throw new NotImplementedException($"Unknown image data type: {dataType}");
}
}
public void ReadUnicodeString()
{
DbgEngDll debugger = Context.Debugger as DbgEngDll;
StackFrame frame = GetFrame($"{DefaultModuleName}!TestDbgEngDll");
VariableCollection locals = frame.Locals;
Variable testString = locals["testWString"];
Assert.NotNull(debugger);
Assert.Equal("Testing...", debugger.ReadUnicodeString(testString.GetCodeType().Module.Process, testString.GetPointerAddress()));
}
/// <summary>
/// Does the full downcast, looks up the type based on virtual table and shifts variable address if multi-inheritance was involved.
/// Difference from <see cref="VariableCastExtender.DowncastInterface(Variable)"/> is that this function returns downcasted .NET object
/// if T contains <see cref="DerivedClassAttribute"/>.
/// </summary>
/// <typeparam name="T">The base user type which will be downcasted.</typeparam>
/// <param name="userType">The user type.</param>
/// <returns>Downcasted .NET object, but upcasted to the original user type.</returns>
public static T DowncastObject <T>(this T userType)
where T : UserType, ICastableObject
{
if (userType == null)
{
return(null);
}
Dictionary <string, DerivedClassAttribute> attributes = UserTypeDelegates <T> .Instance.DerivedClassAttributesDictionary;
if (attributes.Count == 0)
{
throw new Exception(string.Format("Specified type {0} doesn't contain derived class attributes", typeof(T).Name));
}
Variable variable = userType.DowncastInterface();
CodeType originalCodeType = variable.GetCodeType();
List <Tuple <CodeType, int> > types = new List <Tuple <CodeType, int> >();
if (originalCodeType.IsPointer)
{
originalCodeType = originalCodeType.ElementType;
}
types.Add(Tuple.Create(originalCodeType, 0));
while (types.Count > 0)
{
List <Tuple <CodeType, int> > newTypes = new List <Tuple <CodeType, int> >();
foreach (Tuple <CodeType, int> tuple in types)
{
int offset = tuple.Item2;
CodeType codeType = tuple.Item1;
DerivedClassAttribute attribute;
if (attributes.TryGetValue(codeType.Name, out attribute))
{
// Check if we don't have top level code type
if (originalCodeType != codeType)
{
if (offset > 0)
{
variable = variable.AdjustPointer(offset);
}
variable = variable.CastAs(codeType);
}
UserType downcastedObject = (UserType)variable.CastAs(attribute.Type);
return(AsUpcast <T>(downcastedObject, (int)(userType.GetPointerAddress() - variable.GetPointerAddress())));
}
// Add base classes
foreach (var t in codeType.InheritedClassesSorted)
{
newTypes.Add(Tuple.Create(t.Item1, offset + t.Item2));
}
}
// Continue with new types
types = newTypes;
}
return(userType);
}
