public override void WriteTo(ITextOutput output, MemberMapping memberMapping)
{
var startLoc = output.Location;
output.Write("fixed", TextTokenKind.Keyword);
output.WriteSpace();
output.Write("(", TextTokenKind.Operator);
for (int i = 0; i < this.Initializers.Count; i++)
{
if (i > 0)
{
output.Write(",", TextTokenKind.Operator);
output.WriteSpace();
}
this.Initializers[i].WriteTo(output, null);
}
output.Write(")", TextTokenKind.Operator);
var ilRanges = new List <ILRange>(ILRanges);
foreach (var i in Initializers)
{
ilRanges.AddRange(i.GetSelfAndChildrenRecursiveILRanges());
}
UpdateMemberMapping(memberMapping, startLoc, output.Location, ilRanges);
output.WriteSpace();
this.BodyBlock.WriteTo(output, memberMapping);
}
public static void WriteTo(this MethodSig sig, ITextOutput writer)
{
if (sig.ExplicitThis)
{
writer.Write("instance", TextTokenType.Keyword);
writer.WriteSpace();
writer.Write("explicit", TextTokenType.Keyword);
writer.WriteSpace();
}
else if (sig.HasThis)
{
writer.Write("instance", TextTokenType.Keyword);
writer.WriteSpace();
}
sig.RetType.WriteTo(writer, ILNameSyntax.SignatureNoNamedTypeParameters);
writer.WriteSpace();
writer.Write('(', TextTokenType.Operator);
var parameters = sig.GetParameters();
for (int i = 0; i < parameters.Count; ++i)
{
if (i > 0)
{
writer.Write(',', TextTokenType.Operator);
writer.WriteSpace();
}
parameters[i].WriteTo(writer, ILNameSyntax.SignatureNoNamedTypeParameters);
}
writer.Write(")", TextTokenType.Operator);
}
public override void WriteTo(ITextOutput output, MemberMapping memberMapping)
{
output.Write(".try", TextTokenKind.Keyword);
output.WriteSpace();
TryBlock.WriteTo(output, memberMapping, ILRanges);
foreach (CatchBlock block in CatchBlocks)
{
block.WriteTo(output, memberMapping);
}
if (FaultBlock != null)
{
output.Write("fault", TextTokenKind.Keyword);
output.WriteSpace();
FaultBlock.WriteTo(output, memberMapping);
}
if (FinallyBlock != null)
{
output.Write("finally", TextTokenKind.Keyword);
output.WriteSpace();
FinallyBlock.WriteTo(output, memberMapping);
}
if (FilterBlock != null)
{
output.Write("filter", TextTokenKind.Keyword);
output.WriteSpace();
FilterBlock.WriteTo(output, memberMapping);
}
}
public override void WriteTo(ITextOutput output, MemberMapping memberMapping)
{
var startLoc = output.Location;
if (IsFilter)
{
output.Write("filter", TextTokenKind.Keyword);
output.WriteSpace();
output.WriteReference(ExceptionVariable.Name, ExceptionVariable, TextTokenKind.Local);
}
else if (ExceptionType != null)
{
output.Write("catch", TextTokenKind.Keyword);
output.WriteSpace();
output.WriteReference(ExceptionType.FullName, ExceptionType, TextTokenKindUtils.GetTextTokenType(ExceptionType));
if (ExceptionVariable != null)
{
output.WriteSpace();
output.WriteReference(ExceptionVariable.Name, ExceptionVariable, TextTokenKind.Local);
}
}
else
{
output.Write("handler", TextTokenKind.Keyword);
output.WriteSpace();
output.WriteReference(ExceptionVariable.Name, ExceptionVariable, TextTokenKind.Local);
}
UpdateMemberMapping(memberMapping, startLoc, output.Location, StlocILRanges);
output.WriteSpace();
base.WriteTo(output, memberMapping);
}
public static ITextOutput Write(ITextOutput output, MethodDef method, Language language)
{
output.Write(CleanUpIdentifier(method.Name), TextTokenHelper.GetTextTokenType(method));
output.Write('(', TextTokenType.Operator);
for (int i = 0; i < method.Parameters.Count; i++)
{
if (method.Parameters[i].IsHiddenThisParameter)
{
continue;
}
if (method.Parameters[i].MethodSigIndex > 0)
{
output.Write(',', TextTokenType.Operator);
output.WriteSpace();
}
language.TypeToString(output, method.Parameters[i].Type.ToTypeDefOrRef(), false, method.Parameters[i].ParamDef);
}
if (method.CallingConvention == CallingConvention.VarArg || method.CallingConvention == CallingConvention.NativeVarArg)
{
if (method.MethodSig.GetParamCount() > 0)
{
output.Write(',', TextTokenType.Operator);
output.WriteSpace();
}
output.Write("...", TextTokenType.Operator);
}
output.Write(')', TextTokenType.Operator);
output.WriteSpace();
output.Write(':', TextTokenType.Operator);
output.WriteSpace();
language.TypeToString(output, method.ReturnType.ToTypeDefOrRef(), false, method.Parameters.ReturnParameter.ParamDef);
method.MDToken.WriteSuffixString(output);
return(output);
}
public static ITextOutput Write(ITextOutput output, MethodDef method, Language language) {
output.Write(UIUtils.CleanUpIdentifier(method.Name), TextTokenHelper.GetTextTokenType(method));
output.Write('(', TextTokenType.Operator);
for (int i = 0; i < method.Parameters.Count; i++) {
if (method.Parameters[i].IsHiddenThisParameter)
continue;
if (method.Parameters[i].MethodSigIndex > 0) {
output.Write(',', TextTokenType.Operator);
output.WriteSpace();
}
language.TypeToString(output, method.Parameters[i].Type.ToTypeDefOrRef(), false, method.Parameters[i].ParamDef);
}
if (method.CallingConvention == CallingConvention.VarArg || method.CallingConvention == CallingConvention.NativeVarArg) {
if (method.MethodSig.GetParamCount() > 0) {
output.Write(',', TextTokenType.Operator);
output.WriteSpace();
}
output.Write("...", TextTokenType.Operator);
}
output.Write(')', TextTokenType.Operator);
output.WriteSpace();
output.Write(':', TextTokenType.Operator);
output.WriteSpace();
language.TypeToString(output, method.ReturnType.ToTypeDefOrRef(), false, method.Parameters.ReturnParameter.ParamDef);
method.MDToken.WriteSuffixString(output);
return output;
}
public static void WriteTo(this Instruction instruction, ITextOutput writer, Func <OpCode, string> getOpCodeDocumentation)
{
writer.WriteDefinition(DnlibExtensions.OffsetToString(instruction.GetOffset()), instruction, TextTokenType.Label, false);
writer.Write(':', TextTokenType.Operator);
writer.WriteSpace();
writer.WriteReference(instruction.OpCode.Name, instruction.OpCode, TextTokenType.OpCode);
if (instruction.Operand != null)
{
writer.WriteSpace();
if (instruction.OpCode == OpCodes.Ldtoken)
{
var member = instruction.Operand as IMemberRef;
if (member != null && member.IsMethod)
{
writer.Write("method", TextTokenType.Keyword);
writer.WriteSpace();
}
else if (member != null && member.IsField)
{
writer.Write("field", TextTokenType.Keyword);
writer.WriteSpace();
}
}
WriteOperand(writer, instruction.Operand);
}
if (getOpCodeDocumentation != null)
{
var doc = getOpCodeDocumentation(instruction.OpCode);
if (doc != null)
{
writer.Write("\t", TextTokenType.Text);
writer.Write("// " + doc, TextTokenType.Comment);
}
}
}
public override void DecompileMethod(MethodDef method, ITextOutput output, DecompilationOptions options)
{
WriteComment(output, "Method: ");
output.WriteDefinition(IdentifierEscaper.Escape(method.FullName), method, TextTokenType.Comment, false);
output.WriteLine();
if (!method.HasBody) {
return;
}
StartKeywordBlock(output, ".body", method);
ILAstBuilder astBuilder = new ILAstBuilder();
ILBlock ilMethod = new ILBlock();
DecompilerContext context = new DecompilerContext(method.Module) { CurrentType = method.DeclaringType, CurrentMethod = method };
ilMethod.Body = astBuilder.Build(method, inlineVariables, context);
if (abortBeforeStep != null) {
new ILAstOptimizer().Optimize(context, ilMethod, abortBeforeStep.Value);
}
if (context.CurrentMethodIsAsync) {
output.Write("async", TextTokenType.Keyword);
output.Write('/', TextTokenType.Operator);
output.WriteLine("await", TextTokenType.Keyword);
}
var allVariables = ilMethod.GetSelfAndChildrenRecursive<ILExpression>().Select(e => e.Operand as ILVariable)
.Where(v => v != null && !v.IsParameter).Distinct();
foreach (ILVariable v in allVariables) {
output.WriteDefinition(IdentifierEscaper.Escape(v.Name), v, v.IsParameter ? TextTokenType.Parameter : TextTokenType.Local);
if (v.Type != null) {
output.WriteSpace();
output.Write(':', TextTokenType.Operator);
output.WriteSpace();
if (v.IsPinned) {
output.Write("pinned", TextTokenType.Keyword);
output.WriteSpace();
}
v.Type.WriteTo(output, ILNameSyntax.ShortTypeName);
}
if (v.IsGenerated) {
output.WriteSpace();
output.Write('[', TextTokenType.Operator);
output.Write("generated", TextTokenType.Keyword);
output.Write(']', TextTokenType.Operator);
}
output.WriteLine();
}
var memberMapping = new MemberMapping(method);
foreach (ILNode node in ilMethod.Body) {
node.WriteTo(output, memberMapping);
if (!node.WritesNewLine)
output.WriteLine();
}
output.AddDebugSymbols(memberMapping);
EndKeywordBlock(output);
}
static void WriteLong(this ITextOutput output, InstructionVM instr)
{
output.WriteShort(instr);
output.WriteSpace();
output.Write(instr.Code.ToOpCode().Name, TextTokenType.OpCode);
output.WriteSpace();
Write(output, instr.InstructionOperandVM);
}
public virtual void WriteToolTip(ITextOutput output, IVariable variable, string name)
{
output.Write(variable is Local ? "(local variable)" : "(parameter)", TextTokenType.Text);
output.WriteSpace();
WriteToolTip(output, variable.Type.ToTypeDefOrRef(), variable is Parameter ? ((Parameter)variable).ParamDef : null);
output.WriteSpace();
output.Write(IdentifierEscaper.Escape(GetName(variable, name)), variable is Local ? TextTokenType.Local : TextTokenType.Parameter);
}
public static ITextOutput Write(ITextOutput output, PropertyDef property, Language language, bool? isIndexer = null) {
language.FormatPropertyName(output, property, isIndexer);
output.WriteSpace();
output.Write(':', TextTokenType.Operator);
output.WriteSpace();
language.TypeToString(output, property.PropertySig.GetRetType().ToTypeDefOrRef(), false, property);
property.MDToken.WriteSuffixString(output);
return output;
}
protected override void Write(ITextOutput output) {
output.Write(string.Format("{0}", index + 1), TextTokenType.Number);
if (infoTuple != null) {
output.WriteSpace();
output.Write('-', TextTokenType.Operator);
output.WriteSpace();
infoTuple.Item2(output);
}
}
public static ITextOutput Write(ITextOutput output, EventDef ev, Language language) {
output.Write(UIUtils.CleanUpIdentifier(ev.Name), TextTokenHelper.GetTextTokenType(ev));
output.WriteSpace();
output.Write(':', TextTokenType.Operator);
output.WriteSpace();
language.TypeToString(output, ev.EventType, false, ev);
ev.MDToken.WriteSuffixString(output);
return output;
}
public static ITextOutput Write(ITextOutput output, FieldDef field, Language language) {
output.Write(UIUtils.CleanUpIdentifier(field.Name), TextTokenHelper.GetTextTokenType(field));
output.WriteSpace();
output.Write(':', TextTokenType.Operator);
output.WriteSpace();
language.TypeToString(output, field.FieldType.ToTypeDefOrRef(), false, field);
field.MDToken.WriteSuffixString(output);
return output;
}
protected override void Write(ITextOutput output) {
output.Write(string.Format("{0:X2}", (byte)tablesStreamVM.Table), TextTokenType.Number);
output.WriteSpace();
output.Write(string.Format("{0}", tablesStreamVM.Table), TextTokenType.Type);
output.WriteSpace();
output.Write('(', TextTokenType.Operator);
output.Write(string.Format("{0}", tablesStreamVM.Rows), TextTokenType.Number);
output.Write(')', TextTokenType.Operator);
}
protected override void Write(ITextOutput output) {
output.Write("Section", TextTokenType.Keyword);
output.WriteSpace();
output.Write('#', TextTokenType.Operator);
output.Write(sectionNumber.ToString(), TextTokenType.Number);
output.Write(':', TextTokenType.Operator);
output.WriteSpace();
output.Write(string.Format("{0}", imageSectionHeaderVM.NameVM.String), TextTokenType.Type);
}
void StartKeywordBlock(ITextOutput output, string keyword, IMemberDef member)
{
output.Write(keyword, TextTokenKind.Keyword);
output.WriteSpace();
output.WriteDefinition(IdentifierEscaper.Escape(member.Name), member, TextTokenKindUtils.GetTextTokenType(member), false);
output.WriteSpace();
output.WriteLeftBrace();
output.WriteLine();
output.Indent();
}
public static ITextOutput Write(ITextOutput output, EventDef ev, Language language)
{
output.Write(UIUtils.CleanUpIdentifier(ev.Name), TextTokenHelper.GetTextTokenType(ev));
output.WriteSpace();
output.Write(':', TextTokenType.Operator);
output.WriteSpace();
language.TypeToString(output, ev.EventType, false, ev);
ev.MDToken.WriteSuffixString(output);
return(output);
}
protected override void Write(ITextOutput output)
{
output.Write(string.Format("{0:X2}", (byte)tablesStreamVM.Table), TextTokenType.Number);
output.WriteSpace();
output.Write(string.Format("{0}", tablesStreamVM.Table), TextTokenType.Type);
output.WriteSpace();
output.Write('(', TextTokenType.Operator);
output.Write(string.Format("{0}", tablesStreamVM.Rows), TextTokenType.Number);
output.Write(')', TextTokenType.Operator);
}
protected override void Write(ITextOutput output)
{
output.Write("Section", TextTokenType.Keyword);
output.WriteSpace();
output.Write('#', TextTokenType.Operator);
output.Write(sectionNumber.ToString(), TextTokenType.Number);
output.Write(':', TextTokenType.Operator);
output.WriteSpace();
output.Write(string.Format("{0}", imageSectionHeaderVM.NameVM.String), TextTokenType.Type);
}
public static ITextOutput Write(ITextOutput output, FieldDef field, Language language)
{
output.Write(UIUtils.CleanUpIdentifier(field.Name), TextTokenHelper.GetTextTokenType(field));
output.WriteSpace();
output.Write(':', TextTokenType.Operator);
output.WriteSpace();
language.TypeToString(output, field.FieldType.ToTypeDefOrRef(), false, field);
field.MDToken.WriteSuffixString(output);
return(output);
}
protected override void Write(ITextOutput output)
{
output.Write(string.Format("{0}", index + 1), TextTokenType.Number);
if (infoTuple != null)
{
output.WriteSpace();
output.Write('-', TextTokenType.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 (BreakpointSettings.Instance.ShowTokens)
{
WriteToken(output, ilbp.SerializedDnSpyToken.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("???", TextTokenType.Error);
}
else
{
output.Write(string.Format("0x{0:X8}", ilbp.SerializedDnSpyToken.Token), TextTokenType.Number);
}
}
else
{
MethodLanguage.WriteToolTip(output, method, null);
}
output.WriteSpace();
output.Write('+', TextTokenType.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()));
}
protected override void Write(ITextOutput output)
{
output.Write("Storage", TextTokenType.InstanceField);
output.WriteSpace();
output.Write("Stream", TextTokenType.InstanceField);
output.WriteSpace();
output.Write('#', TextTokenType.Operator);
output.Write(streamNumber.ToString(), TextTokenType.Number);
output.Write(':', TextTokenType.Operator);
output.WriteSpace();
output.Write(string.Format("{0}", storageStreamVM.RCNameVM.StringZ), storageStreamType == StorageStreamType.None ? TextTokenType.Error : TextTokenType.Type);
}
public static void WriteTo(this Instruction instruction, ITextOutput writer, Func<OpCode, string> getOpCodeDocumentation)
{
writer.WriteDefinition(DnlibExtensions.OffsetToString(instruction.GetOffset()), instruction, TextTokenType.Label, false);
writer.Write(':', TextTokenType.Operator);
writer.WriteSpace();
writer.WriteReference(instruction.OpCode.Name, instruction.OpCode, TextTokenType.OpCode);
if (instruction.Operand != null) {
writer.WriteSpace();
if (instruction.OpCode == OpCodes.Ldtoken) {
var member = instruction.Operand as IMemberRef;
if (member != null && member.IsMethod) {
writer.Write("method", TextTokenType.Keyword);
writer.WriteSpace();
}
else if (member != null && member.IsField) {
writer.Write("field", TextTokenType.Keyword);
writer.WriteSpace();
}
}
WriteOperand(writer, instruction.Operand);
}
if (getOpCodeDocumentation != null) {
var doc = getOpCodeDocumentation(instruction.OpCode);
if (doc != null) {
writer.Write("\t", TextTokenType.Text);
writer.Write("// " + doc, TextTokenType.Comment);
}
}
}
static void WriteShort(this ITextOutput output, InstructionVM instr)
{
output.Write(instr.Index.ToString(), TextTokenType.Number);
output.WriteSpace();
output.Write('(', TextTokenType.Operator);
output.Write(string.Format("{0:X4}", instr.Offset), TextTokenType.Number);
output.Write(')', TextTokenType.Operator);
}
public static void WriteTo(this ExceptionHandler exceptionHandler, ITextOutput writer, MethodDef method)
{
writer.Write("Try", TextTokenType.Keyword);
writer.WriteSpace();
WriteOffsetReference(writer, exceptionHandler.TryStart, method);
writer.Write('-', TextTokenType.Operator);
WriteOffsetReference(writer, exceptionHandler.TryEnd, method);
writer.WriteSpace();
writer.Write(exceptionHandler.HandlerType.ToString(), TextTokenType.Keyword);
if (exceptionHandler.FilterStart != null)
{
writer.WriteSpace();
WriteOffsetReference(writer, exceptionHandler.FilterStart, method);
writer.WriteSpace();
writer.Write("handler", TextTokenType.Keyword);
writer.WriteSpace();
}
if (exceptionHandler.CatchType != null)
{
writer.WriteSpace();
exceptionHandler.CatchType.WriteTo(writer);
}
writer.WriteSpace();
WriteOffsetReference(writer, exceptionHandler.HandlerStart, method);
writer.Write('-', TextTokenType.Operator);
WriteOffsetReference(writer, exceptionHandler.HandlerEnd, method);
}
public static void WriteTo(this ExceptionHandler exceptionHandler, ITextOutput writer, MethodDef method)
{
writer.Write("Try", TextTokenType.Keyword);
writer.WriteSpace();
WriteOffsetReference(writer, exceptionHandler.TryStart, method);
writer.Write('-', TextTokenType.Operator);
WriteOffsetReference(writer, exceptionHandler.TryEnd, method);
writer.WriteSpace();
writer.Write(exceptionHandler.HandlerType.ToString(), TextTokenType.Keyword);
if (exceptionHandler.FilterStart != null) {
writer.WriteSpace();
WriteOffsetReference(writer, exceptionHandler.FilterStart, method);
writer.WriteSpace();
writer.Write("handler", TextTokenType.Keyword);
writer.WriteSpace();
}
if (exceptionHandler.CatchType != null) {
writer.WriteSpace();
exceptionHandler.CatchType.WriteTo(writer);
}
writer.WriteSpace();
WriteOffsetReference(writer, exceptionHandler.HandlerStart, method);
writer.Write('-', TextTokenType.Operator);
WriteOffsetReference(writer, exceptionHandler.HandlerEnd, method);
}
bool WriteRefIfByRef(ITextOutput output, TypeSig typeSig, ParamDef pd)
{
if (typeSig.RemovePinnedAndModifiers() is ByRefSig)
{
if (pd != null && (!pd.IsIn && pd.IsOut))
{
output.Write("out", TextTokenKind.Keyword);
output.WriteSpace();
}
else
{
output.Write("ref", TextTokenKind.Keyword);
output.WriteSpace();
}
return(true);
}
return(false);
}
public static void WriteSuffixString(this MDToken token, ITextOutput output)
{
if (!DisplaySettingsPanel.CurrentDisplaySettings.ShowMetadataTokens)
{
return;
}
output.WriteSpace();
output.Write('@', TextTokenType.Operator);
output.Write(string.Format("{0:X8}", token.ToUInt32()), TextTokenType.Number);
}
protected override void Write(ITextOutput output, Language language) {
if (hidesParent) {
output.Write('(', TextTokenType.Operator);
output.Write("hides", TextTokenType.Text);
output.Write(')', TextTokenType.Operator);
output.WriteSpace();
}
Language.TypeToString(output, analyzedEvent.DeclaringType, true);
output.Write('.', TextTokenType.Operator);
EventTreeNode.Write(output, analyzedEvent, Language);
}
public static void WriteFieldTo(this IField field, ITextOutput writer)
{
if (field == null || field.FieldSig == null)
{
return;
}
field.FieldSig.Type.WriteTo(writer, ILNameSyntax.SignatureNoNamedTypeParameters);
writer.WriteSpace();
field.DeclaringType.WriteTo(writer, ILNameSyntax.TypeName);
writer.Write("::", TextTokenType.Operator);
writer.WriteReference(Escape(field.Name), field, TextTokenHelper.GetTextTokenType(field));
}
public override void WriteTo(ITextOutput output, MemberMapping memberMapping)
{
var startLoc = output.Location;
output.Write("switch", TextTokenKind.Keyword);
output.WriteSpace();
output.Write("(", TextTokenKind.Operator);
Condition.WriteTo(output, null);
output.Write(")", TextTokenKind.Operator);
var ilRanges = new List <ILRange>(ILRanges);
ilRanges.AddRange(Condition.GetSelfAndChildrenRecursiveILRanges());
UpdateMemberMapping(memberMapping, startLoc, output.Location, ilRanges);
output.WriteSpace();
WriteHiddenStart(output, memberMapping);
foreach (CaseBlock caseBlock in this.CaseBlocks)
{
caseBlock.WriteTo(output, memberMapping);
}
WriteHiddenEnd(output, memberMapping);
}
/// <summary>
/// Converts a member signature to a string.
/// This is used for displaying the tooltip on a member reference.
/// </summary>
public virtual void WriteToolTip(ITextOutput output, IMemberRef member, IHasCustomAttribute typeAttributes)
{
if (member is ITypeDefOrRef)
{
TypeToString(output, (ITypeDefOrRef)member, true, typeAttributes);
}
else if (member is GenericParam)
{
var gp = (GenericParam)member;
output.Write(IdentifierEscaper.Escape(gp.Name), TextTokenHelper.GetTextTokenType(gp));
output.WriteSpace();
output.Write("in", TextTokenType.Text);
output.WriteSpace();
WriteToolTip(output, gp.Owner, typeAttributes);
}
else
{
//TODO: This should be escaped but since it contains whitespace, parens, etc,
// we can't pass it to IdentifierEscaper.Escape().
output.Write(member.ToString(), TextTokenHelper.GetTextTokenType(member));
}
}
public override void WriteTo(ITextOutput output, MemberMapping memberMapping)
{
var startLoc = output.Location;
output.Write("if", TextTokenKind.Keyword);
output.WriteSpace();
output.Write("(", TextTokenKind.Operator);
Condition.WriteTo(output, null);
output.Write(")", TextTokenKind.Operator);
var ilRanges = new List <ILRange>(ILRanges);
ilRanges.AddRange(Condition.GetSelfAndChildrenRecursiveILRanges());
UpdateMemberMapping(memberMapping, startLoc, output.Location, ilRanges);
output.WriteSpace();
TrueBlock.WriteTo(output, memberMapping);
if (FalseBlock != null)
{
output.Write("else", TextTokenKind.Keyword);
output.WriteSpace();
FalseBlock.WriteTo(output, memberMapping);
}
}
public override void WriteTo(ITextOutput output, MemberMapping memberMapping)
{
var startLoc = output.Location;
output.Write("loop", TextTokenKind.Keyword);
output.WriteSpace();
output.Write("(", TextTokenKind.Operator);
if (this.Condition != null)
{
this.Condition.WriteTo(output, null);
}
output.Write(")", TextTokenKind.Operator);
var ilRanges = new List <ILRange>(ILRanges);
if (this.Condition != null)
{
ilRanges.AddRange(this.Condition.GetSelfAndChildrenRecursiveILRanges());
}
UpdateMemberMapping(memberMapping, startLoc, output.Location, ilRanges);
output.WriteSpace();
this.BodyBlock.WriteTo(output, memberMapping);
}
protected override void Write(ITextOutput output, Language language)
{
if (hidesParent)
{
output.Write('(', TextTokenType.Operator);
output.Write("hides", TextTokenType.Text);
output.Write(')', TextTokenType.Operator);
output.WriteSpace();
}
Language.TypeToString(output, analyzedEvent.DeclaringType, true);
output.Write('.', TextTokenType.Operator);
EventTreeNode.Write(output, analyzedEvent, Language);
}
public void WriteName(BreakpointVM vm)
{
var ilbp = vm.Breakpoint as ILCodeBreakpoint;
if (ilbp != null)
{
var module = GetModule(ilbp) as ModuleDefMD;
if (BreakpointSettings.Instance.ShowTokens)
{
WriteToken(output, ilbp.MethodKey.Token);
output.WriteSpace();
}
var method = module == null ? null : module.ResolveToken(ilbp.MethodKey.Token) as IMemberRef;
if (method == null)
{
output.Write(string.Format("0x{0:X8}", ilbp.MethodKey.Token), TextTokenType.Number);
}
else
{
MethodLanguage.WriteToolTip(output, method, null);
}
output.WriteSpace();
output.Write('+', TextTokenType.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()));
}
static void Write(this ITextOutput output, IList <InstructionVM> instrs)
{
output.Write('[', TextTokenType.Operator);
for (int i = 0; i < instrs.Count; i++)
{
if (i > 0)
{
output.Write(',', TextTokenType.Operator);
output.WriteSpace();
}
output.WriteShort(instrs[i]);
}
output.Write(']', TextTokenType.Operator);
}
static void WriteLabelList(ITextOutput writer, IList <Instruction> instructions, MethodDef method)
{
writer.Write("(", TextTokenType.Operator);
for (int i = 0; i < instructions.Count; i++)
{
if (i != 0)
{
writer.Write(',', TextTokenType.Operator);
writer.WriteSpace();
}
WriteOffsetReference(writer, instructions[i], method);
}
writer.Write(")", TextTokenType.Operator);
}
static void WriteLabelList(ITextOutput writer, IList<Instruction> instructions, MethodDef method)
{
writer.Write("(", TextTokenType.Operator);
for(int i = 0; i < instructions.Count; i++) {
if (i != 0) {
writer.Write(',', TextTokenType.Operator);
writer.WriteSpace();
}
WriteOffsetReference(writer, instructions[i], method);
}
writer.Write(")", TextTokenType.Operator);
}
internal static void WriteKeyword(ITextOutput writer, string name, ITypeDefOrRef tdr)
{
var parts = name.Split(' ');
for (int i = 0; i < parts.Length; i++) {
if (i > 0)
writer.WriteSpace();
if (tdr != null)
writer.WriteReference(parts[i], tdr, TextTokenType.Keyword);
else
writer.Write(parts[i], TextTokenType.Keyword);
}
}
public static void WriteTo(this ITypeDefOrRef type, ITextOutput writer, ILNameSyntax syntax, int depth)
{
if (depth++ > MAX_CONVERTTYPE_DEPTH || type == null)
return;
var ts = type as TypeSpec;
if (ts != null && !(ts.TypeSig is FnPtrSig)) {
WriteTo(((TypeSpec)type).TypeSig, writer, syntax, depth);
return;
}
string typeFullName = type.FullName;
string typeName = type.Name.String;
if (ts != null) {
var fnPtrSig = ts.TypeSig as FnPtrSig;
typeFullName = DnlibExtensions.GetFnPtrFullName(fnPtrSig);
typeName = DnlibExtensions.GetFnPtrName(fnPtrSig);
}
TypeSig typeSig = null;
string name = type.DefinitionAssembly.IsCorLib() ? PrimitiveTypeName(typeFullName, type.Module, out typeSig) : null;
if (syntax == ILNameSyntax.ShortTypeName) {
if (name != null)
WriteKeyword(writer, name, typeSig.ToTypeDefOrRef());
else
writer.WriteReference(Escape(typeName), type, TextTokenHelper.GetTextTokenType(type));
} else if ((syntax == ILNameSyntax.Signature || syntax == ILNameSyntax.SignatureNoNamedTypeParameters) && name != null) {
WriteKeyword(writer, name, typeSig.ToTypeDefOrRef());
} else {
if (syntax == ILNameSyntax.Signature || syntax == ILNameSyntax.SignatureNoNamedTypeParameters) {
writer.Write(DnlibExtensions.IsValueType(type) ? "valuetype" : "class", TextTokenType.Keyword);
writer.WriteSpace();
}
if (type.DeclaringType != null) {
type.DeclaringType.WriteTo(writer, ILNameSyntax.TypeName, depth);
writer.Write('/', TextTokenType.Operator);
writer.WriteReference(Escape(typeName), type, TextTokenHelper.GetTextTokenType(type));
} else {
if (!(type is TypeDef) && type.Scope != null && !(type is TypeSpec)) {
writer.Write('[', TextTokenType.Operator);
writer.Write(Escape(type.Scope.GetScopeName()), TextTokenType.ILModule);
writer.Write(']', TextTokenType.Operator);
}
if (ts != null || MustEscape(typeFullName))
writer.WriteReference(Escape(typeFullName), type, TextTokenHelper.GetTextTokenType(type));
else {
WriteNamespace(writer, type.Namespace);
if (!string.IsNullOrEmpty(type.Namespace))
writer.Write('.', TextTokenType.Operator);
writer.WriteReference(IdentifierEscaper.Escape(type.Name), type, TextTokenHelper.GetTextTokenType(type));
}
}
}
}
public static void WriteTo(this TypeSig type, ITextOutput writer, ILNameSyntax syntax, int depth)
{
if (depth++ > MAX_CONVERTTYPE_DEPTH)
return;
ILNameSyntax syntaxForElementTypes = syntax == ILNameSyntax.SignatureNoNamedTypeParameters ? syntax : ILNameSyntax.Signature;
if (type is PinnedSig) {
((PinnedSig)type).Next.WriteTo(writer, syntaxForElementTypes, depth);
writer.WriteSpace();
writer.Write("pinned", TextTokenType.Keyword);
} else if (type is ArraySig) {
ArraySig at = (ArraySig)type;
at.Next.WriteTo(writer, syntaxForElementTypes, depth);
writer.Write('[', TextTokenType.Operator);
for (int i = 0; i < at.Rank; i++)
{
if (i != 0) {
writer.Write(',', TextTokenType.Operator);
writer.WriteSpace();
}
int? lower = i < at.LowerBounds.Count ? at.LowerBounds[i] : (int?)null;
uint? size = i < at.Sizes.Count ? at.Sizes[i] : (uint?)null;
if (lower != null)
{
writer.Write(lower.ToString(), TextTokenType.Number);
if (size != null) {
writer.Write("..", TextTokenType.Operator);
writer.Write((lower.Value + (int)size.Value - 1).ToString(), TextTokenType.Number);
}
else
writer.Write("...", TextTokenType.Operator);
}
}
writer.Write(']', TextTokenType.Operator);
} else if (type is SZArraySig) {
SZArraySig at = (SZArraySig)type;
at.Next.WriteTo(writer, syntaxForElementTypes, depth);
writer.Write("[]", TextTokenType.Operator);
} else if (type is GenericSig) {
if (((GenericSig)type).IsMethodVar)
writer.Write("!!", TextTokenType.Operator);
else
writer.Write("!", TextTokenType.Operator);
string typeName = type.TypeName;
if (string.IsNullOrEmpty(typeName) || typeName[0] == '!' || syntax == ILNameSyntax.SignatureNoNamedTypeParameters)
writer.Write(((GenericSig)type).Number.ToString(), TextTokenType.Number);
else
writer.Write(Escape(typeName), TextTokenHelper.GetTextTokenType(type));
} else if (type is ByRefSig) {
((ByRefSig)type).Next.WriteTo(writer, syntaxForElementTypes, depth);
writer.Write('&', TextTokenType.Operator);
} else if (type is PtrSig) {
((PtrSig)type).Next.WriteTo(writer, syntaxForElementTypes, depth);
writer.Write('*', TextTokenType.Operator);
} else if (type is GenericInstSig) {
((GenericInstSig)type).GenericType.WriteTo(writer, syntaxForElementTypes, depth);
writer.Write('<', TextTokenType.Operator);
var arguments = ((GenericInstSig)type).GenericArguments;
for (int i = 0; i < arguments.Count; i++) {
if (i > 0) {
writer.Write(',', TextTokenType.Operator);
writer.WriteSpace();
}
arguments[i].WriteTo(writer, syntaxForElementTypes, depth);
}
writer.Write('>', TextTokenType.Operator);
} else if (type is CModOptSig) {
((ModifierSig)type).Next.WriteTo(writer, syntax, depth);
writer.WriteSpace();
writer.Write("modopt", TextTokenType.Keyword);
writer.Write('(', TextTokenType.Operator);
((ModifierSig)type).Modifier.WriteTo(writer, ILNameSyntax.TypeName, depth);
writer.Write(')', TextTokenType.Operator);
writer.WriteSpace();
}
else if (type is CModReqdSig) {
((ModifierSig)type).Next.WriteTo(writer, syntax, depth);
writer.WriteSpace();
writer.Write("modreq", TextTokenType.Keyword);
writer.Write('(', TextTokenType.Operator);
((ModifierSig)type).Modifier.WriteTo(writer, ILNameSyntax.TypeName, depth);
writer.Write(')', TextTokenType.Operator);
writer.WriteSpace();
}
else if (type is TypeDefOrRefSig) {
WriteTo(((TypeDefOrRefSig)type).TypeDefOrRef, writer, syntax, depth);
} else if (type is FnPtrSig) {
WriteTo(type.ToTypeDefOrRef(), writer, syntax, depth);
}
//TODO: SentinelSig
}
public static void WriteTo(this MethodSig sig, ITextOutput writer)
{
if (sig.ExplicitThis) {
writer.Write("instance", TextTokenType.Keyword);
writer.WriteSpace();
writer.Write("explicit", TextTokenType.Keyword);
writer.WriteSpace();
}
else if (sig.HasThis) {
writer.Write("instance", TextTokenType.Keyword);
writer.WriteSpace();
}
sig.RetType.WriteTo(writer, ILNameSyntax.SignatureNoNamedTypeParameters);
writer.WriteSpace();
writer.Write('(', TextTokenType.Operator);
var parameters = sig.GetParameters();
for(int i = 0; i < parameters.Count; ++i) {
if (i > 0) {
writer.Write(',', TextTokenType.Operator);
writer.WriteSpace();
}
parameters[i].WriteTo(writer, ILNameSyntax.SignatureNoNamedTypeParameters);
}
writer.Write(")", TextTokenType.Operator);
}
/// <summary>
/// Converts a member signature to a string.
/// This is used for displaying the tooltip on a member reference.
/// </summary>
public virtual void WriteToolTip(ITextOutput output, IMemberRef member, IHasCustomAttribute typeAttributes)
{
if (member is ITypeDefOrRef)
TypeToString(output, (ITypeDefOrRef)member, true, typeAttributes);
else if (member is GenericParam) {
var gp = (GenericParam)member;
output.Write(IdentifierEscaper.Escape(gp.Name), TextTokenHelper.GetTextTokenType(gp));
output.WriteSpace();
output.Write("in", TextTokenType.Text);
output.WriteSpace();
WriteToolTip(output, gp.Owner, typeAttributes);
}
else {
//TODO: This should be escaped but since it contains whitespace, parens, etc,
// we can't pass it to IdentifierEscaper.Escape().
output.Write(member.ToString(), TextTokenHelper.GetTextTokenType(member));
}
}
public override void DecompileField(FieldDef field, ITextOutput output, DecompilationOptions options)
{
output.WriteReference(IdentifierEscaper.Escape(field.FieldType.GetFullName()), field.FieldType.ToTypeDefOrRef(), TextTokenHelper.GetTextTokenType(field.FieldType));
output.WriteSpace();
output.WriteDefinition(IdentifierEscaper.Escape(field.Name), field, TextTokenHelper.GetTextTokenType(field), false);
var c = field.Constant;
if (c != null) {
output.WriteSpace();
output.Write('=', TextTokenType.Operator);
output.WriteSpace();
if (c.Value == null)
output.Write("null", TextTokenType.Keyword);
else {
switch (c.Type) {
case ElementType.Boolean:
if (c.Value is bool)
output.Write((bool)c.Value ? "true" : "false", TextTokenType.Keyword);
else
goto default;
break;
case ElementType.Char:
output.Write(string.Format("'{0}'", c.Value), TextTokenType.Char);
break;
case ElementType.I1:
case ElementType.U1:
case ElementType.I2:
case ElementType.U2:
case ElementType.I4:
case ElementType.U4:
case ElementType.I8:
case ElementType.U8:
case ElementType.R4:
case ElementType.R8:
case ElementType.I:
case ElementType.U:
output.Write(string.Format("{0}", c.Value), TextTokenType.Number);
break;
case ElementType.String:
output.Write(string.Format("{0}", c.Value), TextTokenType.String);
break;
default:
output.Write(string.Format("{0}", c.Value), TextTokenType.Text);
break;
}
}
}
}
public static void WriteFieldTo(this IField field, ITextOutput writer)
{
if (field == null || field.FieldSig == null)
return;
field.FieldSig.Type.WriteTo(writer, ILNameSyntax.SignatureNoNamedTypeParameters);
writer.WriteSpace();
field.DeclaringType.WriteTo(writer, ILNameSyntax.TypeName);
writer.Write("::", TextTokenType.Operator);
writer.WriteReference(Escape(field.Name), field, TextTokenHelper.GetTextTokenType(field));
}
static void Write(ITextOutput output, IAssembly asm)
{
var asmDef = asm as AssemblyDef;
bool isExe = asmDef != null &&
asmDef.ManifestModule != null &&
(asmDef.ManifestModule.Characteristics & dnlib.PE.Characteristics.Dll) == 0;
output.Write(asm.Name, isExe ? TextTokenType.AssemblyExe : TextTokenType.Assembly);
output.Write(',', TextTokenType.Operator);
output.WriteSpace();
output.Write("Version", TextTokenType.InstanceProperty);
output.Write('=', TextTokenType.Operator);
output.Write(asm.Version.Major.ToString(), TextTokenType.Number);
output.Write('.', TextTokenType.Operator);
output.Write(asm.Version.Minor.ToString(), TextTokenType.Number);
output.Write('.', TextTokenType.Operator);
output.Write(asm.Version.Build.ToString(), TextTokenType.Number);
output.Write('.', TextTokenType.Operator);
output.Write(asm.Version.Revision.ToString(), TextTokenType.Number);
output.Write(',', TextTokenType.Operator);
output.WriteSpace();
output.Write("Culture", TextTokenType.InstanceProperty);
output.Write('=', TextTokenType.Operator);
output.Write(UTF8String.IsNullOrEmpty(asm.Culture) ? "neutral" : asm.Culture.String, TextTokenType.EnumField);
output.Write(',', TextTokenType.Operator);
output.WriteSpace();
var publicKey = PublicKeyBase.ToPublicKeyToken(asm.PublicKeyOrToken);
output.Write(publicKey == null || publicKey is PublicKeyToken ? "PublicKeyToken" : "PublicKey", TextTokenType.InstanceProperty);
output.Write('=', TextTokenType.Operator);
if (PublicKeyBase.IsNullOrEmpty2(publicKey))
output.Write("null", TextTokenType.Keyword);
else
output.Write(publicKey.ToString(), TextTokenType.Number);
if ((asm.Attributes & AssemblyAttributes.Retargetable) != 0) {
output.Write(',', TextTokenType.Operator);
output.WriteSpace();
output.Write("Retargetable", TextTokenType.InstanceProperty);
output.Write('=', TextTokenType.Operator);
output.Write("Yes", TextTokenType.EnumField);
}
if ((asm.Attributes & AssemblyAttributes.ContentType_Mask) == AssemblyAttributes.ContentType_WindowsRuntime) {
output.Write(',', TextTokenType.Operator);
output.WriteSpace();
output.Write("ContentType", TextTokenType.InstanceProperty);
output.Write('=', TextTokenType.Operator);
output.Write("WindowsRuntime", TextTokenType.EnumField);
}
}
void WriteMethodName(ITextOutput output, IMethod method, string name)
{
string[] list;
if (nameToOperatorName.TryGetValue(name, out list)) {
for (int i = 0; i < list.Length; i++) {
if (i > 0)
output.WriteSpace();
var s = list[i];
output.Write(s, 'a' <= s[0] && s[0] <= 'z' ? TextTokenType.Keyword : TextTokenType.Operator);
}
}
else
output.Write(IdentifierEscaper.Escape(name), TextTokenHelper.GetTextTokenType(method));
}
protected override void Write(ITextOutput output, Language language)
{
if (!assembly.IsLoaded)
output.Write(UIUtils.CleanUpName(assembly.ShortName), TextTokenType.Assembly);
else if (assembly.ModuleDefinition == null)
output.Write(UIUtils.CleanUpName(assembly.ShortName), TextTokenType.Text);
else if (Parent is AssemblyTreeNode || assembly.AssemblyDefinition == null)
output.Write(UIUtils.CleanUpName(assembly.ModuleDefinition.Name), TextTokenType.Module);
else {
var asm = assembly.AssemblyDefinition;
bool isExe = (assembly.ModuleDefinition.Characteristics & dnlib.PE.Characteristics.Dll) == 0;
output.Write(asm.Name, isExe ? TextTokenType.AssemblyExe : TextTokenType.Assembly);
bool showAsmVer = DisplaySettingsPanel.CurrentDisplaySettings.ShowAssemblyVersion;
bool showPublicKeyToken = DisplaySettingsPanel.CurrentDisplaySettings.ShowAssemblyPublicKeyToken && !PublicKeyBase.IsNullOrEmpty2(asm.PublicKeyToken);
if (showAsmVer || showPublicKeyToken) {
output.WriteSpace();
output.Write('(', TextTokenType.Operator);
bool needComma = false;
if (showAsmVer) {
if (needComma) {
output.Write(',', TextTokenType.Operator);
output.WriteSpace();
}
needComma = true;
output.Write(asm.Version.Major.ToString(), TextTokenType.Number);
output.Write('.', TextTokenType.Operator);
output.Write(asm.Version.Minor.ToString(), TextTokenType.Number);
output.Write('.', TextTokenType.Operator);
output.Write(asm.Version.Build.ToString(), TextTokenType.Number);
output.Write('.', TextTokenType.Operator);
output.Write(asm.Version.Revision.ToString(), TextTokenType.Number);
}
if (showPublicKeyToken) {
if (needComma) {
output.Write(',', TextTokenType.Operator);
output.WriteSpace();
}
needComma = true;
var pkt = asm.PublicKeyToken;
if (PublicKeyBase.IsNullOrEmpty2(pkt))
output.Write("null", TextTokenType.Keyword);
else
output.Write(pkt.ToString(), TextTokenType.Number);
}
output.Write(')', TextTokenType.Operator);
}
}
}
bool WriteRefIfByRef(ITextOutput output, TypeSig typeSig, ParamDef pd)
{
if (typeSig.RemovePinnedAndModifiers() is ByRefSig) {
if (pd != null && (!pd.IsIn && pd.IsOut)) {
output.Write("out", TextTokenType.Keyword);
output.WriteSpace();
}
else {
output.Write("ref", TextTokenType.Keyword);
output.WriteSpace();
}
return true;
}
return false;
}
void WriteToolTip(ITextOutput output, IField field)
{
var sig = field.FieldSig;
var gpContext = GenericParamContext.Create(field.DeclaringType.ResolveTypeDef());
bool isEnumOwner = gpContext.Type != null && gpContext.Type.IsEnum;
var fd = field.ResolveFieldDef();
if (!isEnumOwner) {
if (fd != null && fd.IsLiteral)
output.Write("(constant)", TextTokenType.Text);
else
output.Write("(field)", TextTokenType.Text);
output.WriteSpace();
WriteToolTip(output, sig.Type, gpContext, null);
output.WriteSpace();
}
WriteToolTip(output, field.DeclaringType);
output.Write('.', TextTokenType.Operator);
output.Write(IdentifierEscaper.Escape(field.Name), TextTokenHelper.GetTextTokenType(field));
if (fd.IsLiteral && fd.Constant != null) {
output.WriteSpace();
output.Write('=', TextTokenType.Operator);
output.WriteSpace();
WriteToolTipConstant(output, fd.Constant.Value);
}
}
public virtual void WriteToolTip(ITextOutput output, IVariable variable, string name)
{
output.Write(variable is Local ? "(local variable)" : "(parameter)", TextTokenType.Text);
output.WriteSpace();
WriteToolTip(output, variable.Type.ToTypeDefOrRef(), variable is Parameter ? ((Parameter)variable).ParamDef : null);
output.WriteSpace();
output.Write(IdentifierEscaper.Escape(GetName(variable, name)), variable is Local ? TextTokenType.Local : TextTokenType.Parameter);
}
void WriteNamespaceName(ITextOutput output, int nsIndex, int nameIndex) {
var ns = ReadStringsHeap(nsIndex);
var name = ReadStringsHeap(nameIndex);
output.Write(name, TextTokenType.Type);
if (!string.IsNullOrEmpty(ns)) {
output.WriteSpace();
output.Write('-', TextTokenType.Operator);
output.WriteSpace();
var parts = ns.Split('.');
for (int i = 0; i < parts.Length; i++) {
output.Write(parts[i], TextTokenType.NamespacePart);
if (i + 1 < parts.Length)
output.Write('.', TextTokenType.Operator);
}
}
}
void StartKeywordBlock(ITextOutput output, string keyword, IMemberDef member)
{
output.Write(keyword, TextTokenType.Keyword);
output.WriteSpace();
output.WriteDefinition(IdentifierEscaper.Escape(member.Name), member, TextTokenHelper.GetTextTokenType(member), false);
output.WriteSpace();
output.WriteLeftBrace();
output.WriteLine();
output.Indent();
}
public static void WriteOperand(ITextOutput writer, object operand, MethodDef method = null)
{
Instruction targetInstruction = operand as Instruction;
if (targetInstruction != null) {
WriteOffsetReference(writer, targetInstruction, method);
return;
}
IList<Instruction> targetInstructions = operand as IList<Instruction>;
if (targetInstructions != null) {
WriteLabelList(writer, targetInstructions, method);
return;
}
Local variable = operand as Local;
if (variable != null) {
if (string.IsNullOrEmpty(variable.Name))
writer.WriteReference(variable.Index.ToString(), variable, TextTokenType.Number);
else
writer.WriteReference(Escape(variable.Name), variable, TextTokenType.Local);
return;
}
Parameter paramRef = operand as Parameter;
if (paramRef != null) {
if (string.IsNullOrEmpty(paramRef.Name)) {
if (paramRef.IsHiddenThisParameter)
writer.WriteReference("<hidden-this>", paramRef, TextTokenType.Parameter);
else
writer.WriteReference(paramRef.MethodSigIndex.ToString(), paramRef, TextTokenType.Parameter);
}
else
writer.WriteReference(Escape(paramRef.Name), paramRef, TextTokenType.Parameter);
return;
}
MemberRef memberRef = operand as MemberRef;
if (memberRef != null) {
if (memberRef.IsMethodRef)
memberRef.WriteMethodTo(writer);
else
memberRef.WriteFieldTo(writer);
return;
}
MethodDef methodDef = operand as MethodDef;
if (methodDef != null) {
methodDef.WriteMethodTo(writer);
return;
}
FieldDef fieldDef = operand as FieldDef;
if (fieldDef != null) {
fieldDef.WriteFieldTo(writer);
return;
}
ITypeDefOrRef typeRef = operand as ITypeDefOrRef;
if (typeRef != null) {
typeRef.WriteTo(writer, ILNameSyntax.TypeName);
return;
}
IMethod m = operand as IMethod;
if (m != null) {
m.WriteMethodTo(writer);
return;
}
MethodSig sig = operand as MethodSig;
if (sig != null) {
sig.WriteTo(writer);
return;
}
string s = operand as string;
if (s != null) {
writer.Write("\"" + NRefactory.CSharp.TextWriterTokenWriter.ConvertString(s) + "\"", TextTokenType.String);
} else if (operand is char) {
writer.Write(((int)(char)operand).ToString(), TextTokenType.Number);
} else if (operand is float) {
float val = (float)operand;
if (val == 0) {
if (1 / val == float.NegativeInfinity) {
// negative zero is a special case
writer.Write("-0.0", TextTokenType.Number);
}
else
writer.Write("0.0", TextTokenType.Number);
} else if (float.IsInfinity(val) || float.IsNaN(val)) {
byte[] data = BitConverter.GetBytes(val);
writer.Write('(', TextTokenType.Operator);
for (int i = 0; i < data.Length; i++) {
if (i > 0)
writer.WriteSpace();
writer.Write(data[i].ToString("X2"), TextTokenType.Number);
}
writer.Write(')', TextTokenType.Operator);
} else {
writer.Write(val.ToString("R", System.Globalization.CultureInfo.InvariantCulture), TextTokenType.Number);
}
} else if (operand is double) {
double val = (double)operand;
if (val == 0) {
if (1 / val == double.NegativeInfinity) {
// negative zero is a special case
writer.Write("-0.0", TextTokenType.Number);
}
else
writer.Write("0.0", TextTokenType.Number);
} else if (double.IsInfinity(val) || double.IsNaN(val)) {
byte[] data = BitConverter.GetBytes(val);
writer.Write('(', TextTokenType.Operator);
for (int i = 0; i < data.Length; i++) {
if (i > 0)
writer.WriteSpace();
writer.Write(data[i].ToString("X2"), TextTokenType.Number);
}
writer.Write(')', TextTokenType.Operator);
} else {
writer.Write(val.ToString("R", System.Globalization.CultureInfo.InvariantCulture), TextTokenType.Number);
}
} else if (operand is bool) {
writer.Write((bool)operand ? "true" : "false", TextTokenType.Keyword);
} else {
s = ToInvariantCultureString(operand);
writer.Write(s, TextTokenHelper.GetTextTokenType(operand));
}
}
public static void WriteTo(this Instruction instruction, ITextOutput writer, DisassemblerOptions options, uint baseRva, long baseOffs, IInstructionBytesReader byteReader, MethodDef method)
{
if (options != null && (options.ShowTokenAndRvaComments || options.ShowILBytes)) {
writer.Write("/* ", TextTokenType.Comment);
bool needSpace = false;
if (options.ShowTokenAndRvaComments) {
ulong fileOffset = (ulong)baseOffs + instruction.Offset;
writer.WriteReference(string.Format("0x{0:X8}", fileOffset), new AddressReference(options.OwnerModule == null ? null : options.OwnerModule.Location, false, fileOffset, (ulong)instruction.GetSize()), TextTokenType.Comment, false);
needSpace = true;
}
if (options.ShowILBytes) {
if (needSpace)
writer.Write(' ', TextTokenType.Comment);
if (byteReader == null)
writer.Write("??", TextTokenType.Comment);
else {
int size = instruction.GetSize();
for (int i = 0; i < size; i++) {
var b = byteReader.ReadByte();
if (b < 0)
writer.Write("??", TextTokenType.Comment);
else
writer.Write(string.Format("{0:X2}", b), TextTokenType.Comment);
}
// Most instructions should be at most 5 bytes in length, but use 6 since
// ldftn/ldvirtftn are 6 bytes long. The longest instructions are those with
// 8 byte operands, ldc.i8 and ldc.r8: 9 bytes.
const int MIN_BYTES = 6;
for (int i = size; i < MIN_BYTES; i++)
writer.Write(" ", TextTokenType.Comment);
}
}
writer.Write(" */", TextTokenType.Comment);
writer.WriteSpace();
}
writer.WriteDefinition(DnlibExtensions.OffsetToString(instruction.GetOffset()), new InstructionReference(method, instruction), TextTokenType.Label, false);
writer.Write(':', TextTokenType.Operator);
writer.WriteSpace();
writer.WriteReference(instruction.OpCode.Name, instruction.OpCode, TextTokenType.OpCode);
if (instruction.Operand != null) {
int count = OPERAND_ALIGNMENT - instruction.OpCode.Name.Length;
if (count <= 0)
count = 1;
writer.Write(spaces[count], TextTokenType.Text);
if (instruction.OpCode == OpCodes.Ldtoken) {
var member = instruction.Operand as IMemberRef;
if (member != null && member.IsMethod) {
writer.Write("method", TextTokenType.Keyword);
writer.WriteSpace();
}
else if (member != null && member.IsField) {
writer.Write("field", TextTokenType.Keyword);
writer.WriteSpace();
}
}
WriteOperand(writer, instruction.Operand, method);
}
if (options != null && options.GetOpCodeDocumentation != null) {
var doc = options.GetOpCodeDocumentation(instruction.OpCode);
if (doc != null) {
writer.Write("\t", TextTokenType.Text);
writer.Write("// " + doc, TextTokenType.Comment);
}
}
}
void WriteToolTip(ITextOutput output, PropertyDef prop)
{
var sig = prop.PropertySig;
var md = prop.GetMethods.FirstOrDefault() ??
prop.SetMethods.FirstOrDefault() ??
prop.OtherMethods.FirstOrDefault();
var writer = new MethodWriter(this, output, md);
writer.WriteReturnType();
WriteToolTip(output, prop.DeclaringType);
output.Write('.', TextTokenType.Operator);
var ovrMeth = md == null || md.Overrides.Count == 0 ? null : md.Overrides[0].MethodDeclaration;
if (prop.IsIndexer()) {
if (ovrMeth != null) {
WriteToolTipType(output, ovrMeth.DeclaringType, false);
output.Write('.', TextTokenType.Operator);
}
output.Write("this", TextTokenType.Keyword);
writer.WriteGenericArguments();
writer.WriteMethodParameterList('[', ']');
}
else if (ovrMeth != null && GetPropName(ovrMeth) != null) {
WriteToolTipType(output, ovrMeth.DeclaringType, false);
output.Write('.', TextTokenType.Operator);
output.Write(IdentifierEscaper.Escape(GetPropName(ovrMeth)), TextTokenHelper.GetTextTokenType(prop));
}
else
output.Write(IdentifierEscaper.Escape(prop.Name), TextTokenHelper.GetTextTokenType(prop));
output.WriteSpace();
output.WriteLeftBrace();
if (prop.GetMethods.Count > 0) {
output.WriteSpace();
output.Write("get", TextTokenType.Keyword);
output.Write(';', TextTokenType.Operator);
}
if (prop.SetMethods.Count > 0) {
output.WriteSpace();
output.Write("set", TextTokenType.Keyword);
output.Write(';', TextTokenType.Operator);
}
output.WriteSpace();
output.WriteRightBrace();
}