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 (); }