Initial code commit

11 files changed, 887 insertions, 0 deletions

diff --git a/src/candle/App.ico b/src/candle/App.ico
new file mode 100644
index 00000000..3a5525fd
--- /dev/null
+++ b/src/candle/App.ico
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;
+
+    /// <summary>
+    /// Parse command line for candle.
+    /// </summary>
+    public class CandleCommandLine
+    {
+        public CandleCommandLine()
+        {
+            this.Platform = Platform.X86;
+
+            this.ShowLogo = true;
+            this.Extensions = new List<string>();
+            this.Files = new List<CompileFile>();
+            this.IncludeSearchPaths = new List<string>();
+            this.PreprocessorVariables = new Dictionary<string, string>();
+        }
+
+        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<string> Extensions { get; private set; }
+
+        public List<CompileFile> Files { get; private set; }
+
+        public List<string> IncludeSearchPaths { get; private set; }
+
+        public string PreprocessFile { get; private set; }
+
+        public Dictionary<string, string> PreprocessorVariables { get; private set; }
+
+        /// <summary>
+        /// Parse the commandline arguments.
+        /// </summary>
+        /// <param name="args">Commandline arguments.</param>
+        public string[] Parse(string[] args)
+        {
+            List<string> unprocessed = new List<string>();
+
+            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<string> unprocessed = new List<string>();
+            List<string> files = new List<string>();
+
+            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<string, List<string>> sourcesForOutput = new Dictionary<string, List<string>>(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<string> sources;
+                    string targetPath = Path.GetFullPath(compileFile.OutputPath);
+                    if (!sourcesForOutput.TryGetValue(targetPath, out sources))
+                    {
+                        sources = new List<string>();
+                        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<string, List<string>> 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;
+    
+    
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // 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() {
+        }
+        
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [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;
+            }
+        }
+        
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+        
+        /// <summary>
+        ///   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 &apos;\&apos; or remove the -out argument to have the source files compiled to the current directory..
+        /// </summary>
+        internal static string CannotSpecifyMoreThanOneSourceFileForSingleTargetFile {
+            get {
+                return ResourceManager.GetString("CannotSpecifyMoreThanOneSourceFileForSingleTargetFile", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   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&lt;name&gt;[=&lt;value&gt;]  define a parameter for the preprocessor
+        ///   -ext &lt;extension&gt;  extension assembly or &quot;class, assembly&quot;
+        ///   -I&lt;dir&gt;    add to include search path
+        ///   -nologo    skip printing candle logo information
+        ///   -o[ut]     s [rest of string was truncated]&quot;;.
+        /// </summary>
+        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 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="CannotSpecifyMoreThanOneSourceFileForSingleTargetFile" xml:space="preserve">
+    <value>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.</value>
+  </data>
+  <data name="HelpMessage" xml:space="preserve">
+    <value> 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&lt;name&gt;[=&lt;value&gt;]  define a parameter for the preprocessor
+   -ext &lt;extension&gt;  extension assembly or "class, assembly"
+   -I&lt;dir&gt;    add to include search path
+   -nologo    skip printing candle logo information
+   -o[ut]     specify output file (default: write to current directory)
+   -p&lt;file&gt;   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</value>
+  </data>
+</root>
\ 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
+{
+    /// <summary>
+    /// Source code file to be compiled.
+    /// </summary>
+    public class CompileFile
+    {
+        /// <summary>
+        /// Path to the source code file.
+        /// </summary>
+        public string SourcePath { get; set; }
+
+        /// <summary>
+        /// Path to compile the output to.
+        /// </summary>
+        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 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!-- 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. -->
+
+
+<configuration>
+    <runtime>
+        <loadFromRemoteSources enabled="true"/>
+    </runtime>
+</configuration>
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;
+
+    /// <summary>
+    /// The main entry point for candle.
+    /// </summary>
+    public sealed class Candle
+    {
+        private CandleCommandLine commandLine;
+
+        private IEnumerable<IPreprocessorExtension> preprocessorExtensions;
+        private IEnumerable<ICompilerExtension> compilerExtensions;
+        private IEnumerable<IExtensionData> extensionData;
+
+        /// <summary>
+        /// The main entry point for candle.
+        /// </summary>
+        /// <param name="args">Commandline arguments for the application.</param>
+        /// <returns>Returns the application error code.</returns>
+        [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<IPreprocessorExtension>();
+            foreach (IExtensionCommandLine pce in this.preprocessorExtensions.Where(e => e is IExtensionCommandLine).Cast<IExtensionCommandLine>())
+            {
+                pce.MessageHandler = Messaging.Instance;
+                unprocessed = pce.ParseCommandLine(unprocessed);
+            }
+
+            // Compiler extension command line processing.
+            this.compilerExtensions = extensionManager.Create<ICompilerExtension>();
+            foreach (IExtensionCommandLine cce in this.compilerExtensions.Where(e => e is IExtensionCommandLine).Cast<IExtensionCommandLine>())
+            {
+                cce.MessageHandler = Messaging.Instance;
+                unprocessed = cce.ParseCommandLine(unprocessed);
+            }
+
+            // Extension data command line processing.
+            this.extensionData = extensionManager.Create<IExtensionData>();
+            foreach (IExtensionCommandLine dce in this.extensionData.Where(e => e is IExtensionCommandLine).Cast<IExtensionCommandLine>())
+            {
+                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 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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. -->
+
+
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
+  <PropertyGroup>
+    <ProjectGuid>{956401A5-3C04-4786-9611-B2AEC6207686}</ProjectGuid>
+    <AssemblyName>candle</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <RootNamespace>WixToolset.Tools</RootNamespace>
+    <PlatformTarget>x86</PlatformTarget>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="AssemblyInfo.cs" />
+    <Compile Include="candle.cs" />
+    <Compile Include="CandleCommandLine.cs" />
+    <Compile Include="CompileFile.cs" />
+    <Compile Include="CandleStrings.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>CandleStrings.resx</DependentUpon>
+    </Compile>
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedNativeResource Include="candle.rc" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="app.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="CandleStrings.resx">
+      <SubType>Designer</SubType>
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>CandleStrings.Designer.cs</LastGenOutput>
+    </EmbeddedResource>
+  </ItemGroup>
+  <ItemGroup>
+    <Service Include="{B4F97281-0DBD-4835-9ED8-7DFB966E87FF}" />
+  </ItemGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Xml" />
+    <ProjectReference Include="..\..\libs\WixToolset.Data\WixToolset.Data.csproj">
+      <Project>{6a98499e-40ec-4335-9c31-96a2511d47c6}</Project>
+      <Name>WixToolset.Data</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\libs\WixToolset.Extensibility\WixToolset.Extensibility.csproj">
+      <Project>{eee88c2a-45a0-4e48-a40a-431a4ba458d8}</Project>
+      <Name>WixToolset.Extensibility</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\wconsole\wconsole.csproj">
+      <Project>{4B2BD779-59F7-4BF1-871C-A75952BCA749}</Project>
+      <Name>wconsole</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\wix\Wix.csproj">
+      <Project>{9E03A94C-C70E-45C6-A269-E737BBD8B319}</Project>
+      <Name>Wix</Name>
+    </ProjectReference>
+    <Reference Include="System.Xml.Linq" />
+  </ItemGroup>
+  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildProjectDirectory), wix.proj))\tools\WixBuild.targets" />
+</Project>
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 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<!-- 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. -->
+
+
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0"> 
+ <assemblyIdentity name="WixToolset.Tools.Candle" version="2.0.0.0" processorArchitecture="x86" type="win32"/> 
+ <description>WiX Toolset Compiler</description> 
+ <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3"><security><requestedPrivileges><requestedExecutionLevel level="asInvoker" uiAccess="false"/></requestedPrivileges></security></trustInfo>
+</assembly>
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"