/// ------------------------------------------------------------------------------------
/// <summary>
/// The main entry point
/// </summary>
/// ------------------------------------------------------------------------------------
static void Main(string[] args)
{
if (args.Length < 1)
{
Console.WriteLine("Creates manifest files so that exe can be run without COM " +
"needed to be registered in the registry.");
Console.WriteLine();
Console.WriteLine("Usage:");
Console.WriteLine("regfreeApp <exename>");
return;
}
string executable = args[0];
if (!File.Exists(executable))
{
Console.WriteLine("File {0} does not exist", executable);
return;
}
string manifestFile = executable + ".manifest";
XmlDocument doc = new XmlDocument();
doc.PreserveWhitespace = true;
if (File.Exists(manifestFile))
{
using (XmlReader reader = new XmlTextReader(manifestFile))
{
try
{
reader.MoveToContent();
}
catch (XmlException)
{
}
doc.ReadNode(reader);
}
}
RegFreeCreator creator = new RegFreeCreator(doc, false);
XmlElement root = creator.CreateExeInfo(executable);
string directory = Path.GetDirectoryName(executable);
if (directory.Length == 0)
directory = Directory.GetCurrentDirectory();
foreach (string fileName in Directory.GetFiles(directory, "*.dll"))
creator.ProcessTypeLibrary(root, fileName);
XmlWriterSettings settings = new XmlWriterSettings();
settings.OmitXmlDeclaration = false;
settings.NewLineOnAttributes = false;
settings.NewLineChars = Environment.NewLine;
settings.Indent = true;
settings.IndentChars = "\t";
using (XmlWriter writer = XmlWriter.Create(manifestFile, settings))
{
doc.WriteContentTo(writer);
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Executes the task.
/// </summary>
/// ------------------------------------------------------------------------------------
protected override void ExecuteTask()
{
Log(Level.Info, "Processing {0}", Path.GetFileName(Executable));
string manifestFile = Executable + ".manifest";
try
{
var doc = new XmlDocument {
PreserveWhitespace = true
};
using (XmlReader reader = new XmlTextReader(manifestFile))
{
if (reader.MoveToElement())
{
doc.ReadNode(reader);
}
}
// Register all DLLs temporarily
using (var creator = new RegFreeCreator(doc))
{
foreach (string fileName in Dlls.FileNames)
{
Log(Level.Verbose, "\tRegistering library {0}", Path.GetFileName(fileName));
creator.Register(fileName);
}
XmlElement root = creator.CreateExeInfo(Executable);
foreach (string fileName in Dlls.FileNames)
{
Log(Level.Verbose, "\tProcessing library {0}", Path.GetFileName(fileName));
creator.ProcessTypeLibrary(root, fileName);
}
foreach (string fragmentName in Fragments.FileNames)
{
Log(Level.Verbose, "\tAdding fragment {0}", Path.GetFileName(fragmentName));
creator.AddFragment(root, fragmentName);
}
foreach (string fragmentName in AsIs.FileNames)
{
Log(Level.Verbose, "\tAdding as-is fragment {0}", Path.GetFileName(fragmentName));
creator.AddAsIs(root, fragmentName);
}
var settings = new XmlWriterSettings
{
OmitXmlDeclaration = false,
NewLineOnAttributes = false,
NewLineChars = Environment.NewLine,
Indent = true,
IndentChars = "\t"
};
using (XmlWriter writer = XmlWriter.Create(manifestFile, settings))
{
doc.WriteContentTo(writer);
}
// Unregister DLLs
foreach (string fileName in Dlls.FileNames)
{
Log(Level.Verbose, "\tUnregistering library {0}", Path.GetFileName(fileName));
creator.Unregister(fileName);
}
}
}
catch (Exception e)
{
throw new BuildException("Regfree failed.", Location, e);
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Executes the task.
/// </summary>
/// ------------------------------------------------------------------------------------
public override bool Execute()
{
Log.LogMessage(MessageImportance.Normal, "RegFree processing {0}",
Path.GetFileName(Executable));
StringCollection dllPaths = GetFilesFrom(Dlls);
if (dllPaths.Count == 0)
{
string ext = Path.GetExtension(Executable);
if (ext != null && ext.Equals(".dll", StringComparison.InvariantCultureIgnoreCase))
{
dllPaths.Add(Executable);
}
}
string manifestFile = string.IsNullOrEmpty(Output) ? Executable + ".manifest" : Output;
try
{
var doc = new XmlDocument {
PreserveWhitespace = true
};
using (XmlReader reader = new XmlTextReader(manifestFile))
{
if (reader.MoveToElement())
{
doc.ReadNode(reader);
}
}
// Register all DLLs temporarily
using (var regHelper = new RegHelper(Log, Platform))
{
regHelper.RedirectRegistry(!UserIsAdmin);
var creator = new RegFreeCreator(doc, Log);
var filesToRemove = dllPaths.Cast <string>().Where(fileName => !File.Exists(fileName)).ToList();
foreach (var file in filesToRemove)
{
dllPaths.Remove(file);
}
foreach (string fileName in dllPaths)
{
Log.LogMessage(MessageImportance.Low, "\tRegistering library {0}", Path.GetFileName(fileName));
try
{
regHelper.Register(fileName, true, false);
}
catch (Exception e)
{
Log.LogMessage(MessageImportance.High, "Failed to register library {0}", fileName);
Log.LogMessage(MessageImportance.High, e.StackTrace);
}
}
string assemblyName = Path.GetFileNameWithoutExtension(manifestFile);
Debug.Assert(assemblyName != null);
// The C++ test programs won't run if an assemblyIdentity element exists.
//if (assemblyName.StartsWith("test"))
// assemblyName = null;
string assemblyVersion = null;
try
{
assemblyVersion = FileVersionInfo.GetVersionInfo(Executable).FileVersion;
}
catch
{
// just ignore
}
if (string.IsNullOrEmpty(assemblyVersion))
{
assemblyVersion = "1.0.0.0";
}
XmlElement root = creator.CreateExeInfo(assemblyName, assemblyVersion, Platform);
foreach (string fileName in dllPaths)
{
if (NoTypeLib.Count(f => f.ItemSpec == fileName) != 0)
{
continue;
}
Log.LogMessage(MessageImportance.Low, "\tProcessing library {0}", Path.GetFileName(fileName));
creator.ProcessTypeLibrary(root, fileName);
}
creator.ProcessClasses(root);
creator.ProcessInterfaces(root);
foreach (string fragmentName in GetFilesFrom(Fragments))
{
Log.LogMessage(MessageImportance.Low, "\tAdding fragment {0}", Path.GetFileName(fragmentName));
creator.AddFragment(root, fragmentName);
}
foreach (string fragmentName in GetFilesFrom(AsIs))
{
Log.LogMessage(MessageImportance.Low, "\tAdding as-is fragment {0}", Path.GetFileName(fragmentName));
creator.AddAsIs(root, fragmentName);
}
foreach (string assemblyFileName in GetFilesFrom(DependentAssemblies))
{
Log.LogMessage(MessageImportance.Low, "\tAdding dependent assembly {0}", Path.GetFileName(assemblyFileName));
creator.AddDependentAssembly(root, assemblyFileName);
}
var settings = new XmlWriterSettings
{
OmitXmlDeclaration = false,
NewLineOnAttributes = false,
NewLineChars = Environment.NewLine,
Indent = true,
IndentChars = "\t"
};
using (XmlWriter writer = XmlWriter.Create(manifestFile, settings))
{
doc.WriteContentTo(writer);
}
// Unregister DLLs
if (Unregister)
{
foreach (string fileName in dllPaths)
{
Log.LogMessage(MessageImportance.Low, "\tUnregistering library {0}",
Path.GetFileName(fileName));
regHelper.Unregister(fileName, true);
}
}
}
}
catch (Exception e)
{
Log.LogErrorFromException(e, true, true, null);
return(false);
}
return(true);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Executes the task.
/// </summary>
/// ------------------------------------------------------------------------------------
public override bool Execute()
{
Log.LogMessage(MessageImportance.Normal, "RegFree processing {0}",
Path.GetFileName(Executable));
StringCollection dllPaths = IdlImp.GetFilesFrom(Dlls);
if (dllPaths.Count == 0)
{
string ext = Path.GetExtension(Executable);
if (ext != null && ext.Equals(".dll", StringComparison.InvariantCultureIgnoreCase))
dllPaths.Add(Executable);
}
string manifestFile = string.IsNullOrEmpty(Output) ? Executable + ".manifest" : Output;
try
{
var doc = new XmlDocument { PreserveWhitespace = true };
using (XmlReader reader = new XmlTextReader(manifestFile))
{
if (reader.MoveToElement())
doc.ReadNode(reader);
}
// Register all DLLs temporarily
using (var regHelper = new RegHelper(Log))
{
regHelper.RedirectRegistry(!UserIsAdmin);
var creator = new RegFreeCreator(doc, Log);
var filesToRemove = dllPaths.Cast<string>().Where(fileName => !File.Exists(fileName)).ToList();
foreach (var file in filesToRemove)
dllPaths.Remove(file);
foreach (string fileName in dllPaths)
{
Log.LogMessage(MessageImportance.Low, "\tRegistering library {0}", Path.GetFileName(fileName));
try
{
regHelper.Register(fileName, true, false);
}
catch (Exception e)
{
Log.LogMessage(MessageImportance.High, "Failed to register library {0}", fileName);
Log.LogMessage(MessageImportance.High, e.StackTrace);
}
}
string assemblyName = Path.GetFileNameWithoutExtension(manifestFile);
Debug.Assert(assemblyName != null);
// The C++ test programs won't run if an assemblyIdentity element exists.
//if (assemblyName.StartsWith("test"))
// assemblyName = null;
string assemblyVersion = null;
try
{
assemblyVersion = FileVersionInfo.GetVersionInfo(Executable).FileVersion;
}
catch
{
// just ignore
}
if (string.IsNullOrEmpty(assemblyVersion))
assemblyVersion = "1.0.0.0";
XmlElement root = creator.CreateExeInfo(assemblyName, assemblyVersion);
foreach (string fileName in dllPaths)
{
if (NoTypeLib.Count(f => f.ItemSpec == fileName) != 0)
continue;
Log.LogMessage(MessageImportance.Low, "\tProcessing library {0}", Path.GetFileName(fileName));
creator.ProcessTypeLibrary(root, fileName);
}
creator.ProcessClasses(root);
creator.ProcessInterfaces(root);
foreach (string fragmentName in IdlImp.GetFilesFrom(Fragments))
{
Log.LogMessage(MessageImportance.Low, "\tAdding fragment {0}", Path.GetFileName(fragmentName));
creator.AddFragment(root, fragmentName);
}
foreach (string fragmentName in IdlImp.GetFilesFrom(AsIs))
{
Log.LogMessage(MessageImportance.Low, "\tAdding as-is fragment {0}", Path.GetFileName(fragmentName));
creator.AddAsIs(root, fragmentName);
}
foreach (string assemblyFileName in IdlImp.GetFilesFrom(DependentAssemblies))
{
Log.LogMessage(MessageImportance.Low, "\tAdding dependent assembly {0}", Path.GetFileName(assemblyFileName));
creator.AddDependentAssembly(root, assemblyFileName);
}
var settings = new XmlWriterSettings
{
OmitXmlDeclaration = false,
NewLineOnAttributes = false,
NewLineChars = Environment.NewLine,
Indent = true,
IndentChars = "\t"
};
using (XmlWriter writer = XmlWriter.Create(manifestFile, settings))
{
doc.WriteContentTo(writer);
}
// Unregister DLLs
if (Unregister)
{
foreach (string fileName in dllPaths)
{
Log.LogMessage(MessageImportance.Low, "\tUnregistering library {0}",
Path.GetFileName(fileName));
regHelper.Unregister(fileName, true);
}
}
}
}
catch (Exception e)
{
Log.LogErrorFromException(e, true, true, null);
return false;
}
return true;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Executes the task.
/// </summary>
/// ------------------------------------------------------------------------------------
protected override void ExecuteTask()
{
Log(Level.Info, "Processing {0}", Path.GetFileName(Executable));
string manifestFile = Executable + ".manifest";
try
{
var doc = new XmlDocument { PreserveWhitespace = true };
using (XmlReader reader = new XmlTextReader(manifestFile))
{
if (reader.MoveToElement())
doc.ReadNode(reader);
}
// Register all DLLs temporarily
using (var creator = new RegFreeCreator(doc))
{
foreach (string fileName in Dlls.FileNames)
{
Log(Level.Verbose, "\tRegistering library {0}", Path.GetFileName(fileName));
creator.Register(fileName);
}
XmlElement root = creator.CreateExeInfo(Executable);
foreach (string fileName in Dlls.FileNames)
{
Log(Level.Verbose, "\tProcessing library {0}", Path.GetFileName(fileName));
creator.ProcessTypeLibrary(root, fileName);
}
foreach (string fragmentName in Fragments.FileNames)
{
Log(Level.Verbose, "\tAdding fragment {0}", Path.GetFileName(fragmentName));
creator.AddFragment(root, fragmentName);
}
foreach (string fragmentName in AsIs.FileNames)
{
Log(Level.Verbose, "\tAdding as-is fragment {0}", Path.GetFileName(fragmentName));
creator.AddAsIs(root, fragmentName);
}
var settings = new XmlWriterSettings
{
OmitXmlDeclaration = false,
NewLineOnAttributes = false,
NewLineChars = Environment.NewLine,
Indent = true,
IndentChars = "\t"
};
using (XmlWriter writer = XmlWriter.Create(manifestFile, settings))
{
doc.WriteContentTo(writer);
}
// Unregister DLLs
foreach (string fileName in Dlls.FileNames)
{
Log(Level.Verbose, "\tUnregistering library {0}", Path.GetFileName(fileName));
creator.Unregister(fileName);
}
}
}
catch (Exception e)
{
throw new BuildException("Regfree failed.", Location, e);
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Executes the task.
/// </summary>
/// ------------------------------------------------------------------------------------
public override bool Execute()
{
Log.LogMessage(MessageImportance.Normal, "RegFree processing {0}",
Path.GetFileName(Executable));
var manifestFile = string.IsNullOrEmpty(Output) ? Executable + ".manifest" : Output;
try
{
var doc = new XmlDocument {
PreserveWhitespace = true
};
using (XmlReader reader = new XmlTextReader(manifestFile))
{
if (reader.MoveToElement())
{
doc.ReadNode(reader);
}
}
// Register all DLLs temporarily
using (var regHelper = new RegHelper(Log))
{
regHelper.RedirectRegistry();
var creator = new RegFreeCreator(doc, Log);
var dllPaths = IdlImp.GetFilesFrom(Dlls);
var filesToRemove = dllPaths.Cast <string>().Where(fileName => !File.Exists(fileName)).ToList();
foreach (var file in filesToRemove)
{
dllPaths.Remove(file);
}
foreach (string fileName in dllPaths)
{
Log.LogMessage(MessageImportance.Low, "\tRegistering library {0}", Path.GetFileName(fileName));
try
{
regHelper.Register(fileName, UserIsAdmin, NoTypeLib.Count(f => f.ItemSpec == fileName) == 0);
}
catch (Exception e)
{
Log.LogMessage(MessageImportance.High, "Failed to register library {0}", fileName);
Log.LogMessage(MessageImportance.High, e.StackTrace);
}
}
XmlElement root = creator.CreateExeInfo(Executable);
foreach (string fileName in dllPaths)
{
if (NoTypeLib.Count(f => f.ItemSpec == fileName) != 0)
{
continue;
}
Log.LogMessage(MessageImportance.Low, "\tProcessing library {0}", Path.GetFileName(fileName));
creator.ProcessTypeLibrary(root, fileName);
}
creator.ProcessClasses(root);
creator.ProcessInterfaces(root);
foreach (string fragmentName in IdlImp.GetFilesFrom(Fragments))
{
Log.LogMessage(MessageImportance.Low, "\tAdding fragment {0}", Path.GetFileName(fragmentName));
creator.AddFragment(root, fragmentName);
}
foreach (string fragmentName in IdlImp.GetFilesFrom(AsIs))
{
Log.LogMessage(MessageImportance.Low, "\tAdding as-is fragment {0}", Path.GetFileName(fragmentName));
creator.AddAsIs(root, fragmentName);
}
var settings = new XmlWriterSettings
{
OmitXmlDeclaration = false,
NewLineOnAttributes = false,
NewLineChars = Environment.NewLine,
Indent = true,
IndentChars = "\t"
};
using (XmlWriter writer = XmlWriter.Create(manifestFile, settings))
{
doc.WriteContentTo(writer);
}
// Unregister DLLs
if (Unregister)
{
foreach (string fileName in dllPaths)
{
Log.LogMessage(MessageImportance.Low, "\tUnregistering library {0}",
Path.GetFileName(fileName));
regHelper.Unregister(fileName, UserIsAdmin);
}
}
}
}
catch (Exception e)
{
Log.LogErrorFromException(e, true, true, null);
return(false);
}
return(true);
}