/// <summary>
/// Returns the address to be used as memory context. This is used to get an address
/// from an expression entered into Visual Studio's memory view's address text box.
/// </summary>
public static ulong?GetMemoryContextAddress(this RemoteValue remoteValue)
{
if (!IsValidValue(remoteValue))
{
return(null);
}
TypeFlags GetTypeFlags(RemoteValue value) =>
remoteValue.GetTypeInfo().GetCanonicalType().GetTypeFlags();
// If the value is an array, try to obtain its address.
TypeFlags flags = GetTypeFlags(remoteValue);
if (flags.HasFlag(TypeFlags.IS_ARRAY))
{
remoteValue = remoteValue.AddressOf();
if (!IsValidValue(remoteValue))
{
return(null);
}
flags = GetTypeFlags(remoteValue);
}
// Only interpret pointers, references and integers as addresses.
if (!flags.HasFlag(TypeFlags.IS_REFERENCE) && !flags.HasFlag(TypeFlags.IS_POINTER) &&
!flags.HasFlag(TypeFlags.IS_INTEGER))
{
return(null);
}
return(remoteValue.GetValueAsUnsigned());
}
public bool RequiresIndirection(DataType dt, TypeFlags flags = 0)
{
if (flags == TypeFlags.ThisByRefDeclaration && dt.TypeType == TypeType.Interface ||
flags == TypeFlags.ThisInlineDeclaration && dt.TypeType == TypeType.Interface)
{
return(false);
}
if (flags == TypeFlags.ReturnByRef && IsConstrained(dt) ||
flags == TypeFlags.ParameterByRef && IsConstrained(dt) ||
flags.HasFlag(TypeFlags.ThisByRef) && IsConstrained(dt))
{
return(false);
}
return(flags.HasFlag(TypeFlags.ByRef) &&
!IsConstrained(dt) && !(
dt.IsReferenceType &&
(flags & TypeFlags.TypeMask) != TypeFlags.Return
) || (
dt.IsValueType &&
!flags.HasFlag(TypeFlags.Inline) &&
(flags & TypeFlags.TypeMask) == TypeFlags.Parameter &&
!IsConstrained(dt)
) || (
dt.IsStruct &&
!flags.HasFlag(TypeFlags.Inline) &&
flags.HasFlag(TypeFlags.This) &&
!IsConstrained(dt)
) ||
flags == TypeFlags.ParameterByRef ||
flags == (TypeFlags.ParameterByRef | TypeFlags.Inline));
}
public virtual string FormatValueAsAddress(RemoteValue remoteValue)
{
TypeFlags flags = remoteValue?.GetTypeInfo()?.GetTypeFlags() ?? 0;
if (flags.HasFlag(TypeFlags.IS_REFERENCE) || flags.HasFlag(TypeFlags.IS_POINTER))
{
return($"0x{remoteValue.GetValueAsUnsigned():x16}");
}
return(string.Empty);
}
public override string FormatValueAsAddress(RemoteValue remoteValue)
{
TypeFlags flags = remoteValue?.GetTypeInfo()?.GetTypeFlags() ?? 0;
if (flags.HasFlag(TypeFlags.IS_REFERENCE) || flags.HasFlag(TypeFlags.IS_POINTER))
{
if (ValueFormat == ValueFormat.HexUppercase)
{
return($"{remoteValue.GetValueAsUnsigned():X16}");
}
else
{
return($"{remoteValue.GetValueAsUnsigned():x16}");
}
}
return(string.Empty);
}
public static bool Test(IType type, TypeFlags typeFlags)
{
if (typeFlags.HasFlag(TypeFlags.Private) == true && type.AccessInfo.IsPrivate == false)
{
return(false);
}
if (typeFlags.HasFlag(TypeFlags.Public) == true && type.AccessInfo.IsPublic == false)
{
return(false);
}
if (typeFlags.HasFlag(TypeFlags.Locked) == true && type.LockInfo.IsLocked == false)
{
return(false);
}
if (typeFlags.HasFlag(TypeFlags.NotLocked) == true && type.LockInfo.IsLocked == true)
{
return(false);
}
if (typeFlags.HasFlag(TypeFlags.IsBeingEdited) == true && type.TypeState != TypeState.IsBeingEdited)
{
return(false);
}
if (typeFlags.HasFlag(TypeFlags.NotBeingEdited) == true && type.TypeState == TypeState.IsBeingEdited)
{
return(false);
}
if (typeFlags.HasFlag(TypeFlags.IsReferenced) == true && type.ReferencedTables.Any() == false)
{
return(false);
}
if (typeFlags.HasFlag(TypeFlags.NotReferenced) == true && type.ReferencedTables.Any() == true)
{
return(false);
}
if (typeFlags.HasFlag(TypeFlags.IsFlag) == true && type.TypeInfo.IsFlag == false)
{
return(false);
}
if (typeFlags.HasFlag(TypeFlags.NotFlag) == true && type.TypeInfo.IsFlag == true)
{
return(false);
}
return(true);
}
public string GetTypeDef(DataType dt, Namescope parent = null, TypeFlags flags = 0)
{
if (flags == TypeFlags.ThisByRefDeclaration && dt.TypeType == TypeType.Interface ||
flags == TypeFlags.ThisInlineDeclaration && dt.TypeType == TypeType.Interface)
{
return("const uInterface&");
}
if (flags == TypeFlags.ReturnByRef && IsConstrained(dt) ||
flags == TypeFlags.ParameterByRef && IsConstrained(dt) ||
flags.HasFlag(TypeFlags.ThisByRef) && IsConstrained(dt))
{
return("uTRef");
}
var name = GetTypeName(dt, parent, flags.HasFlag(TypeFlags.Inline));
return(RequiresIndirection(dt, flags)
? name + "*"
: name);
}
public IEnumerable <string> GetAllInheritedTypes()
{
SbType typeInfo = _remoteValue.GetTypeInfo();
if (typeInfo == null)
{
yield break;
}
TypeFlags typeFlags = typeInfo.GetTypeFlags();
if (typeFlags.HasFlag(TypeFlags.IS_POINTER) ||
typeFlags.HasFlag(TypeFlags.IS_REFERENCE))
{
typeInfo = typeInfo.GetPointeeType();
if (typeInfo == null)
{
yield break;
}
}
var typeQueue = new Queue <SbType>();
typeQueue.Enqueue(typeInfo);
while (typeQueue.Count > 0)
{
SbType curType = typeQueue.Dequeue();
yield return(curType.GetName());
uint numDirectBaseClasses = curType.GetNumberOfDirectBaseClasses();
for (uint i = 0; i < numDirectBaseClasses; i++)
{
typeQueue.Enqueue(curType.GetDirectBaseClassAtIndex(i).GetTypeInfo());
}
}
}
// Create type and add to dictionary
public static DataType Create(string name, Type valuetype, Type nativetype, DefaultDelegate defaulter, IsSubclassDelegate issubclass, TypeFlags flags = TypeFlags.None)
{
var dt = new DataType {
Name = name,
_defaulter = defaulter,
_issubclass = issubclass,
NativeType = nativetype,
Flags = flags,
};
if (flags.HasFlag(TypeFlags.HasHeading))
{
dt.Heading = DataHeading.Empty;
}
DataTypes.Dict[name] = dt;
if (valuetype != null)
{
DataTypes.TypeDict[valuetype] = dt;
}
return(dt);
}
