/// <summary>
/// This method is called by the debug engine to populate the text representing the type of
/// a result.
/// </summary>
/// <param name="inspectionContext">Context of the evaluation. This contains options/flags
/// to be used during compilation. It also contains the InspectionSession. The inspection
/// session is the object that provides lifetime management for our objects. When the user
/// steps or continues the process, the debug engine will dispose of the inspection session</param>
/// <param name="clrType">This is the raw type we want to format</param>
/// <param name="customTypeInfo">If Expression Compiler passed any additional information
/// about the type that doesn't exist in metadata, this parameter contais that information.</param>
/// <param name="formatSpecifiers">A list of custom format specifiers that the debugger did
/// not understand. If you want special format specifiers for your language, handle them
/// here. The formatter should ignore any format specifiers it does not understand.</param>
/// <returns>The text of the type name to display</returns>
string IDkmClrFormatter.GetTypeName(
DkmInspectionContext inspectionContext,
DkmClrType clrType,
DkmClrCustomTypeInfo customTypeInfo,
ReadOnlyCollection <string> formatSpecifiers)
{
// Get the LMR type for the DkmClrType. LMR Types (Microsoft.VisualStudio.Debugger.Metadata.Type)
// are similar to System.Type, but represent types that live in the process being debugged.
Type lmrType = clrType.GetLmrType();
XSharpType xType = Utility.GetXSharpTypeForLmrType(lmrType);
if (xType == XSharpType.Invalid)
{
// We don't know about this type. Delegate to the C# Formatter to format the
// type name.
return(inspectionContext.GetTypeName(clrType, customTypeInfo, formatSpecifiers));
}
return(xType.ToString());
}
private static string TryGetFrameNameHelper(DkmInspectionContext inspectionContext, DkmStackWalkFrame frame, DkmVariableInfoFlags argumentFlags)
{
ImportedMethod currentMethod = TryGetCurrentMethod(inspectionContext, frame);
if (currentMethod == null)
{
return(null);
}
string name = currentMethod.Name;
if (argumentFlags == DkmVariableInfoFlags.None)
{
return(name);
}
var type = currentMethod.DeclaringType;
if (type.IsStatic && type.Name == "Functions")
{
; // No prefix for 'normal' functions
}
else
{
// static or instance method ?
if (currentMethod.IsStatic)
{
name = type.FullName + "." + name;
}
else
{
name = type.FullName + ":" + name;
}
}
Variable[] args = currentMethod.GetParameters();
if (args.Length == 0)
{
return(name + "()");
}
StringBuilder nameBuilder = new StringBuilder();
nameBuilder.Append(name);
nameBuilder.Append('(');
bool first = true;
bool showTypes = argumentFlags.HasFlag(DkmVariableInfoFlags.Types);
bool showNames = argumentFlags.HasFlag(DkmVariableInfoFlags.Names);
foreach (Variable arg in args)
{
if (first)
{
first = false;
}
else
{
nameBuilder.Append(", ");
}
XSharpType argType = arg.Type;
if (showNames)
{
nameBuilder.Append(arg.Name);
}
if (showNames && showTypes)
{
if (arg.In && arg.Out)
{
nameBuilder.Append(" REF ");
}
else if (arg.Out)
{
nameBuilder.Append(" OUT ");
}
else
{
nameBuilder.Append(" AS ");
}
}
if (showTypes)
{
nameBuilder.Append(argType.ToString());
}
}
nameBuilder.Append(')');
var result = nameBuilder.ToString();
if (result.Contains(clArgs))
{
result = result.Replace(clArgs, "[ClipperArguments]");
}
return(result);
}
