/// <summary>
/// Constructor
/// </summary>
/// <param name="address">The address of the symbol</param>
/// <param name="text">Symbol</param>
/// <param name="color">Color</param>
/// <param name="flags">Symbol flags</param>
public SymbolResult(ulong address, string text, FormatterOutputTextKind color, SymbolFlags flags)
{
Address = address;
Text = new TextInfo(text, color);
Flags = flags & ~SymbolFlags.HasSymbolSize;
SymbolSize = 0;
}
public X86Block(NativeCodeBlockKind kind, ulong address, string comment, string label, FormatterOutputTextKind labelKind, X86InstructionInfo[] instructions)
{
Kind = kind;
Address = address;
Comment = comment;
Label = label;
LabelKind = labelKind;
Instructions = instructions ?? throw new ArgumentNullException(nameof(instructions));
}
public AsmReference Create(FormatterOutputTextKind kind, string value)
{
var key = (kind, value);
if (!dict.TryGetValue(key, out var asmRef))
{
dict[key] = asmRef = new AsmReference(kind, value);
}
return(asmRef);
}
public static SymbolKind ToSymbolKind(FormatterOutputTextKind kind)
{
switch (kind)
{
case FormatterOutputTextKindExtensions.UnknownSymbol: return(SymbolKind.Unknown);
case FormatterOutputTextKindExtensions.Data: return(SymbolKind.Data);
case FormatterOutputTextKindExtensions.Label: return(SymbolKind.Label);
case FormatterOutputTextKindExtensions.Function: return(SymbolKind.Function);
default: return(SymbolKind.Unknown);
}
}
public override void Write(string text, FormatterOutputTextKind kind)
{
switch (kind)
{
case FormatterOutputTextKind.LabelAddress:
var address = ulong.Parse($"{text.Substring(0, text.Length - 1)}", System.Globalization.NumberStyles.HexNumber);
var ra = (address - BaseAddress).ToString("x4");
var label = $"{ra}h";
Writer.Write(label);
break;
default:
Writer.Write(text);
break;
}
}
public override void Write(string text, FormatterOutputTextKind kind)
{
var color = GetColor(kind);
switch (kind)
{
case FormatterOutputTextKind.Directive:
case FormatterOutputTextKind.Prefix:
case FormatterOutputTextKind.Mnemonic:
case FormatterOutputTextKind.Keyword:
case FormatterOutputTextKind.Register:
case FormatterOutputTextKindExtensions.UnknownSymbol:
case FormatterOutputTextKind.Data:
case FormatterOutputTextKind.Label:
case FormatterOutputTextKind.Function:
output.Write(text, refFactory.Create(kind, text), DisassemblyReferenceFlags.Local, color);
break;
default:
output.Write(text, color);
break;
}
}
public override void Write(string text, FormatterOutputTextKind kind) => writer !.Write(text);
public AsmReference(FormatterOutputTextKind kind, string value)
{
this.kind = kind;
this.value = value;
}
/// <summary> /// Writes text and text kind /// </summary> /// <param name="text">Text, can be an empty string</param> /// <param name="kind">Text kind. This value can be identical to the previous value passed to this method. It's /// the responsibility of the implementer to merge any such strings if needed.</param> public abstract void Write(string text, FormatterOutputTextKind kind);
/// <summary>
/// Constructor
/// </summary>
/// <param name="text">Text</param>
/// <param name="color">Color</param>
public TextPart(string text, FormatterOutputTextKind color)
{
Text = text;
Color = color;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="text">Text</param>
/// <param name="color">Color</param>
public TextInfo(string text, FormatterOutputTextKind color)
{
Text = new TextPart(text, color);
TextArray = null;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="address">The address of the symbol</param>
/// <param name="text">Symbol</param>
/// <param name="color">Color</param>
public SymbolResult(ulong address, string text, FormatterOutputTextKind color)
{
Address = address;
Text = new TextInfo(text, color);
Flags = 0;
}
/// <summary> /// Writes a number /// </summary> /// <param name="instruction">Instruction</param> /// <param name="operand">Operand number, 0-based. This is a formatter operand and isn't necessarily the same as an instruction operand.</param> /// <param name="instructionOperand">Instruction operand number, 0-based, or -1 if it's an operand created by the formatter.</param> /// <param name="text">Number text</param> /// <param name="value">Value</param> /// <param name="numberKind">Number kind</param> /// <param name="kind">Text kind</param> public virtual void WriteNumber(ref Instruction instruction, int operand, int instructionOperand, string text, ulong value, NumberKind numberKind, FormatterOutputTextKind kind) => Write(text, kind);
/// <summary> /// Writes text and text kind /// </summary> /// <param name="text">Text, can be an empty string</param> /// <param name="kind">Text kind. This value can be identical to the previous value passed to this method. It's /// the responsibility of the implementer to merge any such strings if needed.</param> public override void Write(string text, FormatterOutputTextKind kind) => sb.Append(text);
