/// <summary>
/// The programs main function.
/// </summary>
/// <param name="args">The arguments passed by command line.</param>
public static void Main(string[] args)
{
var arguments = new Arguments();
arguments.ParseArguments(args);
if (arguments.ShowHelp)
{
Console.WriteLine("Usage: ImpWiz -i InputFile [...] [-o OutputFile ...].");
Console.WriteLine("");
Console.WriteLine("Options:");
Console.WriteLine("\t--help\t\tShows this help.");
Console.WriteLine("\t-i\t\tThe following assembly files will be rewritten.");
Console.WriteLine("\t-o\t\tThe following destination files will be used for the input assemblies.");
return;
}
if (arguments.InputFiles.Count == 0)
{
Console.Error.WriteLine("Error: No files specified.");
return;
}
if (arguments.InputFiles.Count < arguments.OutputFiles.Count)
{
Console.Error.WriteLine("Error: Not enough input files specified, or too much output files specified.");
return;
}
Stopwatch st = new Stopwatch();
st.Start();
for (int i = 0; i < arguments.InputFiles.Count; i++)
{
var inputFile = arguments.InputFiles[i];
var outputFile = arguments.OutputFiles[i];
if (!File.Exists(inputFile))
{
Console.Error.WriteLine("Input file: " + inputFile + " doesn't exist.");
return;
}
//try
//{
bool overwriteOriginal = Path.GetFullPath(inputFile) == Path.GetFullPath(outputFile);
//AssemblyDefinition outputAssembly = AssemblyDefinition.ReadAssembly(outputFile);
AssemblyDefinition asm = AssemblyDefinition.ReadAssembly(inputFile,
new ReaderParameters(ReadingMode.Deferred)
{
ReadWrite = overwriteOriginal
});
LoadedAssemblies.Add(asm, inputFile);
ITypeFilterStrategy strategy = TypeFilterStrategy.Exclude;
bool integrateImpWiz = true;
var assemblyProcessor = new AssemblyProcessor(asm, strategy, integrateImpWiz);
assemblyProcessor.Process();
LoadContext.Unload();
if (overwriteOriginal)
{
asm.Write();
}
else
{
if (File.Exists(outputFile))
{
File.Delete(outputFile);
}
asm.Write(outputFile);
}
var nAsm = AssemblyDefinition.ReadAssembly(outputFile);
var attrTok = nAsm.MainModule.LookupToken(0x04000008);
var tok = nAsm.MainModule.LookupToken(0x06000021);
//}
//catch (Exception e)
//{
// Console.Error.WriteLine(e);
// throw;
//}
}
st.Stop();
Console.WriteLine(st.ElapsedMilliseconds);
}
public AssemblyProcessor(AssemblyDefinition assembly, ITypeFilterStrategy typeFilterStrategy = null, bool integrateImpWizImporter = false)
{
Assembly = assembly;
IntegrateImpWizImporter = integrateImpWizImporter;
TypeFilterStrategy = typeFilterStrategy ?? Filters.TypeFilterStrategy.All;
NeededModuleReferences = new HashSet <string>();
SupportedMarshalers = new Dictionary <UnmanagedType, HashSet <MarshalerType> >();
var asmPath = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
var originalLibLoaderAssembly = AssemblyDefinition.ReadAssembly(Path.Combine(asmPath, "ImpWiz.Import.dll"));
if (IntegrateImpWizImporter)
{
//var libLoader = new TypeDefinition("ImpWiz.Import", "LibLoader", TypeAttributes.Class | TypeAttributes.Public, Assembly.MainModule.TypeSystem.Object);
var originalLibLoaderType = originalLibLoaderAssembly.MainModule.Types.First(x => x.Namespace == nameof(ImpWiz) + "." + nameof(Import) + "." + nameof(Import.LibLoader) && x.Name == "LibLoader");
var libLoader = originalLibLoaderType.Clone(Assembly.MainModule);
foreach (var importLibType in originalLibLoaderAssembly.MainModule.Types)
{
importLibType.Clone(Assembly.MainModule);
}
foreach (var modRef in originalLibLoaderAssembly.MainModule.ModuleReferences)
{
NeededModuleReferences.Add(modRef.Name);
}
ImportAssembly = Assembly;
ImportAssemblyLibLoader = (TypeDefinition)libLoader;
}
else
{
ImportAssembly = originalLibLoaderAssembly;
ImportAssemblyLibLoader =
ImportAssembly.MainModule.Types.First(x => x.Namespace == nameof(ImpWiz) + "." + nameof(Import) + "." + nameof(Import.LibLoader) && x.Name == "LibLoader");
}
var allTypes = IntegrateImpWizImporter ? assembly.MainModule.Types : originalLibLoaderAssembly.MainModule.Types.Concat(assembly.MainModule.Types);
foreach (var type in allTypes)
{
if (type.IsAbstract || type.IsInterface || !type.IsClass)
{
continue;
}
if (IsMarshaler(type))
{
var marshaler = new MarshalerType(type);
foreach (var unmanagedType in marshaler.SupportedUnmanagedTypes)
{
HashSet <MarshalerType> marshalers;
if (!SupportedMarshalers.TryGetValue(unmanagedType, out marshalers))
{
marshalers = new HashSet <MarshalerType>();
SupportedMarshalers.Add(unmanagedType, marshalers);
}
marshalers.Add(marshaler);
}
}
}
}
static TypeFilterStrategy()
{
All = new FilterStrategyAll();
Exclude = new FilterStrategyExclude();
Include = new FilterStrategyInclude();
}
public InterfaceExpendTypesProvider(
ITypeFilterStrategy typeFilterStrategy
)
{
_typeFilterStrategy = typeFilterStrategy;
}
