string IAssemblyBrowserNodeBuilder.GetDisassembly(ITreeNavigator navigator)
{
DomCecilMethod method = navigator.DataItem as DomCecilMethod;
if (method == null)
{
return("");
}
NetAmbience netAmbience = new NetAmbience();
StringBuilder result = new StringBuilder();
result.Append(netAmbience.GetString(method, DomTypeNodeBuilder.settings));
result.AppendLine();
result.AppendLine();
result.Append(Disassemble(method, true));
return(result.ToString());
}
string IAssemblyBrowserNodeBuilder.GetDocumentationMarkup(ITreeNavigator navigator)
{
DomCecilMethod method = navigator.DataItem as DomCecilMethod;
StringBuilder result = new StringBuilder();
result.Append("<big>");
result.Append(Ambience.GetString(method, OutputFlags.AssemblyBrowserDescription));
result.Append("</big>");
result.AppendLine();
AmbienceService.DocumentationFormatOptions options = new AmbienceService.DocumentationFormatOptions();
options.MaxLineLength = -1;
options.BigHeadings = true;
options.Ambience = Ambience;
result.AppendLine();
result.Append(AmbienceService.GetDocumentationMarkup(AmbienceService.GetDocumentation(method), options));
return(result.ToString());
}
public string GetDecompiledCode(ITreeNavigator navigator)
{
DomCecilMethod method = navigator.DataItem as DomCecilMethod;
if (method == null)
{
return("");
}
StringBuilder result = new StringBuilder();
/* result.Append (GetAttributes (Ambience, method.Attributes));
* result.Append (Ambience.GetString (method, DomTypeNodeBuilder.settings));
* result.AppendLine ();
* result.Append ("{");
* result.AppendLine ();*/
result.Append(Decompile(method, true));
// result.Append ("}");
return(result.ToString());
}
string IAssemblyBrowserNodeBuilder.GetDisassembly(ITreeNavigator navigator)
{
DomCecilMethod method = navigator.DataItem as DomCecilMethod;
if (method == null)
{
return("");
}
NetAmbience netAmbience = new NetAmbience();
StringBuilder result = new StringBuilder();
var settings = DomTypeNodeBuilder.settings;
settings.OutputFlags |= OutputFlags.IncludeConstraints;
result.Append(netAmbience.GetString(method, settings));
settings.OutputFlags &= ~OutputFlags.IncludeConstraints;
result.AppendLine();
result.AppendLine();
result.Append(Disassemble(method, true));
return(result.ToString());
}
public static string Disassemble(DomCecilMethod method, bool markup)
{
if (method.MethodDefinition.IsPInvokeImpl)
{
return(GettextCatalog.GetString("Method is P/Invoke"));
}
if (method.MethodDefinition.Body == null)
{
IType type = method.DeclaringType;
return(type == null || type.ClassType == ClassType.Interface ? GettextCatalog.GetString("Interface method") : GettextCatalog.GetString("Abstract method"));
}
StringBuilder result = new StringBuilder();
foreach (Instruction instruction in method.MethodDefinition.Body.Instructions)
{
if (markup)
{
result.Append("<b>");
}
result.Append(GetInstructionOffset(instruction));
result.Append(markup ? ":</b> " : ": ");
result.Append(instruction.OpCode);
if (markup)
{
result.Append("<i>");
}
if (instruction.Operand != null)
{
result.Append(' ');
if (instruction.Operand is string)
{
result.Append('"');
result.Append(AssemblyBrowserWidget.FormatText(instruction.Operand.ToString()));
result.Append('"');
}
else if (instruction.Operand is Mono.Cecil.Cil.Instruction)
{
result.Append(GetInstructionOffset((Mono.Cecil.Cil.Instruction)instruction.Operand));
}
else if (instruction.Operand is Mono.Cecil.TypeDefinition)
{
AppendLink(result,
new DomCecilType((Mono.Cecil.TypeDefinition)instruction.Operand).HelpUrl,
instruction.Operand.ToString());
}
else if (instruction.Operand is Mono.Cecil.MethodDefinition)
{
Mono.Cecil.MethodDefinition md = instruction.Operand as Mono.Cecil.MethodDefinition;
AppendLink(result,
new DomCecilMethod(md)
{
DeclaringType = new DomCecilType(md.DeclaringType)
}.HelpUrl,
instruction.Operand.ToString());
}
else if (instruction.Operand is Mono.Cecil.FieldDefinition)
{
Mono.Cecil.FieldDefinition fd = instruction.Operand as Mono.Cecil.FieldDefinition;
AppendLink(result,
new DomCecilField(fd)
{
DeclaringType = new DomCecilType(fd.DeclaringType)
}.HelpUrl,
instruction.Operand.ToString());
}
else if (instruction.Operand is Mono.Cecil.PropertyDefinition)
{
Mono.Cecil.PropertyDefinition pd = instruction.Operand as Mono.Cecil.PropertyDefinition;
AppendLink(result,
new DomCecilProperty(pd)
{
DeclaringType = new DomCecilType(pd.DeclaringType)
}.HelpUrl,
instruction.Operand.ToString());
}
else if (instruction.Operand is Mono.Cecil.TypeReference)
{
AppendLink(result,
"T:" + ((TypeReference)instruction.Operand).FullName,
instruction.Operand.ToString());
}
else if (instruction.Operand is Mono.Cecil.MethodReference)
{
Mono.Cecil.MethodReference mr = instruction.Operand as Mono.Cecil.MethodReference;
StringBuilder id = new StringBuilder(mr.DeclaringType.ToString());
bool isConstructor = mr.Name == ".ctor";
if (!isConstructor)
{
id.Append("." + mr.Name);
}
id.Append("(");
for (int i = 0; i < mr.Parameters.Count; i++)
{
if (i > 0)
{
id.Append(',');
}
id.Append(mr.Parameters[i].ParameterType.FullName);
}
id.Append(")");
AppendLink(result, (isConstructor ? "C:" : "M:") + id, id.ToString());
}
else if (instruction.Operand is Mono.Cecil.FieldReference)
{
Mono.Cecil.FieldReference fr = instruction.Operand as Mono.Cecil.FieldReference;
string id = fr.DeclaringType + "." + fr.Name;
AppendLink(result, "F:" + id, id);
}
else if (instruction.Operand is Mono.Cecil.PropertyReference)
{
Mono.Cecil.PropertyReference pr = instruction.Operand as Mono.Cecil.PropertyReference;
string id = pr.DeclaringType + "." + pr.Name;
AppendLink(result, "P:" + id, id);
}
else
{
result.Append(AssemblyBrowserWidget.FormatText(instruction.Operand.ToString()));
}
}
if (markup)
{
result.Append("</i>");
}
result.AppendLine();
}
result.AppendLine();
return(result.ToString());
}
void SearchDoWork(object sender, DoWorkEventArgs e)
{
BackgroundWorker worker = sender as BackgroundWorker;
try {
string pattern = e.Argument.ToString().ToUpper();
int types = 0, curType = 0;
foreach (DomCecilCompilationUnit unit in this.definitions)
{
types += unit.Types.Count;
}
List <IMember> members = new List <IMember> ();
switch (searchMode)
{
case SearchMode.Member:
foreach (DomCecilCompilationUnit unit in this.definitions)
{
foreach (IType type in unit.Types)
{
if (worker.CancellationPending)
{
return;
}
curType++;
foreach (IMember member in type.Members)
{
if (worker.CancellationPending)
{
return;
}
if (member.Name.ToUpper().Contains(pattern))
{
members.Add(member);
}
}
}
}
Gtk.Application.Invoke(delegate {
IdeApp.Workbench.StatusBar.SetProgressFraction((double)curType / types);
foreach (MonoDevelop.Projects.Dom.IMember member in members)
{
if (worker.CancellationPending)
{
return;
}
memberListStore.AppendValues(ImageService.GetPixbuf(member.StockIcon, Gtk.IconSize.Menu),
member.Name,
member.DeclaringType.FullName,
((DomCecilCompilationUnit)member.DeclaringType.CompilationUnit).AssemblyDefinition.Name.FullName,
member);
}
});
break;
case SearchMode.Disassembler:
Gtk.Application.Invoke(delegate {
IdeApp.Workbench.StatusBar.BeginProgress(GettextCatalog.GetString("Searching string in disassembled code..."));
});
foreach (DomCecilCompilationUnit unit in this.definitions)
{
foreach (IType type in unit.Types)
{
if (worker.CancellationPending)
{
return;
}
curType++;
foreach (IMethod method in type.Methods)
{
if (worker.CancellationPending)
{
return;
}
DomCecilMethod domMethod = method as DomCecilMethod;
if (domMethod == null)
{
continue;
}
if (DomMethodNodeBuilder.Disassemble(domMethod, false).ToUpper().Contains(pattern))
{
members.Add(method);
}
}
}
}
Gtk.Application.Invoke(delegate {
IdeApp.Workbench.StatusBar.SetProgressFraction((double)curType / types);
foreach (MonoDevelop.Projects.Dom.IMember member in members)
{
if (worker.CancellationPending)
{
return;
}
memberListStore.AppendValues(ImageService.GetPixbuf(member.StockIcon, Gtk.IconSize.Menu),
member.Name,
member.DeclaringType.FullName,
((DomCecilCompilationUnit)member.DeclaringType.CompilationUnit).AssemblyDefinition.Name.FullName,
member);
}
});
break;
case SearchMode.Decompiler:
foreach (DomCecilCompilationUnit unit in this.definitions)
{
foreach (IType type in unit.Types)
{
if (worker.CancellationPending)
{
return;
}
curType++;
foreach (IMethod method in type.Methods)
{
if (worker.CancellationPending)
{
return;
}
DomCecilMethod domMethod = method as DomCecilMethod;
if (domMethod == null)
{
continue;
}
if (DomMethodNodeBuilder.Decompile(domMethod, false).ToUpper().Contains(pattern))
{
members.Add(method);
}
}
}
}
Gtk.Application.Invoke(delegate {
IdeApp.Workbench.StatusBar.SetProgressFraction((double)curType / types);
foreach (MonoDevelop.Projects.Dom.IMember member in members)
{
if (worker.CancellationPending)
{
return;
}
memberListStore.AppendValues(ImageService.GetPixbuf(member.StockIcon, Gtk.IconSize.Menu),
member.Name,
member.DeclaringType.FullName,
((DomCecilCompilationUnit)member.DeclaringType.CompilationUnit).AssemblyDefinition.Name.FullName,
member);
}
});
break;
case SearchMode.Type:
foreach (DomCecilCompilationUnit unit in this.definitions)
{
foreach (IType type in unit.Types)
{
if (worker.CancellationPending)
{
return;
}
if (type.FullName.ToUpper().IndexOf(pattern) >= 0)
{
members.Add(type);
}
}
}
Gtk.Application.Invoke(delegate {
foreach (IType type in members)
{
if (worker.CancellationPending)
{
return;
}
typeListStore.AppendValues(ImageService.GetPixbuf(type.StockIcon, Gtk.IconSize.Menu),
type.Name,
type.Namespace,
((DomCecilCompilationUnit)type.CompilationUnit).AssemblyDefinition.Name.FullName,
type);
}
});
break;
}
} finally {
Gtk.Application.Invoke(delegate {
IdeApp.Workbench.StatusBar.EndProgress();
});
}
}
