From d3d3649a68cb1fa589fdd987a6690dbd5d671f0d Mon Sep 17 00:00:00 2001 From: Rob Mensching Date: Sun, 17 Sep 2017 15:35:20 -0700 Subject: Initial code commit --- src/candle/App.ico | Bin 0 -> 1078 bytes src/candle/AssemblyInfo.cs | 11 ++ src/candle/CandleCommandLine.cs | 343 +++++++++++++++++++++++++++++++++++ src/candle/CandleStrings.Designer.cs | 81 +++++++++ src/candle/CandleStrings.resx | 142 +++++++++++++++ src/candle/CompileFile.cs | 20 ++ src/candle/app.config | 9 + src/candle/candle.cs | 200 ++++++++++++++++++++ src/candle/candle.csproj | 62 +++++++ src/candle/candle.exe.manifest | 9 + src/candle/candle.rc | 10 + 11 files changed, 887 insertions(+) create mode 100644 src/candle/App.ico create mode 100644 src/candle/AssemblyInfo.cs create mode 100644 src/candle/CandleCommandLine.cs create mode 100644 src/candle/CandleStrings.Designer.cs create mode 100644 src/candle/CandleStrings.resx create mode 100644 src/candle/CompileFile.cs create mode 100644 src/candle/app.config create mode 100644 src/candle/candle.cs create mode 100644 src/candle/candle.csproj create mode 100644 src/candle/candle.exe.manifest create mode 100644 src/candle/candle.rc (limited to 'src/candle') diff --git a/src/candle/App.ico b/src/candle/App.ico new file mode 100644 index 00000000..3a5525fd Binary files /dev/null and b/src/candle/App.ico differ diff --git a/src/candle/AssemblyInfo.cs b/src/candle/AssemblyInfo.cs new file mode 100644 index 00000000..7df55940 --- /dev/null +++ b/src/candle/AssemblyInfo.cs @@ -0,0 +1,11 @@ +// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. + +using System; +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +[assembly: AssemblyTitle("WiX Toolset Compiler")] +[assembly: AssemblyDescription("Compiler")] +[assembly: AssemblyCulture("")] +[assembly: ComVisible(false)] diff --git a/src/candle/CandleCommandLine.cs b/src/candle/CandleCommandLine.cs new file mode 100644 index 00000000..81fdf7b2 --- /dev/null +++ b/src/candle/CandleCommandLine.cs @@ -0,0 +1,343 @@ +// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. + +namespace WixToolset.Tools +{ + using System; + using System.Collections.Generic; + using System.Globalization; + using System.IO; + using WixToolset.Data; + + /// + /// Parse command line for candle. + /// + public class CandleCommandLine + { + public CandleCommandLine() + { + this.Platform = Platform.X86; + + this.ShowLogo = true; + this.Extensions = new List(); + this.Files = new List(); + this.IncludeSearchPaths = new List(); + this.PreprocessorVariables = new Dictionary(); + } + + public Platform Platform { get; private set; } + + public bool ShowLogo { get; private set; } + + public bool ShowHelp { get; private set; } + + public bool ShowPedanticMessages { get; private set; } + + public string OutputFolder { get; private set; } + + public string OutputFile { get; private set; } + + public List Extensions { get; private set; } + + public List Files { get; private set; } + + public List IncludeSearchPaths { get; private set; } + + public string PreprocessFile { get; private set; } + + public Dictionary PreprocessorVariables { get; private set; } + + /// + /// Parse the commandline arguments. + /// + /// Commandline arguments. + public string[] Parse(string[] args) + { + List unprocessed = new List(); + + for (int i = 0; i < args.Length; ++i) + { + string arg = args[i]; + if (String.IsNullOrEmpty(arg)) // skip blank arguments + { + continue; + } + + if (1 == arg.Length) // treat '-' and '@' as filenames when by themselves. + { + unprocessed.Add(arg); + } + else if ('-' == arg[0] || '/' == arg[0]) + { + string parameter = arg.Substring(1); + if ('d' == parameter[0]) + { + if (1 >= parameter.Length || '=' == parameter[1]) + { + Messaging.Instance.OnMessage(WixErrors.InvalidVariableDefinition(arg)); + break; + } + + parameter = arg.Substring(2); + + string[] value = parameter.Split("=".ToCharArray(), 2); + + if (this.PreprocessorVariables.ContainsKey(value[0])) + { + Messaging.Instance.OnMessage(WixErrors.DuplicateVariableDefinition(value[0], (1 == value.Length) ? String.Empty : value[1], this.PreprocessorVariables[value[0]])); + break; + } + + if (1 == value.Length) + { + this.PreprocessorVariables.Add(value[0], String.Empty); + } + else + { + this.PreprocessorVariables.Add(value[0], value[1]); + } + } + else if ('I' == parameter[0]) + { + this.IncludeSearchPaths.Add(parameter.Substring(1)); + } + else if ("ext" == parameter) + { + if (!CommandLine.IsValidArg(args, ++i)) + { + Messaging.Instance.OnMessage(WixErrors.TypeSpecificationForExtensionRequired("-ext")); + break; + } + else + { + this.Extensions.Add(args[i]); + } + } + else if ("nologo" == parameter) + { + this.ShowLogo = false; + } + else if ("o" == parameter || "out" == parameter) + { + string path = CommandLine.GetFileOrDirectory(parameter, args, ++i); + + if (!String.IsNullOrEmpty(path)) + { + if (path.EndsWith("\\", StringComparison.Ordinal) || path.EndsWith("/", StringComparison.Ordinal)) + { + this.OutputFolder = path; + } + else + { + this.OutputFile = path; + } + } + else + { + break; + } + } + else if ("pedantic" == parameter) + { + this.ShowPedanticMessages = true; + } + else if ("arch" == parameter) + { + if (!CommandLine.IsValidArg(args, ++i)) + { + Messaging.Instance.OnMessage(WixErrors.InvalidPlatformParameter(parameter, String.Empty)); + break; + } + + if (String.Equals(args[i], "intel", StringComparison.OrdinalIgnoreCase) || String.Equals(args[i], "x86", StringComparison.OrdinalIgnoreCase)) + { + this.Platform = Platform.X86; + } + else if (String.Equals(args[i], "x64", StringComparison.OrdinalIgnoreCase)) + { + this.Platform = Platform.X64; + } + else if (String.Equals(args[i], "intel64", StringComparison.OrdinalIgnoreCase) || String.Equals(args[i], "ia64", StringComparison.OrdinalIgnoreCase)) + { + this.Platform = Platform.IA64; + } + else if (String.Equals(args[i], "arm", StringComparison.OrdinalIgnoreCase)) + { + this.Platform = Platform.ARM; + } + else + { + Messaging.Instance.OnMessage(WixErrors.InvalidPlatformParameter(parameter, args[i])); + } + } + else if ('p' == parameter[0]) + { + string file = parameter.Substring(1); + this.PreprocessFile = String.IsNullOrEmpty(file) ? "con:" : file; + } + else if (parameter.StartsWith("sw", StringComparison.Ordinal)) + { + string paramArg = parameter.Substring(2); + try + { + if (0 == paramArg.Length) + { + Messaging.Instance.SuppressAllWarnings = true; + } + else + { + int suppressWarning = Convert.ToInt32(paramArg, CultureInfo.InvariantCulture.NumberFormat); + if (0 >= suppressWarning) + { + Messaging.Instance.OnMessage(WixErrors.IllegalSuppressWarningId(paramArg)); + } + + Messaging.Instance.SuppressWarningMessage(suppressWarning); + } + } + catch (FormatException) + { + Messaging.Instance.OnMessage(WixErrors.IllegalSuppressWarningId(paramArg)); + } + catch (OverflowException) + { + Messaging.Instance.OnMessage(WixErrors.IllegalSuppressWarningId(paramArg)); + } + } + else if (parameter.StartsWith("wx", StringComparison.Ordinal)) + { + string paramArg = parameter.Substring(2); + try + { + if (0 == paramArg.Length) + { + Messaging.Instance.WarningsAsError = true; + } + else + { + int elevateWarning = Convert.ToInt32(paramArg, CultureInfo.InvariantCulture.NumberFormat); + if (0 >= elevateWarning) + { + Messaging.Instance.OnMessage(WixErrors.IllegalWarningIdAsError(paramArg)); + } + + Messaging.Instance.ElevateWarningMessage(elevateWarning); + } + } + catch (FormatException) + { + Messaging.Instance.OnMessage(WixErrors.IllegalWarningIdAsError(paramArg)); + } + catch (OverflowException) + { + Messaging.Instance.OnMessage(WixErrors.IllegalWarningIdAsError(paramArg)); + } + } + else if ("v" == parameter) + { + Messaging.Instance.ShowVerboseMessages = true; + } + else if ("?" == parameter || "help" == parameter) + { + this.ShowHelp = true; + break; + } + else + { + unprocessed.Add(arg); + } + } + else if ('@' == arg[0]) + { + string[] parsedArgs = CommandLineResponseFile.Parse(arg.Substring(1)); + string[] unparsedArgs = this.Parse(parsedArgs); + unprocessed.AddRange(unparsedArgs); + } + else + { + unprocessed.Add(arg); + } + } + + return unprocessed.ToArray(); + } + + public string[] ParsePostExtensions(string[] remaining) + { + List unprocessed = new List(); + List files = new List(); + + for (int i = 0; i < remaining.Length; ++i) + { + string arg = remaining[i]; + if (String.IsNullOrEmpty(arg)) // skip blank arguments + { + continue; + } + + if (1 < arg.Length && ('-' == arg[0] || '/' == arg[0])) + { + unprocessed.Add(arg); + } + else + { + files.AddRange(CommandLine.GetFiles(arg, "Source")); + } + } + + if (0 == files.Count) + { + this.ShowHelp = true; + } + else + { + Dictionary> sourcesForOutput = new Dictionary>(StringComparer.OrdinalIgnoreCase); + foreach (string file in files) + { + string sourceFileName = Path.GetFileName(file); + + CompileFile compileFile = new CompileFile(); + compileFile.SourcePath = Path.GetFullPath(file); + + if (null != this.OutputFile) + { + compileFile.OutputPath = this.OutputFile; + } + else if (null != this.OutputFolder) + { + compileFile.OutputPath = Path.Combine(this.OutputFolder, Path.ChangeExtension(sourceFileName, ".wixobj")); + } + else + { + compileFile.OutputPath = Path.ChangeExtension(sourceFileName, ".wixobj"); + } + + // Track which source files result in a given output file, to ensure we aren't + // overwriting the output. + List sources; + string targetPath = Path.GetFullPath(compileFile.OutputPath); + if (!sourcesForOutput.TryGetValue(targetPath, out sources)) + { + sources = new List(); + sourcesForOutput.Add(targetPath, sources); + } + + sources.Add(compileFile.SourcePath); + + this.Files.Add(compileFile); + } + + // Show an error for every output file that had more than 1 source file. + foreach (KeyValuePair> outputSources in sourcesForOutput) + { + if (1 < outputSources.Value.Count) + { + string sourceFiles = String.Join(", ", outputSources.Value); + Messaging.Instance.OnMessage(WixErrors.DuplicateSourcesForOutput(sourceFiles, outputSources.Key)); + } + } + } + + return unprocessed.ToArray(); + } + } +} diff --git a/src/candle/CandleStrings.Designer.cs b/src/candle/CandleStrings.Designer.cs new file mode 100644 index 00000000..aaf7254e --- /dev/null +++ b/src/candle/CandleStrings.Designer.cs @@ -0,0 +1,81 @@ +// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. + +namespace WixToolset.Tools { + using System; + + + /// + /// A strongly-typed resource class, for looking up localized strings, etc. + /// + // This class was auto-generated by the StronglyTypedResourceBuilder + // class via a tool like ResGen or Visual Studio. + // To add or remove a member, edit your .ResX file then rerun ResGen + // with the /str option, or rebuild your VS project. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class CandleStrings { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal CandleStrings() { + } + + /// + /// Returns the cached ResourceManager instance used by this class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("WixToolset.Tools.CandleStrings", typeof(CandleStrings).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Overrides the current thread's CurrentUICulture property for all + /// resource lookups using this strongly typed resource class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + + /// + /// Looks up a localized string similar to Cannot specify more than one source file with single output file. Either specify an output directory for the -out argument by ending the argument with a '\' or remove the -out argument to have the source files compiled to the current directory.. + /// + internal static string CannotSpecifyMoreThanOneSourceFileForSingleTargetFile { + get { + return ResourceManager.GetString("CannotSpecifyMoreThanOneSourceFileForSingleTargetFile", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to usage: candle.exe [-?] [-nologo] [-out outputFile] sourceFile [sourceFile ...] [@responseFile] + /// + /// -arch set architecture defaults for package, components, etc. + /// values: x86, x64, or ia64 (default: x86) + /// -d<name>[=<value>] define a parameter for the preprocessor + /// -ext <extension> extension assembly or "class, assembly" + /// -I<dir> add to include search path + /// -nologo skip printing candle logo information + /// -o[ut] s [rest of string was truncated]";. + /// + internal static string HelpMessage { + get { + return ResourceManager.GetString("HelpMessage", resourceCulture); + } + } + } +} diff --git a/src/candle/CandleStrings.resx b/src/candle/CandleStrings.resx new file mode 100644 index 00000000..d77788ca --- /dev/null +++ b/src/candle/CandleStrings.resx @@ -0,0 +1,142 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Cannot specify more than one source file with single output file. Either specify an output directory for the -out argument by ending the argument with a '\' or remove the -out argument to have the source files compiled to the current directory. + + + usage: candle.exe [-?] [-nologo] [-out outputFile] sourceFile [sourceFile ...] [@responseFile] + + -arch set architecture defaults for package, components, etc. + values: x86, x64, ia64 or arm (default: x86) + -d<name>[=<value>] define a parameter for the preprocessor + -ext <extension> extension assembly or "class, assembly" + -I<dir> add to include search path + -nologo skip printing candle logo information + -o[ut] specify output file (default: write to current directory) + -p<file> preprocess to a file (or stdout if no file supplied) + -pedantic show pedantic messages + -sw[N] suppress all warnings or a specific message ID + (example: -sw1009 -sw1103) + -v verbose output + -wx[N] treat all warnings or a specific message ID as an error + (example: -wx1009 -wx1103) + -? | -help this help information + + \ No newline at end of file diff --git a/src/candle/CompileFile.cs b/src/candle/CompileFile.cs new file mode 100644 index 00000000..682acc21 --- /dev/null +++ b/src/candle/CompileFile.cs @@ -0,0 +1,20 @@ +// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. + +namespace WixToolset.Tools +{ + /// + /// Source code file to be compiled. + /// + public class CompileFile + { + /// + /// Path to the source code file. + /// + public string SourcePath { get; set; } + + /// + /// Path to compile the output to. + /// + public string OutputPath { get; set; } + } +} diff --git a/src/candle/app.config b/src/candle/app.config new file mode 100644 index 00000000..71c529fb --- /dev/null +++ b/src/candle/app.config @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/src/candle/candle.cs b/src/candle/candle.cs new file mode 100644 index 00000000..f5c65cb1 --- /dev/null +++ b/src/candle/candle.cs @@ -0,0 +1,200 @@ +// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. + +namespace WixToolset.Tools +{ + using System; + using System.Collections.Generic; + using System.IO; + using System.Linq; + using System.Runtime.InteropServices; + using System.Xml.Linq; + using WixToolset.Data; + using WixToolset.Extensibility; + + /// + /// The main entry point for candle. + /// + public sealed class Candle + { + private CandleCommandLine commandLine; + + private IEnumerable preprocessorExtensions; + private IEnumerable compilerExtensions; + private IEnumerable extensionData; + + /// + /// The main entry point for candle. + /// + /// Commandline arguments for the application. + /// Returns the application error code. + [MTAThread] + public static int Main(string[] args) + { + AppCommon.PrepareConsoleForLocalization(); + Messaging.Instance.InitializeAppName("CNDL", "candle.exe").Display += AppCommon.ConsoleDisplayMessage; + + Candle candle = new Candle(); + return candle.Execute(args); + } + + private int Execute(string[] args) + { + try + { + string[] unparsed = this.ParseCommandLineAndLoadExtensions(args); + + if (!Messaging.Instance.EncounteredError) + { + if (this.commandLine.ShowLogo) + { + AppCommon.DisplayToolHeader(); + } + + if (this.commandLine.ShowHelp) + { + Console.WriteLine(CandleStrings.HelpMessage); + AppCommon.DisplayToolFooter(); + } + else + { + foreach (string arg in unparsed) + { + Messaging.Instance.OnMessage(WixWarnings.UnsupportedCommandLineArgument(arg)); + } + + this.Run(); + } + } + } + catch (WixException we) + { + Messaging.Instance.OnMessage(we.Error); + } + catch (Exception e) + { + Messaging.Instance.OnMessage(WixErrors.UnexpectedException(e.Message, e.GetType().ToString(), e.StackTrace)); + if (e is NullReferenceException || e is SEHException) + { + throw; + } + } + + return Messaging.Instance.LastErrorNumber; + } + + private string[] ParseCommandLineAndLoadExtensions(string[] args) + { + this.commandLine = new CandleCommandLine(); + string[] unprocessed = commandLine.Parse(args); + if (Messaging.Instance.EncounteredError) + { + return unprocessed; + } + + // Load extensions. + ExtensionManager extensionManager = new ExtensionManager(); + foreach (string extension in this.commandLine.Extensions) + { + extensionManager.Load(extension); + } + + // Preprocessor extension command line processing. + this.preprocessorExtensions = extensionManager.Create(); + foreach (IExtensionCommandLine pce in this.preprocessorExtensions.Where(e => e is IExtensionCommandLine).Cast()) + { + pce.MessageHandler = Messaging.Instance; + unprocessed = pce.ParseCommandLine(unprocessed); + } + + // Compiler extension command line processing. + this.compilerExtensions = extensionManager.Create(); + foreach (IExtensionCommandLine cce in this.compilerExtensions.Where(e => e is IExtensionCommandLine).Cast()) + { + cce.MessageHandler = Messaging.Instance; + unprocessed = cce.ParseCommandLine(unprocessed); + } + + // Extension data command line processing. + this.extensionData = extensionManager.Create(); + foreach (IExtensionCommandLine dce in this.extensionData.Where(e => e is IExtensionCommandLine).Cast()) + { + dce.MessageHandler = Messaging.Instance; + unprocessed = dce.ParseCommandLine(unprocessed); + } + + return commandLine.ParsePostExtensions(unprocessed); + } + + private void Run() + { + // Create the preprocessor and compiler + Preprocessor preprocessor = new Preprocessor(); + preprocessor.CurrentPlatform = this.commandLine.Platform; + + foreach (string includePath in this.commandLine.IncludeSearchPaths) + { + preprocessor.IncludeSearchPaths.Add(includePath); + } + + foreach (IPreprocessorExtension pe in this.preprocessorExtensions) + { + preprocessor.AddExtension(pe); + } + + Compiler compiler = new Compiler(); + compiler.ShowPedanticMessages = this.commandLine.ShowPedanticMessages; + compiler.CurrentPlatform = this.commandLine.Platform; + + foreach (IExtensionData ed in this.extensionData) + { + compiler.AddExtensionData(ed); + } + + foreach (ICompilerExtension ce in this.compilerExtensions) + { + compiler.AddExtension(ce); + } + + // Preprocess then compile each source file. + foreach (CompileFile file in this.commandLine.Files) + { + // print friendly message saying what file is being compiled + Console.WriteLine(file.SourcePath); + + // preprocess the source + XDocument sourceDocument; + try + { + if (!String.IsNullOrEmpty(this.commandLine.PreprocessFile)) + { + preprocessor.PreprocessOut = this.commandLine.PreprocessFile.Equals("con:", StringComparison.OrdinalIgnoreCase) ? Console.Out : new StreamWriter(this.commandLine.PreprocessFile); + } + + sourceDocument = preprocessor.Process(file.SourcePath, this.commandLine.PreprocessorVariables); + } + finally + { + if (null != preprocessor.PreprocessOut && Console.Out != preprocessor.PreprocessOut) + { + preprocessor.PreprocessOut.Close(); + } + } + + // If we're not actually going to compile anything, move on to the next file. + if (null == sourceDocument || !String.IsNullOrEmpty(this.commandLine.PreprocessFile)) + { + continue; + } + + // and now we do what we came here to do... + Intermediate intermediate = compiler.Compile(sourceDocument); + + // save the intermediate to disk if no errors were found for this source file + if (null != intermediate) + { + intermediate.Save(file.OutputPath); + } + } + } + } +} diff --git a/src/candle/candle.csproj b/src/candle/candle.csproj new file mode 100644 index 00000000..cea0cf62 --- /dev/null +++ b/src/candle/candle.csproj @@ -0,0 +1,62 @@ + + + + + + + {956401A5-3C04-4786-9611-B2AEC6207686} + candle + Exe + WixToolset.Tools + x86 + + + + + + + + True + True + CandleStrings.resx + + + + + + + + + + + Designer + ResXFileCodeGenerator + CandleStrings.Designer.cs + + + + + + + + + + {6a98499e-40ec-4335-9c31-96a2511d47c6} + WixToolset.Data + + + {eee88c2a-45a0-4e48-a40a-431a4ba458d8} + WixToolset.Extensibility + + + {4B2BD779-59F7-4BF1-871C-A75952BCA749} + wconsole + + + {9E03A94C-C70E-45C6-A269-E737BBD8B319} + Wix + + + + + diff --git a/src/candle/candle.exe.manifest b/src/candle/candle.exe.manifest new file mode 100644 index 00000000..b05ab18b --- /dev/null +++ b/src/candle/candle.exe.manifest @@ -0,0 +1,9 @@ + + + + + + + WiX Toolset Compiler + + diff --git a/src/candle/candle.rc b/src/candle/candle.rc new file mode 100644 index 00000000..47864811 --- /dev/null +++ b/src/candle/candle.rc @@ -0,0 +1,10 @@ +// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information. + +#define VER_APP +#define VER_ORIGINAL_FILENAME "candle.exe" +#define VER_INTERNAL_NAME "candle" +#define VER_FILE_DESCRIPTION "WiX Toolset Compiler" +#include "wix.rc" + +#define MANIFEST_RESOURCE_ID 1 +MANIFEST_RESOURCE_ID RT_MANIFEST "candle.exe.manifest" -- cgit v1.2.3-55-g6feb