public DecompilationContext(MethodSpecificContext methodContext, TypeSpecificContext typeContext, ModuleSpecificContext moduleContext, AssemblySpecificContext assemblyContext)
{
this.MethodContext = methodContext;
this.TypeContext = typeContext;
this.ModuleContext = moduleContext;
this.AssemblyContext = assemblyContext;
}
public DecompilationContext(MethodSpecificContext methodContext, TypeSpecificContext typeContext, ModuleSpecificContext moduleContext, AssemblySpecificContext assemblyContext)
{
this.MethodContext = methodContext;
this.TypeContext = typeContext;
this.ModuleContext = moduleContext;
this.AssemblyContext = assemblyContext;
}
public override WriterContext GetWriterContext(IMemberDefinition member, ILanguage language)
{
TypeDefinition type = Utilities.GetDeclaringTypeOrSelf(member);
Dictionary <FieldDefinition, PropertyDefinition> fieldToPropertyMap = type.GetFieldToPropertyMap(language);
IEnumerable <FieldDefinition> propertyFields = fieldToPropertyMap.Keys;
HashSet <PropertyDefinition> autoImplementedProperties = new HashSet <PropertyDefinition>(fieldToPropertyMap.Values);
HashSet <EventDefinition> autoImplementedEvents = GetAutoImplementedEvents(type, language);
TypeSpecificContext typeContext = new TypeSpecificContext(type)
{
AutoImplementedProperties = autoImplementedProperties, AutoImplementedEvents = autoImplementedEvents
};
TypeDefinition declaringType = Utilities.GetDeclaringTypeOrSelf(member);
Dictionary <string, string> renamedNamespacesMap = new Dictionary <string, string>();
MemberRenamingData memberReanmingData = GetMemberRenamingData(declaringType.Module, language);
ModuleSpecificContext moduleContext =
new ModuleSpecificContext(declaringType.Module, new List <string>(), new Dictionary <string, List <string> >(), new Dictionary <string, HashSet <string> >(),
renamedNamespacesMap, memberReanmingData.RenamedMembers, memberReanmingData.RenamedMembersMap);
return(new WriterContext(
new AssemblySpecificContext(),
moduleContext,
typeContext,
new Dictionary <string, MethodSpecificContext>(),
GetDecompiledStatements(member, language, propertyFields)));
}
public InitializationPattern(CodePatternsContext patternsContext, DecompilationContext context)
{
base(patternsContext, context.get_MethodContext().get_Method().get_Module().get_TypeSystem());
this.typeContext = context.get_TypeContext();
this.method = context.get_MethodContext().get_Method();
return;
}
public override WriterContext GetWriterContext(IMemberDefinition member, ILanguage language)
{
TypeDefinition type = Utilities.GetDeclaringTypeOrSelf(member);
Dictionary<FieldDefinition, PropertyDefinition> fieldToPropertyMap = type.GetFieldToPropertyMap(language);
IEnumerable<FieldDefinition> propertyFields = fieldToPropertyMap.Keys;
HashSet<PropertyDefinition> autoImplementedProperties = new HashSet<PropertyDefinition>(fieldToPropertyMap.Values);
HashSet<EventDefinition> autoImplementedEvents = GetAutoImplementedEvents(type);
TypeSpecificContext typeContext = new TypeSpecificContext(type) { AutoImplementedProperties = autoImplementedProperties, AutoImplementedEvents = autoImplementedEvents };
TypeDefinition declaringType = Utilities.GetDeclaringTypeOrSelf(member);
Dictionary<string, string> renamedNamespacesMap = new Dictionary<string, string>();
MemberRenamingData memberReanmingData = GetMemberRenamingData(declaringType.Module, language);
ModuleSpecificContext moduleContext =
new ModuleSpecificContext(declaringType.Module, new List<string>(), new Dictionary<string, List<string>>(), new Dictionary<string, HashSet<string>>(),
renamedNamespacesMap, memberReanmingData.RenamedMembers, memberReanmingData.RenamedMembersMap);
return new WriterContext(
new AssemblySpecificContext(),
moduleContext,
typeContext,
new Dictionary<string, MethodSpecificContext>(),
GetDecompiledStatements(member, language, propertyFields));
}
protected void AddGeneratedFilterMethodsToDecompiledType(DecompiledType decompiledType, TypeSpecificContext context, ILanguage language)
{
foreach (GeneratedMethod generatedMethod in context.GeneratedFilterMethods)
{
CachedDecompiledMember member = new CachedDecompiledMember(new DecompiledMember(Utilities.GetMemberUniqueName(generatedMethod.Method), generatedMethod.Body, generatedMethod.Context));
AddDecompiledMemberToDecompiledType(member, decompiledType);
}
}
public PropertyRecognizer(TypeSystem typeSystem, TypeSpecificContext typeContext, ILanguage language)
{
base();
this.typeSystem = typeSystem;
this.typeContext = typeContext;
this.language = language;
return;
}
protected CachedDecompiledMember AddDecompiledMemberToCache(IMemberDefinition member, DecompiledMember decompiledMember, TypeSpecificContext typeContext, ILanguage language)
{
CachedDecompiledMember cachedMember = new CachedDecompiledMember(decompiledMember, typeContext);
if (!this.cacheService.IsDecompiledMemberInCache(member, language, this.renameInvalidMembers))
{
this.cacheService.AddDecompiledMemberToCache(member, language, this.renameInvalidMembers, cachedMember);
}
return cachedMember;
}
protected override TypeSpecificContext GetTypeContext(Mono.Cecil.TypeDefinition type, Languages.ILanguage language, System.Collections.Generic.Dictionary <string, DecompiledType> decompiledTypes)
{
TypeSpecificContext typeContext = base.GetTypeContext(type, language, decompiledTypes);
if (!typeContext.IsWinRTImplementation && typeContext.CurrentType.IsNotPublic && typeContext.CurrentType.IsSealed && typeContext.CurrentType.Name.StartsWith("<CLR>"))
{
typeContext.IsWinRTImplementation = true;
}
return(typeContext);
}
public override WriterContext GetWriterContext(IMemberDefinition member, ILanguage language)
{
TypeSpecificContext typeContext;
DecompiledType decompiledType;
if (member is TypeDefinition && member == Utilities.GetOuterMostDeclaringType(member))
{
TypeDefinition type = member as TypeDefinition;
Dictionary <string, DecompiledType> decompiledTypes = GetNestedDecompiledTypes(type, language);
TypeSpecificContext cachedTypeContext = GetTypeContext(type, language, decompiledTypes);
typeContext = new TypeSpecificContext(
cachedTypeContext.CurrentType,
cachedTypeContext.MethodDefinitionToNameMap,
cachedTypeContext.BackingFieldToNameMap,
cachedTypeContext.UsedNamespaces,
new HashSet <string>(),
cachedTypeContext.FieldAssignmentData,
cachedTypeContext.AutoImplementedProperties,
cachedTypeContext.AutoImplementedEvents,
cachedTypeContext.ExplicitlyImplementedMembers,
cachedTypeContext.ExceptionWhileDecompiling
);
if (!decompiledTypes.TryGetValue(type.FullName, out decompiledType))
{
throw new Exception("Decompiled type not found in decompiled types cache.");
}
}
else
{
decompiledType = GetDecompiledType(member, language);
typeContext = decompiledType.TypeContext;
}
Dictionary <string, MethodSpecificContext> methodContexts = new Dictionary <string, MethodSpecificContext>();
Dictionary <string, Statement> decompiledStatements = new Dictionary <string, Statement>();
foreach (KeyValuePair <string, DecompiledMember> decompiledPair in decompiledType.DecompiledMembers)
{
methodContexts.Add(decompiledPair.Key, decompiledPair.Value.Context);
decompiledStatements.Add(decompiledPair.Key, decompiledPair.Value.Statement);
}
TypeDefinition declaringType = Utilities.GetDeclaringTypeOrSelf(member);
AssemblySpecificContext assemblyContext = GetAssemblyContext(declaringType.Module.Assembly, language);
ModuleSpecificContext moduleContext = GetModuleContext(declaringType.Module, language);
WriterContext writerContext = new WriterContext(assemblyContext, moduleContext, typeContext, methodContexts, decompiledStatements);
return(writerContext);
}
public virtual BlockStatement Process(DecompilationContext context, BlockStatement block)
{
this.context = context;
this.methodContext = context.get_MethodContext();
this.typeContext = context.get_TypeContext();
this.Preprocess();
this.VisitBlockStatement(block);
this.ReplaceDeclarations(block);
this.CollectVariableNames();
return(block);
}
public virtual BlockStatement Process(DecompilationContext context, BlockStatement block)
{
this.methodContext = context.MethodContext;
this.typeContext = context.TypeContext;
//this.suggestedNames.UnionWith(methodContext.UsedNames);
//this.suggestedNames.UnionWith(context.VariableNames);
Preprocess();
VisitBlockStatement(block);
ReplaceDeclarations(block);
//this.methodContext.UsedNames.UnionWith(suggestedNames);
CollectVariableNames();
return(block);
}
private WriterContext GetWriterContextForType(TypeDefinition type, ILanguage language)
{
TypeDefinition outerMostDeclaringType = Utilities.GetOuterMostDeclaringType(type);
Dictionary <string, DecompiledType> decompiledTypes;
if (this.cacheService.AreNestedDecompiledTypesInCache(outerMostDeclaringType, language, this.renameInvalidMembers))
{
decompiledTypes = this.cacheService.GetNestedDecompiledTypesFromCache(outerMostDeclaringType, language, this.renameInvalidMembers);
}
else
{
decompiledTypes = GetNestedDecompiledTypes(outerMostDeclaringType, language);
this.cacheService.AddNestedDecompiledTypesToCache(outerMostDeclaringType, language, this.renameInvalidMembers, decompiledTypes);
}
TypeSpecificContext typeContext = GetTypeContext(outerMostDeclaringType, language, decompiledTypes);
AddTypeContextsToCache(decompiledTypes, outerMostDeclaringType, language);
Dictionary <string, MethodSpecificContext> methodContexts = new Dictionary <string, MethodSpecificContext>();
Dictionary <string, Statement> decompiledStatements = new Dictionary <string, Statement>();
DecompiledType decompiledType;
if (!decompiledTypes.TryGetValue(type.FullName, out decompiledType))
{
throw new Exception("Decompiled type missing from DecompiledTypes cache.");
}
else
{
// If members were taken from the cache, generated filter methods must be added to decompiled type.
if (typeContext.GeneratedFilterMethods.Count > 0)
{
AddGeneratedFilterMethodsToDecompiledType(decompiledType, typeContext, language);
}
foreach (DecompiledMember decompiledMember in decompiledType.DecompiledMembers.Values)
{
methodContexts.Add(decompiledMember.MemberFullName, decompiledMember.Context);
decompiledStatements.Add(decompiledMember.MemberFullName, decompiledMember.Statement);
}
}
AssemblySpecificContext assemblyContext = GetAssemblyContext(outerMostDeclaringType.Module.Assembly, language);
ModuleSpecificContext moduleContext = GetModuleContext(outerMostDeclaringType.Module, language);
WriterContext writerContext = new WriterContext(assemblyContext, moduleContext, typeContext, methodContexts, decompiledStatements);
return(writerContext);
}
public override WriterContext GetWriterContext(IMemberDefinition member, ILanguage language)
{
V_0 = Utilities.GetDeclaringTypeOrSelf(member);
stackVariable4 = V_0.GetFieldToPropertyMap(language);
V_1 = stackVariable4.get_Keys();
V_2 = new HashSet <PropertyDefinition>(stackVariable4.get_Values());
V_3 = this.GetAutoImplementedEvents(V_0, language);
stackVariable13 = new TypeSpecificContext(V_0);
stackVariable13.set_AutoImplementedProperties(V_2);
stackVariable13.set_AutoImplementedEvents(V_3);
V_4 = stackVariable13;
V_5 = Utilities.GetDeclaringTypeOrSelf(member);
V_6 = new Dictionary <string, string>();
V_7 = this.GetMemberRenamingData(V_5.get_Module(), language);
V_8 = new ModuleSpecificContext(V_5.get_Module(), new List <string>(), new Dictionary <string, List <string> >(), new Dictionary <string, HashSet <string> >(), V_6, V_7.get_RenamedMembers(), V_7.get_RenamedMembersMap());
return(new WriterContext(new AssemblySpecificContext(), V_8, V_4, new Dictionary <string, MethodSpecificContext>(), this.GetDecompiledStatements(member, language, V_1)));
}
public override WriterContext GetWriterContext(IMemberDefinition member, ILanguage language)
{
if (member as TypeDefinition == null || member != Utilities.GetOuterMostDeclaringType(member))
{
V_1 = this.GetDecompiledType(member, language);
V_0 = this.GetTypeContext(V_1, language);
}
else
{
V_7 = member as TypeDefinition;
V_8 = this.GetNestedDecompiledTypes(V_7, language);
V_0 = this.GetTypeContext(V_7, language, V_8);
this.AddTypeContextsToCache(V_8, V_7, language);
if (!V_8.TryGetValue(V_7.get_FullName(), out V_1))
{
throw new Exception("Decompiled type not found in decompiled types cache.");
}
}
V_2 = new TypeSpecificContext(V_0.get_CurrentType(), V_0.get_MethodDefinitionToNameMap(), V_0.get_BackingFieldToNameMap(), V_0.get_UsedNamespaces(), new HashSet <string>(), V_0.get_AssignmentData(), V_0.get_AutoImplementedProperties(), V_0.get_AutoImplementedEvents(), V_0.get_ExplicitlyImplementedMembers(), V_0.get_ExceptionWhileDecompiling(), V_0.get_GeneratedFilterMethods(), V_0.get_GeneratedMethodDefinitionToNameMap());
if (V_2.get_GeneratedFilterMethods().get_Count() > 0)
{
this.AddGeneratedFilterMethodsToDecompiledType(V_1, V_2, language);
}
V_3 = new Dictionary <string, MethodSpecificContext>();
V_4 = new Dictionary <string, Statement>();
V_9 = V_1.get_DecompiledMembers().GetEnumerator();
try
{
while (V_9.MoveNext())
{
V_10 = V_9.get_Current();
V_3.Add(V_10.get_Key(), V_10.get_Value().get_Context());
V_4.Add(V_10.get_Key(), V_10.get_Value().get_Statement());
}
}
finally
{
((IDisposable)V_9).Dispose();
}
V_5 = Utilities.GetDeclaringTypeOrSelf(member);
stackVariable66 = this.GetAssemblyContext(V_5.get_Module().get_Assembly(), language);
V_6 = this.GetModuleContext(V_5.get_Module(), language);
return(new WriterContext(stackVariable66, V_6, V_2, V_3, V_4));
}
private void RemoveBaseCtorInvocationStatements(CachedDecompiledMember decompiledMember, DecompiledType decompiledType)
{
MethodSpecificContext methodContext = decompiledMember.Member.Context;
//value types chained constructors?
if (methodContext == null || !methodContext.Method.IsConstructor || methodContext.Method.IsStatic || methodContext.CtorInvokeExpression == null)
{
return;
}
BlockStatement methodBody = decompiledMember.Member.Statement as BlockStatement;
if (methodBody == null) // it might have been an exception
{
return;
}
else if (methodBody.Statements.Count == 1 && methodBody.Statements[0] is UnsafeBlockStatement)
{
methodBody = methodBody.Statements[0] as UnsafeBlockStatement;
}
TypeSpecificContext typeContext = decompiledType.TypeContext;
if (typeContext.FieldInitializationFailed && typeContext.BaseCtorInvocators.Contains(methodContext.Method))
{
methodContext.CtorInvokeExpression = null;
}
else
{
/// all statements before the constructor invocation should be removed
for (int i = 0; i < methodBody.Statements.Count; i++)
{
if (methodBody.Statements[i].CodeNodeType == Ast.CodeNodeType.ExpressionStatement &&
((methodBody.Statements[i] as ExpressionStatement).Expression.CodeNodeType == Ast.CodeNodeType.ThisCtorExpression ||
(methodBody.Statements[i] as ExpressionStatement).Expression.CodeNodeType == Ast.CodeNodeType.BaseCtorExpression))
{
RemoveFirstStatements(methodBody.Statements, i + 1);
return;
}
}
throw new Exception("Constructor invocation not found.");
}
}
public override WriterContext GetWriterContext(IMemberDefinition member, ILanguage language)
{
AssemblySpecificContext assemblyContext = new AssemblySpecificContext();
ModuleSpecificContext moduleContext = new ModuleSpecificContext();
TypeSpecificContext typeContext = new TypeSpecificContext(Utilities.GetDeclaringTypeOrSelf(member));
DecompiledType decompiledType = GetDecompiledType(member, language);
Dictionary <string, MethodSpecificContext> methodContexts = new Dictionary <string, MethodSpecificContext>();
Dictionary <string, Statement> decompiledStatements = new Dictionary <string, Statement>();
foreach (KeyValuePair <string, DecompiledMember> decompiledPair in decompiledType.DecompiledMembers)
{
methodContexts.Add(decompiledPair.Key, decompiledPair.Value.Context);
decompiledStatements.Add(decompiledPair.Key, decompiledPair.Value.Statement);
}
WriterContext writerContext = new WriterContext(assemblyContext, moduleContext, typeContext, methodContexts, decompiledStatements);
return(writerContext);
}
public override WriterContext GetWriterContext(IMemberDefinition member, ILanguage language)
{
AssemblySpecificContext assemblyContext = new AssemblySpecificContext();
ModuleSpecificContext moduleContext = new ModuleSpecificContext();
TypeSpecificContext typeContext = new TypeSpecificContext(Utilities.GetDeclaringTypeOrSelf(member));
DecompiledType decompiledType = GetDecompiledType(member, language);
Dictionary<string, MethodSpecificContext> methodContexts = new Dictionary<string, MethodSpecificContext>();
Dictionary<string, Statement> decompiledStatements = new Dictionary<string, Statement>();
foreach (KeyValuePair<string, DecompiledMember> decompiledPair in decompiledType.DecompiledMembers)
{
methodContexts.Add(decompiledPair.Key, decompiledPair.Value.Context);
decompiledStatements.Add(decompiledPair.Key, decompiledPair.Value.Statement);
}
WriterContext writerContext = new WriterContext(assemblyContext, moduleContext, typeContext, methodContexts, decompiledStatements);
return writerContext;
}
protected virtual TypeSpecificContext GetTypeContext(TypeDefinition type, ILanguage language, Dictionary <string, DecompiledType> decompiledTypes)
{
DecompiledType decompiledCurrentType;
if (!decompiledTypes.TryGetValue(type.FullName, out decompiledCurrentType))
{
throw new Exception("Decompiled type not found in decompiled types cache.");
}
TypeSpecificContext typeContext;
if (this.cacheService.IsTypeContextInCache(type, language, this.renameInvalidMembers))
{
typeContext = this.cacheService.GetTypeContextFromCache(type, language, this.renameInvalidMembers);
}
else
{
ICollection <TypeReference> typesDependingOn = GetTypesDependingOn(decompiledTypes, language);
ICollection <string> usedNamespaces = GetUsedNamespaces(typesDependingOn, type.Namespace);
ICollection <string> visibleMembersNames = GetTypeVisibleMembersNames(type, language);
ExplicitlyImplementedMembersCollection explicitlyImplementedInterfaceMethods = GetExplicitlyImplementedInterfaceMethods(type, language);
typeContext = new TypeSpecificContext(
type,
decompiledCurrentType.TypeContext.MethodDefinitionToNameMap,
decompiledCurrentType.TypeContext.BackingFieldToNameMap,
usedNamespaces,
visibleMembersNames,
decompiledCurrentType.TypeContext.FieldAssignmentData,
GetAutoImplementedProperties(decompiledTypes),
GetAutoImplementedEvents(decompiledTypes),
explicitlyImplementedInterfaceMethods,
this.ExceptionsWhileDecompiling
);
this.cacheService.AddTypeContextToCache(type, language, this.renameInvalidMembers, typeContext);
}
return(typeContext);
}
public override WriterContext GetWriterContext(IMemberDefinition member, ILanguage language)
{
V_0 = new AssemblySpecificContext();
V_1 = new ModuleSpecificContext();
V_2 = new TypeSpecificContext(Utilities.GetDeclaringTypeOrSelf(member));
stackVariable8 = this.GetDecompiledType(member, language);
V_3 = new Dictionary <string, MethodSpecificContext>();
V_4 = new Dictionary <string, Statement>();
V_5 = stackVariable8.get_DecompiledMembers().GetEnumerator();
try
{
while (V_5.MoveNext())
{
V_6 = V_5.get_Current();
V_3.Add(V_6.get_Key(), V_6.get_Value().get_Context());
V_4.Add(V_6.get_Key(), V_6.get_Value().get_Statement());
}
}
finally
{
((IDisposable)V_5).Dispose();
}
return(new WriterContext(V_0, V_1, V_2, V_3, V_4));
}
protected void AddGeneratedFilterMethodsToDecompiledType(DecompiledType decompiledType, TypeSpecificContext context, ILanguage language)
{
foreach (GeneratedMethod generatedMethod in context.GeneratedFilterMethods)
{
CachedDecompiledMember member = new CachedDecompiledMember(new DecompiledMember(Utilities.GetMemberUniqueName(generatedMethod.Method), generatedMethod.Body, generatedMethod.Context));
AddDecompiledMemberToDecompiledType(member, decompiledType);
}
}
public void ReplaceCachedTypeContext(TypeDefinition type, ILanguage language, bool renameInvalidMembers, TypeSpecificContext newContext)
{
if (newContext == null)
{
throw new ArgumentNullException("newContext");
}
RemoveTypeContextFromCache(type, language, renameInvalidMembers);
AddTypeContextToCache(type, language, renameInvalidMembers, newContext);
}
private CachedDecompiledMember DecompileMethod(ILanguage language, MethodDefinition method, TypeSpecificContext typeContext)
{
CachedDecompiledMember decompiledMember;
Statement statement;
try
{
DecompilationContext innerContext = null;
statement = method.Body.Decompile(language, out innerContext, typeContext);
decompiledMember = new CachedDecompiledMember(new DecompiledMember(Utilities.GetMemberUniqueName(method), statement, innerContext.MethodContext), innerContext.TypeContext);
}
catch (Exception ex)
{
this.ExceptionsWhileDecompiling.Add(method);
BlockStatement blockStatement = new BlockStatement();
statement = new ExceptionStatement(ex, method);
blockStatement.AddStatement(statement);
decompiledMember = new CachedDecompiledMember(new DecompiledMember(Utilities.GetMemberUniqueName(method), blockStatement, new MethodSpecificContext(method.Body)));
}
return(decompiledMember);
}
public DecompilationContext(MethodSpecificContext methodContext, TypeSpecificContext typeContext)
: this(methodContext, typeContext, new ModuleSpecificContext(), new AssemblySpecificContext())
{
}
public CachedDecompiledMember(DecompiledMember decompiledMember, TypeSpecificContext typeContext) : this(decompiledMember, typeContext.AssignmentData)
{
}
public override WriterContext GetWriterContext(IMemberDefinition member, ILanguage language)
{
TypeSpecificContext cachedTypeContext;
DecompiledType decompiledType;
if (member is TypeDefinition && member == Utilities.GetOuterMostDeclaringType(member))
{
TypeDefinition type = member as TypeDefinition;
Dictionary<string, DecompiledType> decompiledTypes = GetNestedDecompiledTypes(type, language);
cachedTypeContext = GetTypeContext(type, language, decompiledTypes);
AddTypeContextsToCache(decompiledTypes, type, language);
if (!decompiledTypes.TryGetValue(type.FullName, out decompiledType))
{
throw new Exception("Decompiled type not found in decompiled types cache.");
}
}
else
{
decompiledType = GetDecompiledType(member, language);
cachedTypeContext = GetTypeContext(decompiledType, language);
}
TypeSpecificContext typeContext = new TypeSpecificContext(
cachedTypeContext.CurrentType,
cachedTypeContext.MethodDefinitionToNameMap,
cachedTypeContext.BackingFieldToNameMap,
cachedTypeContext.UsedNamespaces,
new HashSet<string>(),
cachedTypeContext.AssignmentData,
cachedTypeContext.AutoImplementedProperties,
cachedTypeContext.AutoImplementedEvents,
cachedTypeContext.ExplicitlyImplementedMembers,
cachedTypeContext.ExceptionWhileDecompiling,
cachedTypeContext.GeneratedFilterMethods,
cachedTypeContext.GeneratedMethodDefinitionToNameMap
);
// If members were taken from the cache, generated filter methods must be added to decompiled type.
if (typeContext.GeneratedFilterMethods.Count > 0)
{
AddGeneratedFilterMethodsToDecompiledType(decompiledType, typeContext, language);
}
Dictionary<string, MethodSpecificContext> methodContexts = new Dictionary<string, MethodSpecificContext>();
Dictionary<string, Statement> decompiledStatements = new Dictionary<string, Statement>();
foreach (KeyValuePair<string, DecompiledMember> decompiledPair in decompiledType.DecompiledMembers)
{
methodContexts.Add(decompiledPair.Key, decompiledPair.Value.Context);
decompiledStatements.Add(decompiledPair.Key, decompiledPair.Value.Statement);
}
TypeDefinition declaringType = Utilities.GetDeclaringTypeOrSelf(member);
AssemblySpecificContext assemblyContext = GetAssemblyContext(declaringType.Module.Assembly, language);
ModuleSpecificContext moduleContext = GetModuleContext(declaringType.Module, language);
WriterContext writerContext = new WriterContext(assemblyContext, moduleContext, typeContext, methodContexts, decompiledStatements);
return writerContext;
}
public virtual void AddTypeContextToCache(TypeDefinition type, ILanguage language, bool renameInvalidMembers, TypeSpecificContext typeContext)
{
typeContextsCache.Add(GetTypeKey(type, language, renameInvalidMembers), typeContext);
}
public void ReplaceCachedTypeContext(TypeDefinition type, ILanguage language, bool renameInvalidMembers, TypeSpecificContext newContext)
{
if (newContext == null)
{
throw new ArgumentNullException("newContext");
}
RemoveTypeContextFromCache(type, language, renameInvalidMembers);
AddTypeContextToCache(type, language, renameInvalidMembers, newContext);
}
private CachedDecompiledMember DecompileMethod(ILanguage language, MethodDefinition method, TypeSpecificContext typeContext)
{
try
{
V_2 = null;
V_1 = method.get_Body().Decompile(language, out V_2, typeContext);
V_0 = new CachedDecompiledMember(new DecompiledMember(Utilities.GetMemberUniqueName(method), V_1, V_2.get_MethodContext()), V_2.get_TypeContext());
}
catch (Exception exception_0)
{
V_3 = exception_0;
this.get_ExceptionsWhileDecompiling().Add(method);
V_4 = new BlockStatement();
V_4.AddStatement(new ExceptionStatement(V_3, method));
V_0 = new CachedDecompiledMember(new DecompiledMember(Utilities.GetMemberUniqueName(method), V_4, new MethodSpecificContext(method.get_Body())));
this.OnExceptionThrown(V_3);
}
return(V_0);
}
public void AddTypeContextToCache(TypeDefinition type, ILanguage language, bool renameInvalidMembers, TypeSpecificContext typeContex)
{
}
public virtual void AddTypeContextToCache(TypeDefinition type, ILanguage language, bool renameInvalidMembers, TypeSpecificContext typeContext)
{
DefaultDecompilationCacheService.typeContextsCache.Add(this.GetTypeKey(type, language, renameInvalidMembers), typeContext);
return;
}
public void ReplaceCachedTypeContext(TypeDefinition type, ILanguage language, bool renameInvalidMembers, TypeSpecificContext newContext)
{
}
protected CachedDecompiledMember AddDecompiledMemberToCache(IMemberDefinition member, DecompiledMember decompiledMember, TypeSpecificContext typeContext, ILanguage language)
{
CachedDecompiledMember cachedMember = new CachedDecompiledMember(decompiledMember, typeContext);
if (!this.cacheService.IsDecompiledMemberInCache(member, language, this.renameInvalidMembers))
{
this.cacheService.AddDecompiledMemberToCache(member, language, this.renameInvalidMembers, cachedMember);
}
return(cachedMember);
}
private bool TryGetTypeContextFromCache(TypeDefinition type, ILanguage language, out TypeSpecificContext typeContext)
{
typeContext = null;
if (this.cacheService.IsTypeContextInCache(type, language, this.renameInvalidMembers))
{
typeContext = this.cacheService.GetTypeContextFromCache(type, language, this.renameInvalidMembers);
}
return(typeContext != null);
}
public void AddTypeContextToCache(TypeDefinition type, ILanguage language, bool renameInvalidMembers, TypeSpecificContext typeContext)
{
string typeKey = GetTypeKey(type, language, renameInvalidMembers);
if (typeContextsCache.ContainsKey(typeKey))
{
throw new Exception("Key already in TypeContextsCache");
}
typeContextsCache.Add(typeKey, typeContext);
}
public CachedDecompiledMember(DecompiledMember decompiledMember, TypeSpecificContext typeContext) : this(decompiledMember, typeContext.AssignmentData)
{
}
public void ReplaceCachedTypeContext(TypeDefinition type, ILanguage language, bool renameInvalidMembers, TypeSpecificContext newContext)
{
}
private bool TryGetTypeContextFromCache(TypeDefinition type, ILanguage language, out TypeSpecificContext typeContext)
{
typeContext = null;
if (this.cacheService.IsTypeContextInCache(type, language, this.renameInvalidMembers))
{
typeContext = this.cacheService.GetTypeContextFromCache(type, language, this.renameInvalidMembers);
}
return typeContext != null;
}
protected void AddGeneratedFilterMethodsToDecompiledType(DecompiledType decompiledType, TypeSpecificContext context, ILanguage language)
{
V_0 = context.get_GeneratedFilterMethods().GetEnumerator();
try
{
while (V_0.MoveNext())
{
V_1 = V_0.get_Current();
V_2 = new CachedDecompiledMember(new DecompiledMember(Utilities.GetMemberUniqueName(V_1.get_Method()), V_1.get_Body(), V_1.get_Context()));
this.AddDecompiledMemberToDecompiledType(V_2, decompiledType);
}
}
finally
{
if (V_0 != null)
{
V_0.Dispose();
}
}
return;
}
public void AddTypeContextToCache(TypeDefinition type, ILanguage language, bool renameInvalidMembers, TypeSpecificContext typeContext)
{
string typeKey = GetTypeKey(type, language, renameInvalidMembers);
if (typeContextsCache.ContainsKey(typeKey))
{
throw new Exception("Key already in TypeContextsCache");
}
typeContextsCache.Add(typeKey, typeContext);
}
private CachedDecompiledMember DecompileMethod(ILanguage language, MethodDefinition method, TypeSpecificContext typeContext)
{
CachedDecompiledMember decompiledMember;
Statement statement;
try
{
DecompilationContext innerContext = null;
statement = method.Body.Decompile(language, out innerContext, typeContext);
decompiledMember = new CachedDecompiledMember(new DecompiledMember(Utilities.GetMemberUniqueName(method), statement, innerContext.MethodContext), innerContext.TypeContext);
}
catch (Exception ex)
{
this.ExceptionsWhileDecompiling.Add(method);
BlockStatement blockStatement = new BlockStatement();
statement = new ExceptionStatement(ex, method);
blockStatement.AddStatement(statement);
decompiledMember = new CachedDecompiledMember(new DecompiledMember(Utilities.GetMemberUniqueName(method), blockStatement, new MethodSpecificContext(method.Body)));
}
return decompiledMember;
}
public CachedDecompiledMember(DecompiledMember decompiledMember, TypeSpecificContext typeContext)
{
this(decompiledMember, typeContext.get_AssignmentData());
return;
}
public FieldInitializationPattern(CodePatternsContext patternsContext, DecompilationContext context)
: base(patternsContext, context.MethodContext.Method.Module.TypeSystem)
{
this.typeContext = context.TypeContext;
this.method = context.MethodContext.Method;
}
public virtual void AddTypeContextToCache(TypeDefinition type, ILanguage language, bool renameInvalidMembers, TypeSpecificContext typeContext)
{
typeContextsCache.Add(GetTypeKey(type, language, renameInvalidMembers), typeContext);
}
public void AddTypeContextToCache(TypeDefinition type, ILanguage language, bool renameInvalidMembers, TypeSpecificContext typeContex)
{
}
