protected override void WriteCore(ITextColorWriter output, DocumentNodeWriteOptions options) {
output.Write(BoxedTextColor.Number, string.Format("{0:X2}", (byte)MetaDataTableVM.Table));
output.WriteSpace();
output.Write(BoxedTextColor.HexTableName, string.Format("{0}", MetaDataTableVM.Table));
output.WriteSpace();
output.Write(BoxedTextColor.Punctuation, "(");
output.Write(BoxedTextColor.Number, string.Format("{0}", MetaDataTableVM.Rows));
output.Write(BoxedTextColor.Punctuation, ")");
}
protected override void WriteCore(ITextColorWriter output, DocumentNodeWriteOptions options) {
output.Write(BoxedTextColor.Number, string.Format("{0}", index + 1));
if (infoTuple != null) {
output.WriteSpace();
output.Write(BoxedTextColor.Operator, "-");
output.WriteSpace();
infoTuple.Item2(output);
}
}
protected override void WriteCore(ITextColorWriter output, DocumentNodeWriteOptions options) {
output.Write(BoxedTextColor.HexPeSection, dnSpy_AsmEditor_Resources.HexNode_PE_Section);
output.WriteSpace();
output.Write(BoxedTextColor.Operator, "#");
output.Write(BoxedTextColor.Number, SectionNumber.ToString());
output.Write(BoxedTextColor.Punctuation, ":");
output.WriteSpace();
output.Write(BoxedTextColor.HexPeSectionName, string.Format("{0}", imageSectionHeaderVM.NameVM.String));
}
protected override void WriteCore(ITextColorWriter output, DocumentNodeWriteOptions options)
{
output.Write(BoxedTextColor.Number, string.Format("{0}", index + 1));
if (infoTuple != null)
{
output.WriteSpace();
output.Write(BoxedTextColor.Operator, "-");
output.WriteSpace();
infoTuple.Item2(output);
}
}
public void WriteName(BreakpointVM vm)
{
var ilbp = vm.Breakpoint as ILCodeBreakpoint;
if (ilbp != null)
{
vm.NameError = false;
bool printedToken = false;
if (vm.Context.ShowTokens)
{
WriteToken(output, ilbp.MethodToken.Token);
output.WriteSpace();
printedToken = true;
}
// If this is a method in a dynamic module and the module hasn't been loaded yet,
// this call will try to load it, and then open a dialog box showing the progress.
// But in rare cases we can't show the dialog box because of Dispatcher limitations,
// so if we must load the module, fail. Passing in false will prevent loading
// dynamic modules.
var method = vm.GetMethodDef(false);
if (method == null)
{
vm.NameError = true;
if (printedToken)
{
output.Write(BoxedTextColor.Error, "???");
}
else
{
output.Write(BoxedTextColor.Number, string.Format("0x{0:X8}", ilbp.MethodToken.Token));
}
}
else
{
MethodLanguage.Write(output, method, GetFlags(vm.Context));
}
output.WriteSpace();
output.Write(BoxedTextColor.Operator, "+");
output.WriteSpace();
WriteILOffset(output, ilbp.ILOffset);
return;
}
var debp = vm.Breakpoint as DebugEventBreakpoint;
if (debp != null)
{
//TODO:
return;
}
Debug.Fail(string.Format("Unknown breakpoint type: {0}", vm.Breakpoint.GetType()));
}
public override void WriteToolTip(ITextColorWriter output, DbgCodeBreakpointCondition condition)
{
if (output == null)
{
throw new ArgumentNullException(nameof(output));
}
var defaultColor = BoxedTextColor.Text;
output.Write(defaultColor, dnSpy_Debugger_Resources.Breakpoint_Condition_ConditionalExpression);
output.WriteSpace();
switch (condition.Kind)
{
case DbgCodeBreakpointConditionKind.IsTrue:
WriteArgumentAndText(output, defaultColor, BoxedTextColor.String, dnSpy_Debugger_Resources.Breakpoint_Condition_WhenConditionIsTrue2, condition.Condition);
break;
case DbgCodeBreakpointConditionKind.WhenChanged:
WriteArgumentAndText(output, defaultColor, BoxedTextColor.String, dnSpy_Debugger_Resources.Breakpoint_Condition_WhenConditionHasChanged2, condition.Condition);
break;
default:
Debug.Fail($"Unknown kind: {condition.Kind}");
break;
}
}
static void WriteText(ITextColorWriter output, string text)
{
output.WriteSpace();
output.Write(BoxedTextColor.Punctuation, "(");
output.Write(BoxedTextColor.Text, text);
output.Write(BoxedTextColor.Punctuation, ")");
}
public override void WriteLocation(ITextColorWriter output, BookmarkLocationFormatterOptions options)
{
bool printedToken = false;
if ((options & BookmarkLocationFormatterOptions.Tokens) != 0)
{
WriteToken(output, location.Token);
output.WriteSpace();
printedToken = true;
}
bool success = WriteLocationCore(output, options);
if (!success)
{
if (printedToken)
{
output.Write(BoxedTextColor.Error, "???");
}
else
{
WriteToken(output, location.Token);
}
}
}
static void WriteShort(this ITextColorWriter output, InstructionVM instr)
{
output.Write(BoxedTextColor.Number, instr.Index.ToString());
output.WriteSpace();
output.Write(BoxedTextColor.Punctuation, "(");
output.Write(BoxedTextColor.Label, instr.Offset.ToString("X4"));
output.Write(BoxedTextColor.Punctuation, ")");
}
static void WriteShort(this ITextColorWriter output, InstructionVM instr)
{
output.Write(BoxedTextColor.Number, instr.Index.ToString());
output.WriteSpace();
output.Write(BoxedTextColor.Punctuation, "(");
output.Write(BoxedTextColor.Number, string.Format("{0:X4}", instr.Offset));
output.Write(BoxedTextColor.Punctuation, ")");
}
/// <summary>
/// Writes a token
/// </summary>
/// <param name="output">Output</param>
/// <param name="tok">Token provider</param>
/// <param name="showToken">true to write tokens</param>
void WriteToken(ITextColorWriter output, IMDTokenProvider tok, bool showToken)
{
if (!showToken)
{
return;
}
output.WriteSpace();
output.Write(BoxedTextColor.Operator, "@");
output.Write(BoxedTextColor.Number, tok.MDToken.Raw.ToString("X8"));
}
/// <summary>
/// Writes a token
/// </summary>
/// <param name="output">Output</param>
/// <param name="tok">Token provider</param>
/// <param name="showToken">true to write tokens</param>
void WriteToken(ITextColorWriter output, IMDTokenProvider tok, bool showToken)
{
if (!showToken)
{
return;
}
output.WriteSpace();
output.Write(BoxedTextColor.Operator, "@");
output.Write(BoxedTextColor.Number, string.Format("{0:X8}", tok.MDToken.Raw));
}
protected override void Write(ITextColorWriter output, IDecompiler decompiler) {
if (hidesParent) {
output.Write(BoxedTextColor.Punctuation, "(");
output.Write(BoxedTextColor.Text, dnSpy_Analyzer_Resources.HidesParent);
output.Write(BoxedTextColor.Punctuation, ")");
output.WriteSpace();
}
decompiler.WriteType(output, analyzedProperty.DeclaringType, true);
output.Write(BoxedTextColor.Operator, ".");
new NodePrinter().Write(output, decompiler, analyzedProperty, Context.ShowToken, null);
}
void WriteGenericMethodArguments(ITextColorWriter output, DmdMethodBase method, Formatters.VisualBasic.VisualBasicTypeFormatter typeFormatter)
{
var genArgs = method.GetGenericArguments();
if (genArgs.Count == 0)
{
return;
}
output.Write(BoxedTextColor.Punctuation, GenericsParenOpen);
output.Write(BoxedTextColor.Keyword, Keyword_Of);
output.WriteSpace();
for (int i = 0; i < genArgs.Count; i++)
{
if (i > 0)
{
output.Write(BoxedTextColor.Punctuation, ",");
output.WriteSpace();
}
typeFormatter.Format(genArgs[i], null);
}
output.Write(BoxedTextColor.Punctuation, GenericsParenClose);
}
protected override void Write(ITextColorWriter output, IDecompiler decompiler)
{
if (hidesParent)
{
output.Write(BoxedTextColor.Punctuation, "(");
output.Write(BoxedTextColor.Text, dnSpy_Analyzer_Resources.HidesParent);
output.Write(BoxedTextColor.Punctuation, ")");
output.WriteSpace();
}
decompiler.WriteType(output, analyzedMethod.DeclaringType, true);
output.Write(BoxedTextColor.Operator, ".");
new NodeFormatter().Write(output, decompiler, analyzedMethod, Context.ShowToken);
}
protected override void Write(ITextColorWriter output, ILanguage language)
{
if (hidesParent)
{
output.Write(BoxedTextColor.Punctuation, "(");
output.Write(BoxedTextColor.Text, dnSpy_Analyzer_Resources.HidesParent);
output.Write(BoxedTextColor.Punctuation, ")");
output.WriteSpace();
}
language.WriteType(output, analyzedEvent.DeclaringType, true);
output.Write(BoxedTextColor.Operator, ".");
new NodePrinter().Write(output, language, analyzedEvent, Context.ShowToken);
}
static void Write(this ITextColorWriter output, IList <InstructionVM> instrs)
{
output.Write(BoxedTextColor.Punctuation, "[");
for (int i = 0; i < instrs.Count; i++)
{
if (i > 0)
{
output.Write(BoxedTextColor.Punctuation, ",");
output.WriteSpace();
}
output.WriteShort(instrs[i]);
}
output.Write(BoxedTextColor.Punctuation, "]");
}
public void WriteType(ITextColorWriter output, ValueNode vm)
{
vm.CachedExpectedType.WriteTo(output);
var cachedActualType = vm.CachedActualType_OrDefaultInstance;
// If it's default, expected type == actual type
if (!cachedActualType.IsDefault)
{
output.WriteSpace();
output.Write(BoxedTextColor.Error, "{");
cachedActualType.WriteTo(output);
output.Write(BoxedTextColor.Error, "}");
}
}
internal void WriteLabels(ITextColorWriter output, BookmarkVM vm)
{
bool needSep = false;
foreach (var label in vm.Bookmark.Labels ?? emptyLabels)
{
if (needSep)
{
output.Write(BoxedTextColor.Text, LabelsSeparatorString);
output.WriteSpace();
}
needSep = true;
output.Write(BoxedTextColor.Text, label);
}
}
void WriteNamespaceName(ITextColorWriter output, int nsIndex, int nameIndex)
{
var ns = ReadStringsHeap(nsIndex);
var name = ReadStringsHeap(nameIndex);
output.Write(BoxedTextColor.Type, name);
if (!string.IsNullOrEmpty(ns))
{
output.WriteSpace();
output.Write(BoxedTextColor.Operator, "-");
output.WriteSpace();
var parts = ns.Split('.');
for (int i = 0; i < parts.Length; i++)
{
output.Write(BoxedTextColor.Namespace, parts[i]);
if (i + 1 < parts.Length)
{
output.Write(BoxedTextColor.Operator, ".");
}
}
}
}
/// <summary>
/// Writes an assembly
/// </summary>
/// <param name="output">Output</param>
/// <param name="decompiler">Decompiler</param>
/// <param name="asm">Assembly</param>
/// <param name="showToken">true to write tokens</param>
/// <param name="showAssemblyVersion">true to write version</param>
/// <param name="showAssemblyPublicKeyToken">true to write public key token</param>
public void Write(ITextColorWriter output, IDecompiler decompiler, AssemblyDef asm, bool showToken, bool showAssemblyVersion, bool showAssemblyPublicKeyToken)
{
output.Write(IsExe(asm.ManifestModule) ? BoxedTextColor.AssemblyExe : BoxedTextColor.Assembly, asm.Name);
bool showAsmVer = showAssemblyVersion;
bool showPublicKeyToken = showAssemblyPublicKeyToken && !PublicKeyBase.IsNullOrEmpty2(asm.PublicKeyToken);
if (showAsmVer || showPublicKeyToken)
{
output.WriteSpace();
output.Write(BoxedTextColor.Punctuation, "(");
bool needComma = false;
if (showAsmVer)
{
if (needComma)
{
output.WriteCommaSpace();
}
needComma = true;
output.Write(asm.Version);
}
if (showPublicKeyToken)
{
if (needComma)
{
output.WriteCommaSpace();
}
needComma = true;
var pkt = asm.PublicKeyToken;
if (PublicKeyBase.IsNullOrEmpty2(pkt))
{
output.Write(BoxedTextColor.Keyword, "null");
}
else
{
output.Write(BoxedTextColor.Number, pkt.ToString());
}
}
output.Write(BoxedTextColor.Punctuation, ")");
}
WriteToken(output, asm, showToken);
}
public override void WriteName(ITextColorWriter writer, DbgExceptionDefinition definition, bool includeDescription)
{
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
if (definition.Id.Category == null)
{
throw new ArgumentException();
}
WriteNameCore(writer, definition);
if (includeDescription && definition.Description != null)
{
writer.WriteSpace();
WriteDescription(writer, definition);
}
}
public void WriteObjectId(ITextColorWriter output, ValueNode vm)
{
Debug.Assert(ObjectIdService != null);
if (ObjectIdService == null)
{
return;
}
var vmImpl = (ValueNodeImpl)vm;
if (vmImpl.RawNode is DebuggerValueRawNode rawNode)
{
var language = Language;
Debug.Assert(language != null);
if (language == null)
{
return;
}
var value = rawNode.DebuggerValueNode.Value;
if (value == null)
{
return;
}
var objectId = ObjectIdService.GetObjectId(value);
if (objectId != null)
{
output.WriteSpace();
output.Write(BoxedTextColor.Punctuation, "{");
var evalInfo = vmImpl.Context.EvaluationInfo;
Debug.Assert(evalInfo != null);
if (evalInfo == null)
{
output.Write(BoxedTextColor.Error, "???");
}
else
{
language.Formatter.FormatObjectIdName(evalInfo.Context, output, objectId.Id);
}
output.Write(BoxedTextColor.Punctuation, "}");
}
}
}
protected override void FormatReturnValueMethodName(DbgEvaluationInfo evalInfo, ITextColorWriter output, DbgValueFormatterTypeOptions typeOptions, DbgValueFormatterOptions valueOptions, CultureInfo cultureInfo, DmdMethodBase method, DmdPropertyInfo property)
{
var typeFormatter = new Formatters.VisualBasic.VisualBasicTypeFormatter(output, typeOptions.ToTypeFormatterOptions(), null);
typeFormatter.Format(method.DeclaringType, null);
var valueFormatter = new Formatters.VisualBasic.VisualBasicPrimitiveValueFormatter(output, valueOptions.ToValueFormatterOptions(), cultureInfo);
output.Write(BoxedTextColor.Operator, ".");
if ((object)property != null)
{
output.Write(MemberUtils.GetColor(property), Formatters.VisualBasic.VisualBasicTypeFormatter.GetFormattedIdentifier(property.Name));
valueFormatter.WriteTokenComment(property.MetadataToken);
output.Write(BoxedTextColor.Operator, ".");
output.Write(BoxedTextColor.Keyword, "Get");
valueFormatter.WriteTokenComment(method.MetadataToken);
}
else
{
var operatorInfo = Formatters.VisualBasic.Operators.TryGetOperatorInfo(method.Name);
if (operatorInfo != null && method is DmdMethodInfo methodInfo)
{
for (int i = 0; i < operatorInfo.Length; i++)
{
if (i > 0)
{
output.WriteSpace();
}
var s = operatorInfo[i];
output.Write('A' <= s[0] && s[0] <= 'Z' ? BoxedTextColor.Keyword : BoxedTextColor.Operator, s);
}
WriteGenericMethodArguments(output, method, typeFormatter);
}
else
{
output.Write(TypeFormatterUtils.GetColor(method, canBeModule: true), Formatters.VisualBasic.VisualBasicTypeFormatter.GetFormattedIdentifier(method.Name));
valueFormatter.WriteTokenComment(method.MetadataToken);
WriteGenericMethodArguments(output, method, typeFormatter);
}
}
}
/// <summary>
/// Writes an assembly
/// </summary>
/// <param name="output">Output</param>
/// <param name="decompiler">Decompiler</param>
/// <param name="asm">Assembly</param>
/// <param name="showToken">true to write tokens</param>
/// <param name="showAssemblyVersion">true to write version</param>
/// <param name="showAssemblyPublicKeyToken">true to write public key token</param>
public void Write(ITextColorWriter output, IDecompiler decompiler, AssemblyDef asm, bool showToken, bool showAssemblyVersion, bool showAssemblyPublicKeyToken) {
output.Write(IsExe(asm.ManifestModule) ? BoxedTextColor.AssemblyExe : BoxedTextColor.Assembly, asm.Name);
bool showAsmVer = showAssemblyVersion;
bool showPublicKeyToken = showAssemblyPublicKeyToken && !PublicKeyBase.IsNullOrEmpty2(asm.PublicKeyToken);
if (showAsmVer || showPublicKeyToken) {
output.WriteSpace();
output.Write(BoxedTextColor.Punctuation, "(");
bool needComma = false;
if (showAsmVer) {
if (needComma)
output.WriteCommaSpace();
needComma = true;
output.Write(asm.Version);
}
if (showPublicKeyToken) {
if (needComma)
output.WriteCommaSpace();
needComma = true;
var pkt = asm.PublicKeyToken;
if (PublicKeyBase.IsNullOrEmpty2(pkt))
output.Write(BoxedTextColor.Keyword, "null");
else
output.Write(BoxedTextColor.Number, pkt.ToString());
}
output.Write(BoxedTextColor.Punctuation, ")");
}
WriteToken(output, asm, showToken);
}
/// <summary>
/// Writes a field
/// </summary>
/// <param name="output">Output</param>
/// <param name="decompiler">Decompiler</param>
/// <param name="field">Field</param>
/// <param name="showToken">true to write tokens</param>
public void Write(ITextColorWriter output, IDecompiler decompiler, FieldDef field, bool showToken) {
output.Write(decompiler.MetadataTextColorProvider.GetColor(field), NameUtilities.CleanIdentifier(field.Name));
output.WriteSpace();
output.Write(BoxedTextColor.Punctuation, ":");
output.WriteSpace();
decompiler.WriteType(output, field.FieldType.ToTypeDefOrRef(), false);
WriteToken(output, field, showToken);
}
/// <summary>
/// Writes a method
/// </summary>
/// <param name="output">Output</param>
/// <param name="decompiler">Decompiler</param>
/// <param name="method">Method</param>
/// <param name="showToken">true to write tokens</param>
public void Write(ITextColorWriter output, IDecompiler decompiler, MethodDef method, bool showToken) {
output.Write(decompiler.MetadataTextColorProvider.GetColor(method), NameUtilities.CleanIdentifier(method.Name));
output.Write(BoxedTextColor.Punctuation, "(");
foreach (var p in method.Parameters) {
if (p.IsHiddenThisParameter)
continue;
if (p.MethodSigIndex > 0)
output.WriteCommaSpace();
decompiler.WriteType(output, p.Type.ToTypeDefOrRef(), false, p.ParamDef);
}
if (method.CallingConvention == CallingConvention.VarArg || method.CallingConvention == CallingConvention.NativeVarArg) {
if (method.MethodSig.GetParamCount() > 0)
output.WriteCommaSpace();
output.Write(BoxedTextColor.Operator, "...");
}
output.Write(BoxedTextColor.Punctuation, ")");
output.WriteSpace();
output.Write(BoxedTextColor.Punctuation, ":");
output.WriteSpace();
decompiler.WriteType(output, method.ReturnType.ToTypeDefOrRef(), false, method.Parameters.ReturnParameter.ParamDef);
WriteToken(output, method, showToken);
}
public override void WriteName(ITextColorWriter output, DbgBreakpointLocationFormatterOptions options)
{
bool printedToken = false;
if ((options & DbgBreakpointLocationFormatterOptions.Tokens) != 0)
{
WriteToken(output, location.Token);
output.WriteSpace();
printedToken = true;
}
var method = owner.GetDefinition <MethodDef>(location.Module, location.Token);
if (method == null)
{
if (printedToken)
{
output.Write(BoxedTextColor.Error, "???");
}
else
{
WriteToken(output, location.Token);
}
}
else
{
owner.MethodDecompiler.Write(output, method, GetFormatterOptions(options));
}
switch (location.ILOffsetMapping)
{
case DbgILOffsetMapping.Exact:
case DbgILOffsetMapping.Approximate:
output.WriteSpace();
output.Write(BoxedTextColor.Operator, "+");
output.WriteSpace();
if (location.ILOffsetMapping == DbgILOffsetMapping.Approximate)
{
output.Write(BoxedTextColor.Operator, "~");
}
WriteILOffset(output, location.Offset);
break;
case DbgILOffsetMapping.Prolog:
WriteText(output, "prolog");
break;
case DbgILOffsetMapping.Epilog:
WriteText(output, "epilog");
break;
case DbgILOffsetMapping.Unknown:
case DbgILOffsetMapping.NoInfo:
case DbgILOffsetMapping.UnmappedAddress:
WriteText(output, "???");
break;
default: throw new InvalidOperationException();
}
output.WriteSpace();
output.Write(BoxedTextColor.Punctuation, "(");
output.Write(BoxedTextColor.Number, GetHexPrefix() + location.NativeMethodAddress.ToString("X8"));
output.Write(BoxedTextColor.Operator, "+");
output.Write(BoxedTextColor.Number,
(options & DbgBreakpointLocationFormatterOptions.Decimal) != 0 ?
location.NativeMethodOffset.ToString() :
GetHexPrefix() + location.NativeMethodOffset.ToString("X"));
output.Write(BoxedTextColor.Punctuation, ")");
}
public static void WriteObject(ITextColorWriter output, object obj, WriteObjectFlags flags = WriteObjectFlags.None)
{
if (IsNull(obj))
{
output.Write(BoxedTextColor.Keyword, "null");
return;
}
var mr = obj as IMemberRef;
if (mr != null)
{
if (simpleILPrinter.Write(TextColorWriterToDecompilerOutput.Create(output), mr))
{
return;
}
}
var local = obj as LocalVM;
if (local != null)
{
output.Write(BoxedTextColor.Local, IdentifierEscaper.Escape(GetLocalName(local.Name, local.Index)));
output.WriteSpace();
output.WriteLocalParameterIndex(local.Index);
return;
}
var parameter = obj as Parameter;
if (parameter != null)
{
if (parameter.IsHiddenThisParameter)
{
output.Write(BoxedTextColor.Keyword, "this");
}
else
{
output.Write(BoxedTextColor.Parameter, IdentifierEscaper.Escape(GetParameterName(parameter.Name, parameter.Index)));
output.WriteSpace();
output.WriteLocalParameterIndex(parameter.Index);
}
return;
}
var instr = obj as InstructionVM;
if (instr != null)
{
if ((flags & WriteObjectFlags.ShortInstruction) != 0)
{
output.WriteShort(instr);
}
else
{
output.WriteLong(instr);
}
return;
}
var instrs = obj as IList <InstructionVM>;
if (instrs != null)
{
output.Write(instrs);
return;
}
var methodSig = obj as MethodSig;
if (methodSig != null)
{
simpleILPrinter.Write(TextColorWriterToDecompilerOutput.Create(output), methodSig);
return;
}
if (obj is TypeSig)
{
simpleILPrinter.Write(TextColorWriterToDecompilerOutput.Create(output), obj as TypeSig);
return;
}
if (obj is Code)
{
output.Write(BoxedTextColor.OpCode, ((Code)obj).ToOpCode().Name);
return;
}
// This code gets called by the combobox and it sometimes passes in the empty string.
// It's never shown in the UI.
Debug.Assert(string.Empty.Equals(obj), "Shouldn't be here");
output.Write(BoxedTextColor.Text, obj.ToString());
}
protected override void WriteCore(ITextColorWriter output, DocumentNodeWriteOptions options) {
output.Write(BoxedTextColor.HexStorageStream, dnSpy_AsmEditor_Resources.HexNode_StorageStream);
output.WriteSpace();
output.Write(BoxedTextColor.Operator, "#");
output.Write(BoxedTextColor.Number, StreamNumber.ToString());
output.Write(BoxedTextColor.Punctuation, ":");
output.WriteSpace();
output.Write(StorageStreamType == StorageStreamType.None ? BoxedTextColor.HexStorageStreamNameInvalid : BoxedTextColor.HexStorageStreamName, string.Format("{0}", storageStreamVM.RCNameVM.StringZ));
}
/// <summary>
/// Writes an event
/// </summary>
/// <param name="output">Output</param>
/// <param name="decompiler">Decompiler</param>
/// <param name="event">Event</param>
/// <param name="showToken">true to write tokens</param>
public void Write(ITextColorWriter output, IDecompiler decompiler, EventDef @event, bool showToken) {
output.Write(decompiler.MetadataTextColorProvider.GetColor(@event), NameUtilities.CleanIdentifier(@event.Name));
output.WriteSpace();
output.Write(BoxedTextColor.Punctuation, ":");
output.WriteSpace();
decompiler.WriteType(output, @event.EventType, false);
WriteToken(output, @event, showToken);
}
void WriteNamespaceName(ITextColorWriter output, int nsIndex, int nameIndex) {
var ns = ReadStringsHeap(nsIndex);
var name = ReadStringsHeap(nameIndex);
output.Write(BoxedTextColor.Type, name);
if (!string.IsNullOrEmpty(ns)) {
output.WriteSpace();
output.Write(BoxedTextColor.Operator, "-");
output.WriteSpace();
var parts = ns.Split('.');
for (int i = 0; i < parts.Length; i++) {
output.Write(BoxedTextColor.Namespace, parts[i]);
if (i + 1 < parts.Length)
output.Write(BoxedTextColor.Operator, ".");
}
}
}
/// <summary>
/// Writes a property
/// </summary>
/// <param name="output">Output</param>
/// <param name="decompiler">Decompiler</param>
/// <param name="property">Property</param>
/// <param name="showToken">true to write tokens</param>
/// <param name="isIndexer">true if it's an indexer</param>
public void Write(ITextColorWriter output, IDecompiler decompiler, PropertyDef property, bool showToken, bool? isIndexer) {
decompiler.WriteName(output, property, isIndexer);
output.WriteSpace();
output.Write(BoxedTextColor.Punctuation, ":");
output.WriteSpace();
decompiler.WriteType(output, property.PropertySig.GetRetType().ToTypeDefOrRef(), false);
WriteToken(output, property, showToken);
}
/// <summary>
/// Writes a token
/// </summary>
/// <param name="output">Output</param>
/// <param name="tok">Token provider</param>
/// <param name="showToken">true to write tokens</param>
void WriteToken(ITextColorWriter output, IMDTokenProvider tok, bool showToken) {
if (!showToken)
return;
output.WriteSpace();
output.Write(BoxedTextColor.Operator, "@");
output.Write(BoxedTextColor.Number, string.Format("{0:X8}", tok.MDToken.Raw));
}
void WriteQuotedString(ITextColorWriter output, string text, string s)
{
output.Write(BoxedTextColor.Text, text);
output.WriteSpace();
output.Write(BoxedTextColor.String, SimpleTypeConverter.ToString(s, true));
}
void CreateUI(ITextColorWriter output, object?o, bool includeNamespace)
{
if (o is NamespaceSearchResult ns)
{
output.WriteNamespace(ns.Namespace);
return;
}
if (o is TypeDef td)
{
Debug2.Assert(!(Context.Decompiler is null));
Context.Decompiler.WriteType(output, td, includeNamespace);
return;
}
if (o is MethodDef md)
{
var methodNameColor = Context.Decompiler.MetadataTextColorProvider.GetColor(md);
output.Write(methodNameColor, IdentifierEscaper.Escape(md.Name));
if (md.ImplMap is ImplMap implMap && !UTF8String.IsNullOrEmpty(implMap.Name) && implMap.Name != md.Name)
{
output.WriteSpace();
output.Write(BoxedTextColor.Punctuation, "(");
output.Write(methodNameColor, IdentifierEscaper.Escape(implMap.Name));
output.Write(BoxedTextColor.Punctuation, ")");
}
return;
}
if (o is FieldDef fd)
{
output.Write(Context.Decompiler.MetadataTextColorProvider.GetColor(fd), IdentifierEscaper.Escape(fd.Name));
return;
}
if (o is PropertyDef pd)
{
output.Write(Context.Decompiler.MetadataTextColorProvider.GetColor(pd), IdentifierEscaper.Escape(pd.Name));
return;
}
if (o is EventDef ed)
{
output.Write(Context.Decompiler.MetadataTextColorProvider.GetColor(ed), IdentifierEscaper.Escape(ed.Name));
return;
}
if (o is AssemblyDef asm)
{
output.Write(asm);
return;
}
if (o is ModuleDef mod)
{
output.WriteModule(mod.FullName);
return;
}
if (o is AssemblyRef asmRef)
{
output.Write(asmRef);
return;
}
if (o is ModuleRef modRef)
{
output.WriteModule(modRef.FullName);
return;
}
if (o is ParamDef paramDef)
{
output.Write(BoxedTextColor.Parameter, IdentifierEscaper.Escape(paramDef.Name));
return;
}
// non-.NET file
if (o is IDsDocument document)
{
output.Write(BoxedTextColor.Text, document.GetShortName());
return;
}
if (o is ResourceNode resNode)
{
output.WriteFilename(resNode.Name);
return;
}
if (o is ResourceElementNode resElNode)
{
output.WriteFilename(resElNode.Name);
return;
}
if (o is ErrorMessage em)
{
output.Write(em.Color, em.Text);
return;
}
Debug2.Assert(o is null);
}
public override void WriteName(ITextColorWriter output, DbgBreakpointLocationFormatterOptions options)
{
bool printedToken = false;
if ((options & DbgBreakpointLocationFormatterOptions.Tokens) != 0)
{
WriteToken(output, location.Token);
output.WriteSpace();
printedToken = true;
}
var method = weakMethod?.Target as MethodDef ?? owner.GetDefinition <MethodDef>(location.Module, location.Token);
if (method == null)
{
if (printedToken)
{
output.Write(BoxedTextColor.Error, "???");
}
else
{
WriteToken(output, location.Token);
}
}
else
{
if (weakMethod?.Target != method)
{
weakMethod = new WeakReference(method);
}
owner.MethodDecompiler.Write(output, method, GetFormatterOptions(options));
}
switch (location.ILOffsetMapping)
{
case DbgILOffsetMapping.Exact:
case DbgILOffsetMapping.Approximate:
output.WriteSpace();
output.Write(BoxedTextColor.Operator, "+");
output.WriteSpace();
if (location.ILOffsetMapping == DbgILOffsetMapping.Approximate)
{
output.Write(BoxedTextColor.Operator, "~");
}
WriteILOffset(output, location.Offset);
break;
case DbgILOffsetMapping.Prolog:
WriteText(output, "prolog");
break;
case DbgILOffsetMapping.Epilog:
WriteText(output, "epilog");
break;
case DbgILOffsetMapping.Unknown:
case DbgILOffsetMapping.NoInfo:
case DbgILOffsetMapping.UnmappedAddress:
WriteText(output, "???");
break;
default:
Debug.Fail($"Unknown IL offset mapping: {location.ILOffsetMapping}");
goto case DbgILOffsetMapping.Unknown;
}
}
