Exemple #1
0
        /// ------------------------------------------------------------------------------------
        /// <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);
            }
        }
Exemple #2
0
        /// ------------------------------------------------------------------------------------
        /// <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);
            }
        }
Exemple #3
0
        /// ------------------------------------------------------------------------------------
        /// <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);
        }
Exemple #4
0
		/// ------------------------------------------------------------------------------------
		/// <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;
		}
Exemple #5
0
		/// ------------------------------------------------------------------------------------
		/// <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);
			}
		}
Exemple #6
0
        /// ------------------------------------------------------------------------------------
        /// <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);
        }