public class ResolveFromAssemblyStep : ResolveStep {
- string _assembly;
+ AssemblyDefinition _assembly;
+ string _file;
public ResolveFromAssemblyStep (string assembly)
+ {
+ _file = assembly;
+ }
+
+ public ResolveFromAssemblyStep (AssemblyDefinition assembly)
{
_assembly = assembly;
}
- public override void Process (LinkContext context)
+ protected override void Process ()
{
- AssemblyDefinition assembly = context.Resolve (_assembly);
+ if (_assembly != null)
+ Context.Resolver.CacheAssembly (_assembly);
- switch (assembly.Kind) {
- case AssemblyKind.Dll:
- ProcessLibrary (assembly);
- return;
+ AssemblyDefinition assembly = _assembly ?? Context.Resolve (_file);
+
+ switch (assembly.MainModule.Kind) {
+ case ModuleKind.Dll:
+ ProcessLibrary (Context, assembly);
+ break;
default:
ProcessExecutable (assembly);
- return;
+ break;
}
}
- static void ProcessLibrary (AssemblyDefinition assembly)
+ static void SetAction (LinkContext context, AssemblyDefinition assembly, AssemblyAction action)
{
- Annotations.SetAction (assembly, AssemblyAction.Copy);
+ TryReadSymbols (context, assembly);
- foreach (TypeDefinition type in assembly.MainModule.Types) {
- Annotations.Mark (type);
+ context.Annotations.SetAction (assembly, action);
+ }
- if (type.HasMethods)
- MarkMethods (type.Methods);
- if (type.HasConstructors)
- MarkMethods (type.Constructors);
- }
+ static void TryReadSymbols (LinkContext context, AssemblyDefinition assembly)
+ {
+ context.SafeReadSymbols (assembly);
+ }
+
+ public static void ProcessLibrary (LinkContext context, AssemblyDefinition assembly)
+ {
+ SetAction (context, assembly, AssemblyAction.Copy);
+
+ context.Annotations.Push (assembly);
+
+ foreach (TypeDefinition type in assembly.MainModule.Types)
+ MarkType (context, type);
+
+ context.Annotations.Pop ();
+ }
+
+ static void MarkType (LinkContext context, TypeDefinition type)
+ {
+ context.Annotations.Mark (type);
+
+ context.Annotations.Push (type);
+
+ if (type.HasFields)
+ MarkFields (context, type.Fields);
+ if (type.HasMethods)
+ MarkMethods (context, type.Methods);
+ if (type.HasNestedTypes)
+ foreach (var nested in type.NestedTypes)
+ MarkType (context, nested);
+
+ context.Annotations.Pop ();
}
- static void ProcessExecutable (AssemblyDefinition assembly)
+ void ProcessExecutable (AssemblyDefinition assembly)
{
- Annotations.SetAction (assembly, AssemblyAction.Link);
+ SetAction (Context, assembly, AssemblyAction.Link);
+
+ Annotations.Push (assembly);
Annotations.Mark (assembly.EntryPoint.DeclaringType);
- MarkMethod (assembly.EntryPoint, MethodAction.Parse);
+ MarkMethod (Context, assembly.EntryPoint, MethodAction.Parse);
+
+ Annotations.Pop ();
+ }
+
+ static void MarkFields (LinkContext context, ICollection fields)
+ {
+ foreach (FieldDefinition field in fields)
+ context.Annotations.Mark (field);
}
- static void MarkMethods (ICollection methods)
+ static void MarkMethods (LinkContext context, ICollection methods)
{
foreach (MethodDefinition method in methods)
- MarkMethod (method, MethodAction.ForceParse);
+ MarkMethod (context, method, MethodAction.ForceParse);
}
- static void MarkMethod (MethodDefinition method, MethodAction action)
+ static void MarkMethod (LinkContext context, MethodDefinition method, MethodAction action)
{
- Annotations.Mark (method);
- Annotations.SetAction (method, action);
+ context.Annotations.Mark (method);
+ context.Annotations.SetAction (method, action);
}
}
}