public DomCecilMethod(MethodDefinition methodDefinition)
{
this.methodDefinition = methodDefinition;
this.name = methodDefinition.Name;
if (methodDefinition.Name == ".ctor")
{
MethodModifier |= MethodModifier.IsConstructor;
}
foreach (GenericParameter param in methodDefinition.GenericParameters)
{
TypeParameter tp = new TypeParameter(param.FullName);
tp.Variance = (TypeParameterVariance)(((uint)param.Attributes) & 3);
foreach (TypeReference tr in param.Constraints)
{
tp.AddConstraint(DomCecilMethod.GetReturnType(tr));
}
AddTypeParameter(tp);
}
AddAttributes(this, methodDefinition.CustomAttributes);
base.Modifiers = DomCecilType.GetModifiers(methodDefinition);
base.ReturnType = DomCecilMethod.GetReturnType(methodDefinition.ReturnType.ReturnType);
foreach (ParameterDefinition paramDef in methodDefinition.Parameters)
{
Add(new DomCecilParameter(paramDef));
}
if (this.IsStatic)
{
foreach (IAttribute attr in this.Attributes)
{
if (attr.Name == "System.Runtime.CompilerServices.ExtensionAttribute")
{
MethodModifier |= MethodModifier.IsExtension;
break;
}
}
}
foreach (MethodReference overrideRef in methodDefinition.Overrides)
{
if (overrideRef.Name == this.name && IsPublic)
{
continue;
}
AddExplicitInterface(GetReturnType(overrideRef.DeclaringType));
}
}
public DomCecilType(TypeDefinition typeDefinition, bool loadInternal, bool loadMonotouchDocumentation = true)
{
this.LoadMonotouchDocumentation = loadMonotouchDocumentation;
this.typeDefinition = typeDefinition;
this.loadInternal = loadInternal;
this.classType = GetClassType(typeDefinition);
this.Name = DomCecilType.RemoveGenericParamSuffix(typeDefinition.Name);
this.Namespace = typeDefinition.Namespace;
this.Modifiers = GetModifiers(typeDefinition.Attributes);
if (typeDefinition.BaseType != null)
{
this.baseType = DomCecilMethod.GetReturnType(typeDefinition.BaseType);
}
DomCecilMethod.AddAttributes(this, typeDefinition.CustomAttributes);
foreach (TypeReference interfaceReference in typeDefinition.Interfaces)
{
this.AddInterfaceImplementation(DomCecilMethod.GetReturnType(interfaceReference));
}
foreach (GenericParameter parameter in typeDefinition.GenericParameters)
{
TypeParameter tp = new TypeParameter(parameter.FullName);
tp.Variance = (TypeParameterVariance)(((uint)parameter.Attributes) & 3);
if (parameter.HasDefaultConstructorConstraint)
{
tp.TypeParameterModifier |= TypeParameterModifier.HasDefaultConstructorConstraint;
}
foreach (TypeReference tr in parameter.Constraints)
{
tp.AddConstraint(DomCecilMethod.GetReturnType(tr));
}
AddTypeParameter(tp);
}
AddDocumentation(this);
}
public DomCecilParameter(ParameterDefinition parameterDefinition)
{
this.parameterDefinition = parameterDefinition;
base.Name = parameterDefinition.Name;
// base.modifiers = DomCecilType.GetModifiers (parameterDefinition..Attributes);
base.ReturnType = DomCecilMethod.GetReturnType(parameterDefinition.ParameterType);
if (parameterDefinition.ParameterType is Mono.Cecil.ByReferenceType)
{
this.ParameterModifiers = (parameterDefinition.Attributes & ParameterAttributes.Out) == ParameterAttributes.Out ? ParameterModifiers.Out : ParameterModifiers.Ref;
}
else
{
this.ParameterModifiers = ParameterModifiers.In;
}
if ((parameterDefinition.Attributes & ParameterAttributes.Optional) == ParameterAttributes.Optional)
{
this.ParameterModifiers |= ParameterModifiers.Optional;
}
if ((parameterDefinition.Attributes & ParameterAttributes.HasDefault) == ParameterAttributes.HasDefault)
{
this.DefaultValue = new System.CodeDom.CodePrimitiveExpression(parameterDefinition.Constant);
}
if (ReturnType.ArrayDimensions > 0)
{
foreach (CustomAttribute customAttribute in parameterDefinition.CustomAttributes)
{
if (customAttribute.Constructor.DeclaringType.FullName == "System.ParamArrayAttribute")
{
this.ParameterModifiers |= ParameterModifiers.Params;
}
}
}
}
void CheckInitialization()
{
if (isInitialized)
{
return;
}
isInitialized = true;
foreach (FieldDefinition fieldDefinition in typeDefinition.Fields)
{
if (!loadInternal && DomCecilCompilationUnit.IsInternal(DomCecilType.GetModifiers(fieldDefinition)))
{
continue;
}
var field = new DomCecilField(fieldDefinition);
base.Add(field);
AddDocumentation(field);
}
foreach (MethodDefinition methodDefinition in typeDefinition.Methods.Where(m => !m.IsConstructor))
{
if (!loadInternal && DomCecilCompilationUnit.IsInternal(DomCecilType.GetModifiers(methodDefinition)))
{
continue;
}
var method = new DomCecilMethod(methodDefinition);
base.Add(method);
AddDocumentation(method);
}
bool internalOnly = true;
bool hasConstructors = false;
foreach (MethodDefinition methodDefinition in typeDefinition.Methods.Where(m => m.IsConstructor))
{
hasConstructors = true;
if (!loadInternal && DomCecilCompilationUnit.IsInternal(DomCecilType.GetModifiers(methodDefinition)))
{
continue;
}
internalOnly = false;
base.Add(new DomCecilMethod(methodDefinition));
}
if (hasConstructors && internalOnly)
{
base.TypeModifier |= TypeModifier.HasOnlyHiddenConstructors;
}
foreach (PropertyDefinition propertyDefinition in typeDefinition.Properties)
{
if (!loadInternal && DomCecilCompilationUnit.IsInternal(DomCecilType.GetModifiers(propertyDefinition.Attributes)))
{
continue;
}
base.Add(new DomCecilProperty(propertyDefinition));
}
foreach (EventDefinition eventDefinition in typeDefinition.Events)
{
if (!loadInternal && DomCecilCompilationUnit.IsInternal(DomCecilType.GetModifiers(eventDefinition.Attributes)))
{
continue;
}
base.Add(new DomCecilEvent(eventDefinition));
}
foreach (TypeDefinition nestedType in typeDefinition.NestedTypes)
{
if (!loadInternal && DomCecilCompilationUnit.IsInternal(DomCecilType.GetModifiers(nestedType.Attributes)))
{
continue;
}
DomCecilType innerType = new DomCecilType(nestedType, loadInternal);
base.Add(innerType);
if (typeParameters != null && innerType.typeParameters != null)
{
innerType.typeParameters.RemoveAll(para => typeParameters.Any(myPara => myPara.Name == para.Name));
}
}
}
void CheckInitialization ()
{
if (isInitialized)
return;
isInitialized = true;
foreach (FieldDefinition fieldDefinition in typeDefinition.Fields) {
if (!loadInternal && DomCecilCompilationUnit.IsInternal (DomCecilType.GetModifiers (fieldDefinition)))
continue;
var field = new DomCecilField (fieldDefinition);
base.Add (field);
AddDocumentation (field);
}
foreach (MethodDefinition methodDefinition in typeDefinition.Methods.Where (m => !m.IsConstructor)) {
if (!loadInternal && DomCecilCompilationUnit.IsInternal (DomCecilType.GetModifiers (methodDefinition)))
continue;
var method = new DomCecilMethod (methodDefinition);
base.Add (method);
AddDocumentation (method);
}
bool internalOnly = true;
bool hasConstructors = false;
foreach (MethodDefinition methodDefinition in typeDefinition.Methods.Where (m => m.IsConstructor)) {
hasConstructors = true;
if (!loadInternal && DomCecilCompilationUnit.IsInternal (DomCecilType.GetModifiers (methodDefinition)))
continue;
internalOnly = false;
base.Add (new DomCecilMethod (methodDefinition));
}
if (hasConstructors && internalOnly)
base.TypeModifier |= TypeModifier.HasOnlyHiddenConstructors;
foreach (PropertyDefinition propertyDefinition in typeDefinition.Properties) {
if (!loadInternal && DomCecilCompilationUnit.IsInternal (DomCecilType.GetModifiers (propertyDefinition.Attributes)))
continue;
base.Add (new DomCecilProperty (propertyDefinition));
}
foreach (EventDefinition eventDefinition in typeDefinition.Events) {
if (!loadInternal && DomCecilCompilationUnit.IsInternal (DomCecilType.GetModifiers (eventDefinition.Attributes)))
continue;
base.Add (new DomCecilEvent (eventDefinition));
}
foreach (TypeDefinition nestedType in typeDefinition.NestedTypes) {
if (!loadInternal && DomCecilCompilationUnit.IsInternal (DomCecilType.GetModifiers (nestedType.Attributes)))
continue;
DomCecilType innerType = new DomCecilType (nestedType, loadInternal);
base.Add (innerType);
if (typeParameters != null && innerType.typeParameters != null)
innerType.typeParameters.RemoveAll (para => typeParameters.Any (myPara => myPara.Name == para.Name));
}
}
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 ();
}
public static string Decompile (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 ();
try {
//ControlFlowGraph controlFlowGraph = ControlFlowGraph.Create (method.MethodDefinition);
ILanguage lang = CSharp.GetLanguage (CSharpVersion.V3);
ColoredCSharpFormatter formatter = new ColoredCSharpFormatter ();
ILanguageWriter langWriter = lang.GetWriter (formatter);
langWriter.Write (method.MethodDefinition);
result.Append (formatter.Text);
} catch (Exception e) {
result.Append ("Decompilation failed: \n" + e);
}
return result.ToString ();
}
