Initial code commit

3 files changed, 2268 insertions, 0 deletions

diff --git a/src/WixToolset.Core/Preprocess/IfContext.cs b/src/WixToolset.Core/Preprocess/IfContext.cs
new file mode 100644
index 00000000..64b5bd91
--- /dev/null
+++ b/src/WixToolset.Core/Preprocess/IfContext.cs
@@ -0,0 +1,110 @@
+// 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.Preprocess
+{
+    using System;
+
+    /// <summary>
+    /// Current state of the if context.
+    /// </summary>
+    internal enum IfState
+    {
+        /// <summary>Context currently in unknown state.</summary>
+        Unknown,
+
+        /// <summary>Context currently inside if statement.</summary>
+        If,
+
+        /// <summary>Context currently inside elseif statement..</summary>
+        ElseIf,
+
+        /// <summary>Conext currently inside else statement.</summary>
+        Else,
+    }
+
+    /// <summary>
+    /// Context for an if statement in the preprocessor.
+    /// </summary>
+    internal sealed class IfContext
+    {
+        private bool active;
+        private bool keep;
+        private bool everKept;
+        private IfState state;
+
+        /// <summary>
+        /// Creates a default if context object, which are used for if's within an inactive preprocessor block
+        /// </summary>
+        public IfContext()
+        {
+            this.active = false;
+            this.keep = false;
+            this.everKept = true;
+            this.state = IfState.If;
+        }
+
+        /// <summary>
+        /// Creates an if context object.
+        /// </summary>
+        /// <param name="active">Flag if context is currently active.</param>
+        /// <param name="keep">Flag if context is currently true.</param>
+        /// <param name="state">State of context to start in.</param>
+        public IfContext(bool active, bool keep, IfState state)
+        {
+            this.active = active;
+            this.keep = keep;
+            this.everKept = keep;
+            this.state = state;
+        }
+
+        /// <summary>
+        /// Gets and sets if this if context is currently active.
+        /// </summary>
+        /// <value>true if context is active.</value>
+        public bool Active
+        {
+            get { return this.active; }
+            set { this.active = value; }
+        }
+
+        /// <summary>
+        /// Gets and sets if context is current true.
+        /// </summary>
+        /// <value>true if context is currently true.</value>
+        public bool IsTrue
+        {
+            get
+            {
+                return this.keep;
+            }
+
+            set
+            {
+                this.keep = value;
+                if (this.keep)
+                {
+                    this.everKept = true;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets if the context was ever true.
+        /// </summary>
+        /// <value>True if context was ever true.</value>
+        public bool WasEverTrue
+        {
+            get { return this.everKept; }
+        }
+
+        /// <summary>
+        /// Gets the current state of the if context.
+        /// </summary>
+        /// <value>Current state of context.</value>
+        public IfState IfState
+        {
+            get { return this.state; }
+            set { this.state = value; }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Preprocessor.cs b/src/WixToolset.Core/Preprocessor.cs
new file mode 100644
index 00000000..a9fbcbb7
--- /dev/null
+++ b/src/WixToolset.Core/Preprocessor.cs
@@ -0,0 +1,1598 @@
+// 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
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Globalization;
+    using System.IO;
+    using System.Text;
+    using System.Text.RegularExpressions;
+    using System.Xml;
+    using System.Xml.Linq;
+    using WixToolset.Data;
+    using WixToolset.Extensibility;
+    using WixToolset.Preprocess;
+
+    /// <summary>
+    /// Preprocessor object
+    /// </summary>
+    public sealed class Preprocessor
+    {
+        private readonly Regex defineRegex = new Regex(@"^\s*(?<varName>.+?)\s*(=\s*(?<varValue>.+?)\s*)?$", RegexOptions.Compiled | RegexOptions.Singleline | RegexOptions.ExplicitCapture);
+        private readonly Regex pragmaRegex = new Regex(@"^\s*(?<pragmaName>.+?)(?<pragmaValue>[\s\(].+?)?$", RegexOptions.Compiled | RegexOptions.Singleline | RegexOptions.ExplicitCapture);
+
+        private readonly XmlReaderSettings DocumentXmlReaderSettings = new XmlReaderSettings()
+        {
+            ValidationFlags = System.Xml.Schema.XmlSchemaValidationFlags.None,
+            XmlResolver = null,
+        };
+        private readonly XmlReaderSettings FragmentXmlReaderSettings = new XmlReaderSettings()
+        {
+            ConformanceLevel = System.Xml.ConformanceLevel.Fragment,
+            ValidationFlags = System.Xml.Schema.XmlSchemaValidationFlags.None,
+            XmlResolver = null,
+        };
+
+        private List<IPreprocessorExtension> extensions;
+        private Dictionary<string, IPreprocessorExtension> extensionsByPrefix;
+        private List<InspectorExtension> inspectorExtensions;
+
+        private SourceLineNumber currentLineNumber;
+        private Stack<SourceLineNumber> sourceStack;
+
+        private PreprocessorCore core;
+        private TextWriter preprocessOut;
+
+        private Stack<bool> includeNextStack;
+        private Stack<string> currentFileStack;
+
+        private Platform currentPlatform;
+
+        /// <summary>
+        /// Creates a new preprocesor.
+        /// </summary>
+        public Preprocessor()
+        {
+            this.IncludeSearchPaths = new List<string>();
+
+            this.extensions = new List<IPreprocessorExtension>();
+            this.extensionsByPrefix = new Dictionary<string, IPreprocessorExtension>();
+            this.inspectorExtensions = new List<InspectorExtension>();
+
+            this.sourceStack = new Stack<SourceLineNumber>();
+
+            this.includeNextStack = new Stack<bool>();
+            this.currentFileStack = new Stack<string>();
+
+            this.currentPlatform = Platform.X86;
+        }
+
+        /// <summary>
+        /// Event for ifdef/ifndef directives.
+        /// </summary>
+        public event IfDefEventHandler IfDef;
+
+        /// <summary>
+        /// Event for included files.
+        /// </summary>
+        public event IncludedFileEventHandler IncludedFile;
+
+        /// <summary>
+        /// Event for preprocessed stream.
+        /// </summary>
+        public event ProcessedStreamEventHandler ProcessedStream;
+
+        /// <summary>
+        /// Event for resolved variables.
+        /// </summary>
+        public event ResolvedVariableEventHandler ResolvedVariable;
+
+        /// <summary>
+        /// Enumeration for preprocessor operations in if statements.
+        /// </summary>
+        private enum PreprocessorOperation
+        {
+            /// <summary>The and operator.</summary>
+            And,
+
+            /// <summary>The or operator.</summary>
+            Or,
+
+            /// <summary>The not operator.</summary>
+            Not
+        }
+
+        /// <summary>
+        /// Gets or sets the platform which the compiler will use when defaulting 64-bit attributes and elements.
+        /// </summary>
+        /// <value>The platform which the compiler will use when defaulting 64-bit attributes and elements.</value>
+        public Platform CurrentPlatform
+        {
+            get { return this.currentPlatform; }
+            set { this.currentPlatform = value; }
+        }
+
+        /// <summary>
+        /// Ordered list of search paths that the precompiler uses to find included files.
+        /// </summary>
+        /// <value>List of ordered search paths to use during precompiling.</value>
+        public IList<string> IncludeSearchPaths { get; private set; }
+
+        /// <summary>
+        /// Specifies the text stream to display the postprocessed data to.
+        /// </summary>
+        /// <value>TextWriter to write preprocessed xml to.</value>
+        public TextWriter PreprocessOut
+        {
+            get { return this.preprocessOut; }
+            set { this.preprocessOut = value; }
+        }
+
+        /// <summary>
+        /// Get the source line information for the current element.  The precompiler will insert
+        /// special source line number processing instructions before each element that it
+        /// encounters.  This is where those line numbers are read and processed.  This function
+        /// may return an array of source line numbers because the element may have come from
+        /// an included file, in which case the chain of imports is expressed in the array.
+        /// </summary>
+        /// <param name="node">Element to get source line information for.</param>
+        /// <returns>Returns the stack of imports used to author the element being processed.</returns>
+        [SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes")]
+        public static SourceLineNumber GetSourceLineNumbers(XmlNode node)
+        {
+            return null;
+        }
+
+        /// <summary>
+        /// Get the source line information for the current element.  The precompiler will insert
+        /// special source line number information for each element that it encounters.
+        /// </summary>
+        /// <param name="node">Element to get source line information for.</param>
+        /// <returns>
+        /// The source line number used to author the element being processed or
+        /// null if the preprocessor did not process the element or the node is
+        /// not an element.
+        /// </returns>
+        public static SourceLineNumber GetSourceLineNumbers(XObject node)
+        {
+            return SourceLineNumber.GetFromXAnnotation(node);
+        }
+
+        /// <summary>
+        /// Adds an extension.
+        /// </summary>
+        /// <param name="extension">The extension to add.</param>
+        public void AddExtension(IPreprocessorExtension extension)
+        {
+            this.extensions.Add(extension);
+
+            if (null != extension.Prefixes)
+            {
+                foreach (string prefix in extension.Prefixes)
+                {
+                    IPreprocessorExtension collidingExtension;
+                    if (!this.extensionsByPrefix.TryGetValue(prefix, out collidingExtension))
+                    {
+                        this.extensionsByPrefix.Add(prefix, extension);
+                    }
+                    else
+                    {
+                        Messaging.Instance.OnMessage(WixErrors.DuplicateExtensionPreprocessorType(extension.GetType().ToString(), prefix, collidingExtension.GetType().ToString()));
+                    }
+                }
+            }
+
+            //if (null != extension.InspectorExtension)
+            //{
+            //    this.inspectorExtensions.Add(extension.InspectorExtension);
+            //}
+        }
+
+        /// <summary>
+        /// Preprocesses a file.
+        /// </summary>
+        /// <param name="sourceFile">The file to preprocess.</param>
+        /// <param name="variables">The variables defined prior to preprocessing.</param>
+        /// <returns>XDocument with the postprocessed data.</returns>
+        [SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes")]
+        public XDocument Process(string sourceFile, IDictionary<string, string> variables)
+        {
+            using (Stream sourceStream = new FileStream(sourceFile, FileMode.Open, FileAccess.Read, FileShare.Read))
+            {
+                InspectorCore inspectorCore = new InspectorCore();
+                foreach (InspectorExtension inspectorExtension in this.inspectorExtensions)
+                {
+                    inspectorExtension.Core = inspectorCore;
+                    inspectorExtension.InspectSource(sourceStream);
+
+                    // reset
+                    inspectorExtension.Core = null;
+                    sourceStream.Position = 0;
+                }
+
+                if (inspectorCore.EncounteredError)
+                {
+                    return null;
+                }
+
+                using (XmlReader reader = XmlReader.Create(sourceFile, DocumentXmlReaderSettings))
+                {
+                    return Process(reader, variables, sourceFile);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Preprocesses a file.
+        /// </summary>
+        /// <param name="sourceFile">The file to preprocess.</param>
+        /// <param name="variables">The variables defined prior to preprocessing.</param>
+        /// <returns>XDocument with the postprocessed data.</returns>
+        [SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes")]
+        public XDocument Process(XmlReader reader, IDictionary<string, string> variables, string sourceFile = null)
+        {
+            if (String.IsNullOrEmpty(sourceFile) && !String.IsNullOrEmpty(reader.BaseURI))
+            {
+                Uri uri = new Uri(reader.BaseURI);
+                sourceFile = uri.AbsolutePath;
+            }
+
+            this.core = new PreprocessorCore(this.extensionsByPrefix, sourceFile, variables);
+            this.core.ResolvedVariableHandler = this.ResolvedVariable;
+            this.core.CurrentPlatform = this.currentPlatform;
+            this.currentLineNumber = new SourceLineNumber(sourceFile);
+            this.currentFileStack.Clear();
+            this.currentFileStack.Push(this.core.GetVariableValue(this.currentLineNumber, "sys", "SOURCEFILEDIR"));
+
+            // Process the reader into the output.
+            XDocument output = new XDocument();
+            try
+            {
+                foreach (PreprocessorExtension extension in this.extensions)
+                {
+                    extension.Core = this.core;
+                    extension.Initialize();
+                }
+
+                this.PreprocessReader(false, reader, output, 0);
+            }
+            catch (XmlException e)
+            {
+                this.UpdateCurrentLineNumber(reader, 0);
+                throw new WixException(WixErrors.InvalidXml(this.currentLineNumber, "source", e.Message));
+            }
+
+            // Fire event with post-processed document.
+            ProcessedStreamEventArgs args = new ProcessedStreamEventArgs(sourceFile, output);
+            this.OnProcessedStream(args);
+
+            // preprocess the generated XML Document
+            foreach (PreprocessorExtension extension in this.extensions)
+            {
+                extension.PreprocessDocument(output);
+            }
+
+            // finalize the preprocessing
+            foreach (PreprocessorExtension extension in this.extensions)
+            {
+                extension.Finish();
+                extension.Core = null;
+            }
+
+            if (this.core.EncounteredError)
+            {
+                return null;
+            }
+            else
+            {
+                if (null != this.preprocessOut)
+                {
+                    output.Save(this.preprocessOut);
+                    this.preprocessOut.Flush();
+                }
+
+                return output;
+            }
+        }
+
+        /// <summary>
+        /// Determins if string is an operator.
+        /// </summary>
+        /// <param name="operation">String to check.</param>
+        /// <returns>true if string is an operator.</returns>
+        private static bool IsOperator(string operation)
+        {
+            if (operation == null)
+            {
+                return false;
+            }
+
+            operation = operation.Trim();
+            if (0 == operation.Length)
+            {
+                return false;
+            }
+
+            if ("=" == operation ||
+                "!=" == operation ||
+                "<" == operation ||
+                "<=" == operation ||
+                ">" == operation ||
+                ">=" == operation ||
+                "~=" == operation)
+            {
+                return true;
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Determines if expression is currently inside quotes.
+        /// </summary>
+        /// <param name="expression">Expression to evaluate.</param>
+        /// <param name="index">Index to start searching in expression.</param>
+        /// <returns>true if expression is inside in quotes.</returns>
+        private static bool InsideQuotes(string expression, int index)
+        {
+            if (index == -1)
+            {
+                return false;
+            }
+
+            int numQuotes = 0;
+            int tmpIndex = 0;
+            while (-1 != (tmpIndex = expression.IndexOf('\"', tmpIndex, index - tmpIndex)))
+            {
+                numQuotes++;
+                tmpIndex++;
+            }
+
+            // found an even number of quotes before the index, so we're not inside
+            if (numQuotes % 2 == 0)
+            {
+                return false;
+            }
+
+            // found an odd number of quotes, so we are inside
+            return true;
+        }
+
+        /// <summary>
+        /// Fires an event when an ifdef/ifndef directive is processed.
+        /// </summary>
+        /// <param name="ea">ifdef/ifndef event arguments.</param>
+        private void OnIfDef(IfDefEventArgs ea)
+        {
+            if (null != this.IfDef)
+            {
+                this.IfDef(this, ea);
+            }
+        }
+
+        /// <summary>
+        /// Fires an event when an included file is processed.
+        /// </summary>
+        /// <param name="ea">Included file event arguments.</param>
+        private void OnIncludedFile(IncludedFileEventArgs ea)
+        {
+            if (null != this.IncludedFile)
+            {
+                this.IncludedFile(this, ea);
+            }
+        }
+
+        /// <summary>
+        /// Fires an event after the file is preprocessed.
+        /// </summary>
+        /// <param name="ea">Included file event arguments.</param>
+        private void OnProcessedStream(ProcessedStreamEventArgs ea)
+        {
+            if (null != this.ProcessedStream)
+            {
+                this.ProcessedStream(this, ea);
+            }
+        }
+
+        /// <summary>
+        /// Tests expression to see if it starts with a keyword.
+        /// </summary>
+        /// <param name="expression">Expression to test.</param>
+        /// <param name="operation">Operation to test for.</param>
+        /// <returns>true if expression starts with a keyword.</returns>
+        private static bool StartsWithKeyword(string expression, PreprocessorOperation operation)
+        {
+            expression = expression.ToUpper(CultureInfo.InvariantCulture);
+            switch (operation)
+            {
+                case PreprocessorOperation.Not:
+                    if (expression.StartsWith("NOT ", StringComparison.Ordinal) || expression.StartsWith("NOT(", StringComparison.Ordinal))
+                    {
+                        return true;
+                    }
+                    break;
+                case PreprocessorOperation.And:
+                    if (expression.StartsWith("AND ", StringComparison.Ordinal) || expression.StartsWith("AND(", StringComparison.Ordinal))
+                    {
+                        return true;
+                    }
+                    break;
+                case PreprocessorOperation.Or:
+                    if (expression.StartsWith("OR ", StringComparison.Ordinal) || expression.StartsWith("OR(", StringComparison.Ordinal))
+                    {
+                        return true;
+                    }
+                    break;
+                default:
+                    break;
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Processes an xml reader into an xml writer.
+        /// </summary>
+        /// <param name="include">Specifies if reader is from an included file.</param>
+        /// <param name="reader">Reader for the source document.</param>
+        /// <param name="container">Node where content should be added.</param>
+        /// <param name="offset">Original offset for the line numbers being processed.</param>
+        private void PreprocessReader(bool include, XmlReader reader, XContainer container, int offset)
+        {
+            XContainer currentContainer = container;
+            Stack<XContainer> containerStack = new Stack<XContainer>();
+
+            IfContext ifContext = new IfContext(true, true, IfState.Unknown); // start by assuming we want to keep the nodes in the source code
+            Stack<IfContext> ifStack = new Stack<IfContext>();
+
+            // process the reader into the writer
+            while (reader.Read())
+            {
+                // update information here in case an error occurs before the next read
+                this.UpdateCurrentLineNumber(reader, offset);
+
+                SourceLineNumber sourceLineNumbers = this.currentLineNumber;
+
+                // check for changes in conditional processing
+                if (XmlNodeType.ProcessingInstruction == reader.NodeType)
+                {
+                    bool ignore = false;
+                    string name = null;
+
+                    switch (reader.LocalName)
+                    {
+                        case "if":
+                            ifStack.Push(ifContext);
+                            if (ifContext.IsTrue)
+                            {
+                                ifContext = new IfContext(ifContext.IsTrue & ifContext.Active, this.EvaluateExpression(reader.Value), IfState.If);
+                            }
+                            else // Use a default IfContext object so we don't try to evaluate the expression if the context isn't true
+                            {
+                                ifContext = new IfContext();
+                            }
+                            ignore = true;
+                            break;
+
+                        case "ifdef":
+                            ifStack.Push(ifContext);
+                            name = reader.Value.Trim();
+                            if (ifContext.IsTrue)
+                            {
+                                ifContext = new IfContext(ifContext.IsTrue & ifContext.Active, (null != this.core.GetVariableValue(sourceLineNumbers, name, true)), IfState.If);
+                            }
+                            else // Use a default IfContext object so we don't try to evaluate the expression if the context isn't true
+                            {
+                                ifContext = new IfContext();
+                            }
+                            ignore = true;
+                            OnIfDef(new IfDefEventArgs(sourceLineNumbers, true, ifContext.IsTrue, name));
+                            break;
+
+                        case "ifndef":
+                            ifStack.Push(ifContext);
+                            name = reader.Value.Trim();
+                            if (ifContext.IsTrue)
+                            {
+                                ifContext = new IfContext(ifContext.IsTrue & ifContext.Active, (null == this.core.GetVariableValue(sourceLineNumbers, name, true)), IfState.If);
+                            }
+                            else // Use a default IfContext object so we don't try to evaluate the expression if the context isn't true
+                            {
+                                ifContext = new IfContext();
+                            }
+                            ignore = true;
+                            OnIfDef(new IfDefEventArgs(sourceLineNumbers, false, !ifContext.IsTrue, name));
+                            break;
+
+                        case "elseif":
+                            if (0 == ifStack.Count)
+                            {
+                                throw new WixException(WixErrors.UnmatchedPreprocessorInstruction(this.currentLineNumber, "if", "elseif"));
+                            }
+
+                            if (IfState.If != ifContext.IfState && IfState.ElseIf != ifContext.IfState)
+                            {
+                                throw new WixException(WixErrors.UnmatchedPreprocessorInstruction(this.currentLineNumber, "if", "elseif"));
+                            }
+
+                            ifContext.IfState = IfState.ElseIf;   // we're now in an elseif
+                            if (!ifContext.WasEverTrue)   // if we've never evaluated the if context to true, then we can try this test
+                            {
+                                ifContext.IsTrue = this.EvaluateExpression(reader.Value);
+                            }
+                            else if (ifContext.IsTrue)
+                            {
+                                ifContext.IsTrue = false;
+                            }
+                            ignore = true;
+                            break;
+
+                        case "else":
+                            if (0 == ifStack.Count)
+                            {
+                                throw new WixException(WixErrors.UnmatchedPreprocessorInstruction(this.currentLineNumber, "if", "else"));
+                            }
+
+                            if (IfState.If != ifContext.IfState && IfState.ElseIf != ifContext.IfState)
+                            {
+                                throw new WixException(WixErrors.UnmatchedPreprocessorInstruction(this.currentLineNumber, "if", "else"));
+                            }
+
+                            ifContext.IfState = IfState.Else;   // we're now in an else
+                            ifContext.IsTrue = !ifContext.WasEverTrue;   // if we were never true, we can be true now
+                            ignore = true;
+                            break;
+
+                        case "endif":
+                            if (0 == ifStack.Count)
+                            {
+                                throw new WixException(WixErrors.UnmatchedPreprocessorInstruction(this.currentLineNumber, "if", "endif"));
+                            }
+
+                            ifContext = (IfContext)ifStack.Pop();
+                            ignore = true;
+                            break;
+                    }
+
+                    if (ignore)   // ignore this node since we just handled it above
+                    {
+                        continue;
+                    }
+                }
+
+                if (!ifContext.Active || !ifContext.IsTrue)   // if our context is not true then skip the rest of the processing and just read the next thing
+                {
+                    continue;
+                }
+
+                switch (reader.NodeType)
+                {
+                    case XmlNodeType.XmlDeclaration:
+                        XDocument document = currentContainer as XDocument;
+                        if (null != document)
+                        {
+                            document.Declaration = new XDeclaration(null, null, null);
+                            while (reader.MoveToNextAttribute())
+                            {
+                                switch (reader.LocalName)
+                                {
+                                    case "version":
+                                        document.Declaration.Version = reader.Value;
+                                        break;
+
+                                    case "encoding":
+                                        document.Declaration.Encoding = reader.Value;
+                                        break;
+
+                                    case "standalone":
+                                        document.Declaration.Standalone = reader.Value;
+                                        break;
+                                }
+                            }
+
+                        }
+                        //else
+                        //{
+                        //    display an error? Can this happen?
+                        //}
+                        break;
+
+                    case XmlNodeType.ProcessingInstruction:
+                        switch (reader.LocalName)
+                        {
+                            case "define":
+                                this.PreprocessDefine(reader.Value);
+                                break;
+
+                            case "error":
+                                this.PreprocessError(reader.Value);
+                                break;
+
+                            case "warning":
+                                this.PreprocessWarning(reader.Value);
+                                break;
+
+                            case "undef":
+                                this.PreprocessUndef(reader.Value);
+                                break;
+
+                            case "include":
+                                this.UpdateCurrentLineNumber(reader, offset);
+                                this.PreprocessInclude(reader.Value, currentContainer);
+                                break;
+
+                            case "foreach":
+                                this.PreprocessForeach(reader, currentContainer, offset);
+                                break;
+
+                            case "endforeach": // endforeach is handled in PreprocessForeach, so seeing it here is an error
+                                throw new WixException(WixErrors.UnmatchedPreprocessorInstruction(this.currentLineNumber, "foreach", "endforeach"));
+
+                            case "pragma":
+                                this.PreprocessPragma(reader.Value, currentContainer);
+                                break;
+
+                            default:
+                                // unknown processing instructions are currently ignored
+                                break;
+                        }
+                        break;
+
+                    case XmlNodeType.Element:
+                        if (0 < this.includeNextStack.Count && this.includeNextStack.Peek())
+                        {
+                            if ("Include" != reader.LocalName)
+                            {
+                                this.core.OnMessage(WixErrors.InvalidDocumentElement(this.currentLineNumber, reader.Name, "include", "Include"));
+                            }
+
+                            this.includeNextStack.Pop();
+                            this.includeNextStack.Push(false);
+                            break;
+                        }
+
+                        bool empty = reader.IsEmptyElement;
+                        XNamespace ns = XNamespace.Get(reader.NamespaceURI);
+                        XElement element = new XElement(ns + reader.LocalName);
+                        currentContainer.Add(element);
+
+                        this.UpdateCurrentLineNumber(reader, offset);
+                        element.AddAnnotation(this.currentLineNumber);
+
+                        while (reader.MoveToNextAttribute())
+                        {
+                            string value = this.core.PreprocessString(this.currentLineNumber, reader.Value);
+                            XNamespace attribNamespace = XNamespace.Get(reader.NamespaceURI);
+                            attribNamespace = XNamespace.Xmlns == attribNamespace && reader.LocalName.Equals("xmlns") ? XNamespace.None : attribNamespace;
+                            element.Add(new XAttribute(attribNamespace + reader.LocalName, value));
+                        }
+
+                        if (!empty)
+                        {
+                            containerStack.Push(currentContainer);
+                            currentContainer = element;
+                        }
+                        break;
+
+                    case XmlNodeType.EndElement:
+                        if (0 < reader.Depth || !include)
+                        {
+                            currentContainer = containerStack.Pop();
+                        }
+                        break;
+
+                    case XmlNodeType.Text:
+                        string postprocessedText = this.core.PreprocessString(this.currentLineNumber, reader.Value);
+                        currentContainer.Add(postprocessedText);
+                        break;
+
+                    case XmlNodeType.CDATA:
+                        string postprocessedValue = this.core.PreprocessString(this.currentLineNumber, reader.Value);
+                        currentContainer.Add(new XCData(postprocessedValue));
+                        break;
+
+                    default:
+                        break;
+                }
+            }
+
+            if (0 != ifStack.Count)
+            {
+                throw new WixException(WixErrors.NonterminatedPreprocessorInstruction(this.currentLineNumber, "if", "endif"));
+            }
+
+            // TODO: can this actually happen?
+            if (0 != containerStack.Count)
+            {
+                throw new WixException(WixErrors.NonterminatedPreprocessorInstruction(this.currentLineNumber, "nodes", "nodes"));
+            }
+        }
+
+        /// <summary>
+        /// Processes an error processing instruction.
+        /// </summary>
+        /// <param name="errorMessage">Text from source.</param>
+        private void PreprocessError(string errorMessage)
+        {
+            SourceLineNumber sourceLineNumbers = this.currentLineNumber;
+
+            // resolve other variables in the error message
+            errorMessage = this.core.PreprocessString(sourceLineNumbers, errorMessage);
+
+            throw new WixException(WixErrors.PreprocessorError(sourceLineNumbers, errorMessage));
+        }
+
+        /// <summary>
+        /// Processes a warning processing instruction.
+        /// </summary>
+        /// <param name="warningMessage">Text from source.</param>
+        private void PreprocessWarning(string warningMessage)
+        {
+            SourceLineNumber sourceLineNumbers = this.currentLineNumber;
+
+            // resolve other variables in the warning message
+            warningMessage = this.core.PreprocessString(sourceLineNumbers, warningMessage);
+
+            this.core.OnMessage(WixWarnings.PreprocessorWarning(sourceLineNumbers, warningMessage));
+        }
+
+        /// <summary>
+        /// Processes a define processing instruction and creates the appropriate parameter.
+        /// </summary>
+        /// <param name="originalDefine">Text from source.</param>
+        private void PreprocessDefine(string originalDefine)
+        {
+            Match match = defineRegex.Match(originalDefine);
+            SourceLineNumber sourceLineNumbers = this.currentLineNumber;
+
+            if (!match.Success)
+            {
+                throw new WixException(WixErrors.IllegalDefineStatement(sourceLineNumbers, originalDefine));
+            }
+
+            string defineName = match.Groups["varName"].Value;
+            string defineValue = match.Groups["varValue"].Value;
+
+            // strip off the optional quotes
+            if (1 < defineValue.Length &&
+                   ((defineValue.StartsWith("\"", StringComparison.Ordinal) && defineValue.EndsWith("\"", StringComparison.Ordinal))
+                || (defineValue.StartsWith("'", StringComparison.Ordinal) && defineValue.EndsWith("'", StringComparison.Ordinal))))
+            {
+                defineValue = defineValue.Substring(1, defineValue.Length - 2);
+            }
+
+            // resolve other variables in the variable value
+            defineValue = this.core.PreprocessString(sourceLineNumbers, defineValue);
+
+            if (defineName.StartsWith("var.", StringComparison.Ordinal))
+            {
+                this.core.AddVariable(sourceLineNumbers, defineName.Substring(4), defineValue);
+            }
+            else
+            {
+                this.core.AddVariable(sourceLineNumbers, defineName, defineValue);
+            }
+        }
+
+        /// <summary>
+        /// Processes an undef processing instruction and creates the appropriate parameter.
+        /// </summary>
+        /// <param name="originalDefine">Text from source.</param>
+        private void PreprocessUndef(string originalDefine)
+        {
+            SourceLineNumber sourceLineNumbers = this.currentLineNumber;
+            string name = this.core.PreprocessString(sourceLineNumbers, originalDefine.Trim());
+
+            if (name.StartsWith("var.", StringComparison.Ordinal))
+            {
+                this.core.RemoveVariable(sourceLineNumbers, name.Substring(4));
+            }
+            else
+            {
+                this.core.RemoveVariable(sourceLineNumbers, name);
+            }
+        }
+
+        /// <summary>
+        /// Processes an included file.
+        /// </summary>
+        /// <param name="includePath">Path to included file.</param>
+        /// <param name="parent">Parent container for included content.</param>
+        private void PreprocessInclude(string includePath, XContainer parent)
+        {
+            SourceLineNumber sourceLineNumbers = this.currentLineNumber;
+
+            // preprocess variables in the path
+            includePath = this.core.PreprocessString(sourceLineNumbers, includePath);
+
+            string includeFile = this.GetIncludeFile(includePath);
+
+            if (null == includeFile)
+            {
+                throw new WixException(WixErrors.FileNotFound(sourceLineNumbers, includePath, "include"));
+            }
+
+            using (XmlReader reader = XmlReader.Create(includeFile, DocumentXmlReaderSettings))
+            {
+                this.PushInclude(includeFile);
+
+                // process the included reader into the writer
+                try
+                {
+                    this.PreprocessReader(true, reader, parent, 0);
+                }
+                catch (XmlException e)
+                {
+                    this.UpdateCurrentLineNumber(reader, 0);
+                    throw new WixException(WixErrors.InvalidXml(sourceLineNumbers, "source", e.Message));
+                }
+
+                this.OnIncludedFile(new IncludedFileEventArgs(sourceLineNumbers, includeFile));
+
+                this.PopInclude();
+            }
+        }
+
+        /// <summary>
+        /// Preprocess a foreach processing instruction.
+        /// </summary>
+        /// <param name="reader">The xml reader.</param>
+        /// <param name="container">The container where to output processed data.</param>
+        /// <param name="offset">Offset for the line numbers.</param>
+        private void PreprocessForeach(XmlReader reader, XContainer container, int offset)
+        {
+            // find the "in" token
+            int indexOfInToken = reader.Value.IndexOf(" in ", StringComparison.Ordinal);
+            if (0 > indexOfInToken)
+            {
+                throw new WixException(WixErrors.IllegalForeach(this.currentLineNumber, reader.Value));
+            }
+
+            // parse out the variable name
+            string varName = reader.Value.Substring(0, indexOfInToken).Trim();
+            string varValuesString = reader.Value.Substring(indexOfInToken + 4).Trim();
+
+            // preprocess the variable values string because it might be a variable itself
+            varValuesString = this.core.PreprocessString(this.currentLineNumber, varValuesString);
+
+            string[] varValues = varValuesString.Split(';');
+
+            // go through all the empty strings
+            while (reader.Read() && XmlNodeType.Whitespace == reader.NodeType)
+            {
+            }
+
+            // get the offset of this xml fragment (for some reason its always off by 1)
+            IXmlLineInfo lineInfoReader = reader as IXmlLineInfo;
+            if (null != lineInfoReader)
+            {
+                offset += lineInfoReader.LineNumber - 1;
+            }
+
+            XmlTextReader textReader = reader as XmlTextReader;
+            // dump the xml to a string (maintaining whitespace if possible)
+            if (null != textReader)
+            {
+                textReader.WhitespaceHandling = WhitespaceHandling.All;
+            }
+
+            StringBuilder fragmentBuilder = new StringBuilder();
+            int nestedForeachCount = 1;
+            while (nestedForeachCount != 0)
+            {
+                if (reader.NodeType == XmlNodeType.ProcessingInstruction)
+                {
+                    switch (reader.LocalName)
+                    {
+                        case "foreach":
+                            ++nestedForeachCount;
+                            // Output the foreach statement
+                            fragmentBuilder.AppendFormat("<?foreach {0}?>", reader.Value);
+                            break;
+
+                        case "endforeach":
+                            --nestedForeachCount;
+                            if (0 != nestedForeachCount)
+                            {
+                                fragmentBuilder.Append("<?endforeach ?>");
+                            }
+                            break;
+
+                        default:
+                            fragmentBuilder.AppendFormat("<?{0} {1}?>", reader.LocalName, reader.Value);
+                            break;
+                    }
+                }
+                else if (reader.NodeType == XmlNodeType.Element)
+                {
+                    fragmentBuilder.Append(reader.ReadOuterXml());
+                    continue;
+                }
+                else if (reader.NodeType == XmlNodeType.Whitespace)
+                {
+                    // Or output the whitespace
+                    fragmentBuilder.Append(reader.Value);
+                }
+                else if (reader.NodeType == XmlNodeType.None)
+                {
+                    throw new WixException(WixErrors.ExpectedEndforeach(this.currentLineNumber));
+                }
+
+                reader.Read();
+            }
+
+            using (MemoryStream fragmentStream = new MemoryStream(Encoding.UTF8.GetBytes(fragmentBuilder.ToString())))
+            using (XmlReader loopReader = XmlReader.Create(fragmentStream, FragmentXmlReaderSettings))
+            {
+                // process each iteration, updating the variable's value each time
+                foreach (string varValue in varValues)
+                {
+                    // Always overwrite foreach variables.
+                    this.core.AddVariable(this.currentLineNumber, varName, varValue, false);
+
+                    try
+                    {
+                        this.PreprocessReader(false, loopReader, container, offset);
+                    }
+                    catch (XmlException e)
+                    {
+                        this.UpdateCurrentLineNumber(loopReader, offset);
+                        throw new WixException(WixErrors.InvalidXml(this.currentLineNumber, "source", e.Message));
+                    }
+
+                    fragmentStream.Position = 0; // seek back to the beginning for the next loop.
+                }
+            }
+        }
+
+        /// <summary>
+        /// Processes a pragma processing instruction
+        /// </summary>
+        /// <param name="pragmaText">Text from source.</param>
+        private void PreprocessPragma(string pragmaText, XContainer parent)
+        {
+            Match match = pragmaRegex.Match(pragmaText);
+            SourceLineNumber sourceLineNumbers = this.currentLineNumber;
+
+            if (!match.Success)
+            {
+                throw new WixException(WixErrors.InvalidPreprocessorPragma(sourceLineNumbers, pragmaText));
+            }
+
+            // resolve other variables in the pragma argument(s)
+            string pragmaArgs = this.core.PreprocessString(sourceLineNumbers, match.Groups["pragmaValue"].Value).Trim();
+
+            try
+            {
+                this.core.PreprocessPragma(sourceLineNumbers, match.Groups["pragmaName"].Value.Trim(), pragmaArgs, parent);
+            }
+            catch (Exception e)
+            {
+                throw new WixException(WixErrors.PreprocessorExtensionPragmaFailed(sourceLineNumbers, pragmaText, e.Message));
+            }
+        }
+
+        /// <summary>
+        /// Gets the next token in an expression.
+        /// </summary>
+        /// <param name="originalExpression">Expression to parse.</param>
+        /// <param name="expression">Expression with token removed.</param>
+        /// <param name="stringLiteral">Flag if token is a string literal instead of a variable.</param>
+        /// <returns>Next token.</returns>
+        private string GetNextToken(string originalExpression, ref string expression, out bool stringLiteral)
+        {
+            stringLiteral = false;
+            string token = String.Empty;
+            expression = expression.Trim();
+            if (0 == expression.Length)
+            {
+                return String.Empty;
+            }
+
+            if (expression.StartsWith("\"", StringComparison.Ordinal))
+            {
+                stringLiteral = true;
+                int endingQuotes = expression.IndexOf('\"', 1);
+                if (-1 == endingQuotes)
+                {
+                    throw new WixException(WixErrors.UnmatchedQuotesInExpression(this.currentLineNumber, originalExpression));
+                }
+
+                // cut the quotes off the string
+                token = this.core.PreprocessString(this.currentLineNumber, expression.Substring(1, endingQuotes - 1));
+
+                // advance past this string
+                expression = expression.Substring(endingQuotes + 1).Trim();
+            }
+            else if (expression.StartsWith("$(", StringComparison.Ordinal))
+            {
+                // Find the ending paren of the expression
+                int endingParen = -1;
+                int openedCount = 1;
+                for (int i = 2; i < expression.Length; i++)
+                {
+                    if ('(' == expression[i])
+                    {
+                        openedCount++;
+                    }
+                    else if (')' == expression[i])
+                    {
+                        openedCount--;
+                    }
+
+                    if (openedCount == 0)
+                    {
+                        endingParen = i;
+                        break;
+                    }
+                }
+
+                if (-1 == endingParen)
+                {
+                    throw new WixException(WixErrors.UnmatchedParenthesisInExpression(this.currentLineNumber, originalExpression));
+                }
+                token = expression.Substring(0, endingParen + 1);
+
+                // Advance past this variable
+                expression = expression.Substring(endingParen + 1).Trim();
+            }
+            else
+            {
+                // Cut the token off at the next equal, space, inequality operator,
+                // or end of string, whichever comes first
+                int space = expression.IndexOf(" ", StringComparison.Ordinal);
+                int equals = expression.IndexOf("=", StringComparison.Ordinal);
+                int lessThan = expression.IndexOf("<", StringComparison.Ordinal);
+                int lessThanEquals = expression.IndexOf("<=", StringComparison.Ordinal);
+                int greaterThan = expression.IndexOf(">", StringComparison.Ordinal);
+                int greaterThanEquals = expression.IndexOf(">=", StringComparison.Ordinal);
+                int notEquals = expression.IndexOf("!=", StringComparison.Ordinal);
+                int equalsNoCase = expression.IndexOf("~=", StringComparison.Ordinal);
+                int closingIndex;
+
+                if (space == -1)
+                {
+                    space = Int32.MaxValue;
+                }
+
+                if (equals == -1)
+                {
+                    equals = Int32.MaxValue;
+                }
+
+                if (lessThan == -1)
+                {
+                    lessThan = Int32.MaxValue;
+                }
+
+                if (lessThanEquals == -1)
+                {
+                    lessThanEquals = Int32.MaxValue;
+                }
+
+                if (greaterThan == -1)
+                {
+                    greaterThan = Int32.MaxValue;
+                }
+
+                if (greaterThanEquals == -1)
+                {
+                    greaterThanEquals = Int32.MaxValue;
+                }
+
+                if (notEquals == -1)
+                {
+                    notEquals = Int32.MaxValue;
+                }
+
+                if (equalsNoCase == -1)
+                {
+                    equalsNoCase = Int32.MaxValue;
+                }
+
+                closingIndex = Math.Min(space, Math.Min(equals, Math.Min(lessThan, Math.Min(lessThanEquals, Math.Min(greaterThan, Math.Min(greaterThanEquals, Math.Min(equalsNoCase, notEquals)))))));
+
+                if (Int32.MaxValue == closingIndex)
+                {
+                    closingIndex = expression.Length;
+                }
+
+                // If the index is 0, we hit an operator, so return it
+                if (0 == closingIndex)
+                {
+                    // Length 2 operators
+                    if (closingIndex == lessThanEquals || closingIndex == greaterThanEquals || closingIndex == notEquals || closingIndex == equalsNoCase)
+                    {
+                        closingIndex = 2;
+                    }
+                    else // Length 1 operators
+                    {
+                        closingIndex = 1;
+                    }
+                }
+
+                // Cut out the new token
+                token = expression.Substring(0, closingIndex).Trim();
+                expression = expression.Substring(closingIndex).Trim();
+            }
+
+            return token;
+        }
+
+        /// <summary>
+        /// Gets the value for a variable.
+        /// </summary>
+        /// <param name="originalExpression">Original expression for error message.</param>
+        /// <param name="variable">Variable to evaluate.</param>
+        /// <returns>Value of variable.</returns>
+        private string EvaluateVariable(string originalExpression, string variable)
+        {
+            // By default it's a literal and will only be evaluated if it
+            // matches the variable format
+            string varValue = variable;
+
+            if (variable.StartsWith("$(", StringComparison.Ordinal))
+            {
+                try
+                {
+                    varValue = this.core.PreprocessString(this.currentLineNumber, variable);
+                }
+                catch (ArgumentNullException)
+                {
+                    // non-existent variables are expected
+                    varValue = null;
+                }
+            }
+            else if (variable.IndexOf("(", StringComparison.Ordinal) != -1 || variable.IndexOf(")", StringComparison.Ordinal) != -1)
+            {
+                // make sure it doesn't contain parenthesis
+                throw new WixException(WixErrors.UnmatchedParenthesisInExpression(this.currentLineNumber, originalExpression));
+            }
+            else if (variable.IndexOf("\"", StringComparison.Ordinal) != -1)
+            {
+                // shouldn't contain quotes
+                throw new WixException(WixErrors.UnmatchedQuotesInExpression(this.currentLineNumber, originalExpression));
+            }
+
+            return varValue;
+        }
+
+        /// <summary>
+        /// Gets the left side value, operator, and right side value of an expression.
+        /// </summary>
+        /// <param name="originalExpression">Original expression to evaluate.</param>
+        /// <param name="expression">Expression modified while processing.</param>
+        /// <param name="leftValue">Left side value from expression.</param>
+        /// <param name="operation">Operation in expression.</param>
+        /// <param name="rightValue">Right side value from expression.</param>
+        private void GetNameValuePair(string originalExpression, ref string expression, out string leftValue, out string operation, out string rightValue)
+        {
+            bool stringLiteral;
+            leftValue = this.GetNextToken(originalExpression, ref expression, out stringLiteral);
+
+            // If it wasn't a string literal, evaluate it
+            if (!stringLiteral)
+            {
+                leftValue = this.EvaluateVariable(originalExpression, leftValue);
+            }
+
+            // Get the operation
+            operation = this.GetNextToken(originalExpression, ref expression, out stringLiteral);
+            if (IsOperator(operation))
+            {
+                if (stringLiteral)
+                {
+                    throw new WixException(WixErrors.UnmatchedQuotesInExpression(this.currentLineNumber, originalExpression));
+                }
+
+                rightValue = this.GetNextToken(originalExpression, ref expression, out stringLiteral);
+
+                // If it wasn't a string literal, evaluate it
+                if (!stringLiteral)
+                {
+                    rightValue = this.EvaluateVariable(originalExpression, rightValue);
+                }
+            }
+            else
+            {
+                // Prepend the token back on the expression since it wasn't an operator
+                // and put the quotes back on the literal if necessary
+
+                if (stringLiteral)
+                {
+                    operation = "\"" + operation + "\"";
+                }
+                expression = (operation + " " + expression).Trim();
+
+                // If no operator, just check for existence
+                operation = "";
+                rightValue = "";
+            }
+        }
+
+        /// <summary>
+        /// Evaluates an expression.
+        /// </summary>
+        /// <param name="originalExpression">Original expression to evaluate.</param>
+        /// <param name="expression">Expression modified while processing.</param>
+        /// <returns>true if expression evaluates to true.</returns>
+        private bool EvaluateAtomicExpression(string originalExpression, ref string expression)
+        {
+            // Quick test to see if the first token is a variable
+            bool startsWithVariable = expression.StartsWith("$(", StringComparison.Ordinal);
+
+            string leftValue;
+            string rightValue;
+            string operation;
+            this.GetNameValuePair(originalExpression, ref expression, out leftValue, out operation, out rightValue);
+
+            bool expressionValue = false;
+
+            // If the variables don't exist, they were evaluated to null
+            if (null == leftValue || null == rightValue)
+            {
+                if (operation.Length > 0)
+                {
+                    throw new WixException(WixErrors.ExpectedVariable(this.currentLineNumber, originalExpression));
+                }
+
+                // false expression
+            }
+            else if (operation.Length == 0)
+            {
+                // There is no right side of the equation.
+                // If the variable was evaluated, it exists, so the expression is true
+                if (startsWithVariable)
+                {
+                    expressionValue = true;
+                }
+                else
+                {
+                    throw new WixException(WixErrors.UnexpectedLiteral(this.currentLineNumber, originalExpression));
+                }
+            }
+            else
+            {
+                leftValue = leftValue.Trim();
+                rightValue = rightValue.Trim();
+                if ("=" == operation)
+                {
+                    if (leftValue == rightValue)
+                    {
+                        expressionValue = true;
+                    }
+                }
+                else if ("!=" == operation)
+                {
+                    if (leftValue != rightValue)
+                    {
+                        expressionValue = true;
+                    }
+                }
+                else if ("~=" == operation)
+                {
+                    if (String.Equals(leftValue, rightValue, StringComparison.OrdinalIgnoreCase))
+                    {
+                        expressionValue = true;
+                    }
+                }
+                else
+                {
+                    // Convert the numbers from strings
+                    int rightInt;
+                    int leftInt;
+                    try
+                    {
+                        rightInt = Int32.Parse(rightValue, CultureInfo.InvariantCulture);
+                        leftInt = Int32.Parse(leftValue, CultureInfo.InvariantCulture);
+                    }
+                    catch (FormatException)
+                    {
+                        throw new WixException(WixErrors.IllegalIntegerInExpression(this.currentLineNumber, originalExpression));
+                    }
+                    catch (OverflowException)
+                    {
+                        throw new WixException(WixErrors.IllegalIntegerInExpression(this.currentLineNumber, originalExpression));
+                    }
+
+                    // Compare the numbers
+                    if ("<" == operation && leftInt < rightInt ||
+                        "<=" == operation && leftInt <= rightInt ||
+                        ">" == operation && leftInt > rightInt ||
+                        ">=" == operation && leftInt >= rightInt)
+                    {
+                        expressionValue = true;
+                    }
+                }
+            }
+
+            return expressionValue;
+        }
+
+        /// <summary>
+        /// Gets a sub-expression in parenthesis.
+        /// </summary>
+        /// <param name="originalExpression">Original expression to evaluate.</param>
+        /// <param name="expression">Expression modified while processing.</param>
+        /// <param name="endSubExpression">Index of end of sub-expression.</param>
+        /// <returns>Sub-expression in parenthesis.</returns>
+        private string GetParenthesisExpression(string originalExpression, string expression, out int endSubExpression)
+        {
+            endSubExpression = 0;
+
+            // if the expression doesn't start with parenthesis, leave it alone
+            if (!expression.StartsWith("(", StringComparison.Ordinal))
+            {
+                return expression;
+            }
+
+            // search for the end of the expression with the matching paren
+            int openParenIndex = 0;
+            int closeParenIndex = 1;
+            while (openParenIndex != -1 && openParenIndex < closeParenIndex)
+            {
+                closeParenIndex = expression.IndexOf(')', closeParenIndex);
+                if (closeParenIndex == -1)
+                {
+                    throw new WixException(WixErrors.UnmatchedParenthesisInExpression(this.currentLineNumber, originalExpression));
+                }
+
+                if (InsideQuotes(expression, closeParenIndex))
+                {
+                    // ignore stuff inside quotes (it's a string literal)
+                }
+                else
+                {
+                    // Look to see if there is another open paren before the close paren
+                    // and skip over the open parens while they are in a string literal
+                    do
+                    {
+                        openParenIndex++;
+                        openParenIndex = expression.IndexOf('(', openParenIndex, closeParenIndex - openParenIndex);
+                    }
+                    while (InsideQuotes(expression, openParenIndex));
+                }
+
+                // Advance past the closing paren
+                closeParenIndex++;
+            }
+
+            endSubExpression = closeParenIndex;
+
+            // Return the expression minus the parenthesis
+            return expression.Substring(1, closeParenIndex - 2);
+        }
+
+        /// <summary>
+        /// Updates expression based on operation.
+        /// </summary>
+        /// <param name="currentValue">State to update.</param>
+        /// <param name="operation">Operation to apply to current value.</param>
+        /// <param name="prevResult">Previous result.</param>
+        private void UpdateExpressionValue(ref bool currentValue, PreprocessorOperation operation, bool prevResult)
+        {
+            switch (operation)
+            {
+                case PreprocessorOperation.And:
+                    currentValue = currentValue && prevResult;
+                    break;
+                case PreprocessorOperation.Or:
+                    currentValue = currentValue || prevResult;
+                    break;
+                case PreprocessorOperation.Not:
+                    currentValue = !currentValue;
+                    break;
+                default:
+                    throw new WixException(WixErrors.UnexpectedPreprocessorOperator(this.currentLineNumber, operation.ToString()));
+            }
+        }
+
+        /// <summary>
+        /// Evaluate an expression.
+        /// </summary>
+        /// <param name="expression">Expression to evaluate.</param>
+        /// <returns>Boolean result of expression.</returns>
+        private bool EvaluateExpression(string expression)
+        {
+            string tmpExpression = expression;
+            return this.EvaluateExpressionRecurse(expression, ref tmpExpression, PreprocessorOperation.And, true);
+        }
+
+        /// <summary>
+        /// Recurse through the expression to evaluate if it is true or false.
+        /// The expression is evaluated left to right. 
+        /// The expression is case-sensitive (converted to upper case) with the
+        /// following exceptions: variable names and keywords (and, not, or).
+        /// Comparisons with = and != are string comparisons.  
+        /// Comparisons with inequality operators must be done on valid integers.
+        /// 
+        /// The operator precedence is:
+        ///    ""
+        ///    ()
+        ///    &lt;, &gt;, &lt;=, &gt;=, =, !=
+        ///    Not
+        ///    And, Or
+        ///    
+        /// Valid expressions include:
+        ///   not $(var.B) or not $(var.C)
+        ///   (($(var.A))and $(var.B) ="2")or Not((($(var.C))) and $(var.A))
+        ///   (($(var.A)) and $(var.B) = " 3 ") or $(var.C)
+        ///   $(var.A) and $(var.C) = "3" or $(var.C) and $(var.D) = $(env.windir)
+        ///   $(var.A) and $(var.B)>2 or $(var.B) &lt;= 2
+        ///   $(var.A) != "2" 
+        /// </summary>
+        /// <param name="originalExpression">The original expression</param>
+        /// <param name="expression">The expression currently being evaluated</param>
+        /// <param name="prevResultOperation">The operation to apply to this result</param>
+        /// <param name="prevResult">The previous result to apply to this result</param>
+        /// <returns>Boolean to indicate if the expression is true or false</returns>
+        private bool EvaluateExpressionRecurse(string originalExpression, ref string expression, PreprocessorOperation prevResultOperation, bool prevResult)
+        {
+            bool expressionValue = false;
+            expression = expression.Trim();
+            if (expression.Length == 0)
+            {
+                throw new WixException(WixErrors.UnexpectedEmptySubexpression(this.currentLineNumber, originalExpression));
+            }
+
+            // If the expression starts with parenthesis, evaluate it
+            if (expression.IndexOf('(') == 0)
+            {
+                int endSubExpressionIndex;
+                string subExpression = this.GetParenthesisExpression(originalExpression, expression, out endSubExpressionIndex);
+                expressionValue = this.EvaluateExpressionRecurse(originalExpression, ref subExpression, PreprocessorOperation.And, true);
+
+                // Now get the rest of the expression that hasn't been evaluated
+                expression = expression.Substring(endSubExpressionIndex).Trim();
+            }
+            else
+            {
+                // Check for NOT
+                if (StartsWithKeyword(expression, PreprocessorOperation.Not))
+                {
+                    expression = expression.Substring(3).Trim();
+                    if (expression.Length == 0)
+                    {
+                        throw new WixException(WixErrors.ExpectedExpressionAfterNot(this.currentLineNumber, originalExpression));
+                    }
+
+                    expressionValue = this.EvaluateExpressionRecurse(originalExpression, ref expression, PreprocessorOperation.Not, true);
+                }
+                else // Expect a literal
+                {
+                    expressionValue = this.EvaluateAtomicExpression(originalExpression, ref expression);
+
+                    // Expect the literal that was just evaluated to already be cut off
+                }
+            }
+            this.UpdateExpressionValue(ref expressionValue, prevResultOperation, prevResult);
+
+            // If there's still an expression left, it must start with AND or OR.
+            if (expression.Trim().Length > 0)
+            {
+                if (StartsWithKeyword(expression, PreprocessorOperation.And))
+                {
+                    expression = expression.Substring(3);
+                    return this.EvaluateExpressionRecurse(originalExpression, ref expression, PreprocessorOperation.And, expressionValue);
+                }
+                else if (StartsWithKeyword(expression, PreprocessorOperation.Or))
+                {
+                    expression = expression.Substring(2);
+                    return this.EvaluateExpressionRecurse(originalExpression, ref expression, PreprocessorOperation.Or, expressionValue);
+                }
+                else
+                {
+                    throw new WixException(WixErrors.InvalidSubExpression(this.currentLineNumber, expression, originalExpression));
+                }
+            }
+
+            return expressionValue;
+        }
+
+        /// <summary>
+        /// Update the current line number with the reader's current state.
+        /// </summary>
+        /// <param name="reader">The xml reader for the preprocessor.</param>
+        /// <param name="offset">This is the artificial offset of the line numbers from the reader.  Used for the foreach processing.</param>
+        private void UpdateCurrentLineNumber(XmlReader reader, int offset)
+        {
+            IXmlLineInfo lineInfoReader = reader as IXmlLineInfo;
+            if (null != lineInfoReader)
+            {
+                int newLine = lineInfoReader.LineNumber + offset;
+
+                if (this.currentLineNumber.LineNumber != newLine)
+                {
+                    this.currentLineNumber = new SourceLineNumber(this.currentLineNumber.FileName, newLine);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Pushes a file name on the stack of included files.
+        /// </summary>
+        /// <param name="fileName">Name to push on to the stack of included files.</param>
+        private void PushInclude(string fileName)
+        {
+            if (1023 < this.currentFileStack.Count)
+            {
+                throw new WixException(WixErrors.TooDeeplyIncluded(this.currentLineNumber, this.currentFileStack.Count));
+            }
+
+            this.currentFileStack.Push(fileName);
+            this.sourceStack.Push(this.currentLineNumber);
+            this.currentLineNumber = new SourceLineNumber(fileName);
+            this.includeNextStack.Push(true);
+        }
+
+        /// <summary>
+        /// Pops a file name from the stack of included files.
+        /// </summary>
+        private void PopInclude()
+        {
+            this.currentLineNumber = this.sourceStack.Pop();
+
+            this.currentFileStack.Pop();
+            this.includeNextStack.Pop();
+        }
+
+        /// <summary>
+        /// Go through search paths, looking for a matching include file.
+        /// Start the search in the directory of the source file, then go
+        /// through the search paths in the order given on the command line
+        /// (leftmost first, ...).
+        /// </summary>
+        /// <param name="includePath">User-specified path to the included file (usually just the file name).</param>
+        /// <returns>Returns a FileInfo for the found include file, or null if the file cannot be found.</returns>
+        private string GetIncludeFile(string includePath)
+        {
+            string finalIncludePath = null;
+
+            includePath = includePath.Trim();
+
+            // remove quotes (only if they match)
+            if ((includePath.StartsWith("\"", StringComparison.Ordinal) && includePath.EndsWith("\"", StringComparison.Ordinal)) ||
+                (includePath.StartsWith("'", StringComparison.Ordinal) && includePath.EndsWith("'", StringComparison.Ordinal)))
+            {
+                includePath = includePath.Substring(1, includePath.Length - 2);
+            }
+
+            // check if the include file is a full path
+            if (Path.IsPathRooted(includePath))
+            {
+                if (File.Exists(includePath))
+                {
+                    finalIncludePath = includePath;
+                }
+            }
+            else // relative path
+            {
+                // build a string to test the directory containing the source file first
+                string currentFolder = this.currentFileStack.Peek();
+                string includeTestPath = Path.Combine(Path.GetDirectoryName(currentFolder) ?? String.Empty, includePath);
+
+                // test the source file directory
+                if (File.Exists(includeTestPath))
+                {
+                    finalIncludePath = includeTestPath;
+                }
+                else // test all search paths in the order specified on the command line
+                {
+                    foreach (string includeSearchPath in this.IncludeSearchPaths)
+                    {
+                        // if the path exists, we have found the final string
+                        includeTestPath = Path.Combine(includeSearchPath, includePath);
+                        if (File.Exists(includeTestPath))
+                        {
+                            finalIncludePath = includeTestPath;
+                            break;
+                        }
+                    }
+                }
+            }
+
+            return finalIncludePath;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/PreprocessorCore.cs b/src/WixToolset.Core/PreprocessorCore.cs
new file mode 100644
index 00000000..b58fc80c
--- /dev/null
+++ b/src/WixToolset.Core/PreprocessorCore.cs
@@ -0,0 +1,560 @@
+// 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
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Text;
+    using System.Xml.Linq;
+    using WixToolset.Data;
+    using WixToolset.Extensibility;
+
+    /// <summary>
+    /// The preprocessor core.
+    /// </summary>
+    internal class PreprocessorCore : IPreprocessorCore
+    {
+        private static readonly char[] variableSplitter = new char[] { '.' };
+        private static readonly char[] argumentSplitter = new char[] { ',' };
+
+        private Platform currentPlatform;
+        private Dictionary<string, IPreprocessorExtension> extensionsByPrefix;
+        private string sourceFile;
+        private IDictionary<string, string> variables;
+
+        /// <summary>
+        /// Instantiate a new PreprocessorCore.
+        /// </summary>
+        /// <param name="extensionsByPrefix">The extensions indexed by their prefixes.</param>
+        /// <param name="messageHandler">The message handler.</param>
+        /// <param name="sourceFile">The source file being preprocessed.</param>
+        /// <param name="variables">The variables defined prior to preprocessing.</param>
+        internal PreprocessorCore(Dictionary<string, IPreprocessorExtension> extensionsByPrefix, string sourceFile, IDictionary<string, string> variables)
+        {
+            this.extensionsByPrefix = extensionsByPrefix;
+            this.sourceFile = String.IsNullOrEmpty(sourceFile) ? null : Path.GetFullPath(sourceFile);
+
+            this.variables = new Dictionary<string, string>();
+            foreach (var entry in variables)
+            {
+                this.AddVariable(null, entry.Key, entry.Value);
+            }
+        }
+
+        /// <summary>
+        /// Event for resolved variables.
+        /// </summary>
+        private event ResolvedVariableEventHandler ResolvedVariable;
+
+        /// <summary>
+        /// Sets event for ResolvedVariableEventHandler.
+        /// </summary>
+        public ResolvedVariableEventHandler ResolvedVariableHandler
+        {
+            set { this.ResolvedVariable = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the platform which the compiler will use when defaulting 64-bit attributes and elements.
+        /// </summary>
+        /// <value>The platform which the compiler will use when defaulting 64-bit attributes and elements.</value>
+        public Platform CurrentPlatform
+        {
+            get { return this.currentPlatform; }
+            set { this.currentPlatform = value; }
+        }
+
+        /// <summary>
+        /// Gets whether the core encountered an error while processing.
+        /// </summary>
+        /// <value>Flag if core encountered an error during processing.</value>
+        public bool EncounteredError
+        {
+            get { return Messaging.Instance.EncounteredError; }
+        }
+
+        /// <summary>
+        /// Replaces parameters in the source text.
+        /// </summary>
+        /// <param name="sourceLineNumbers">The source line information for the function.</param>
+        /// <param name="value">Text that may contain parameters to replace.</param>
+        /// <returns>Text after parameters have been replaced.</returns>
+        public string PreprocessString(SourceLineNumber sourceLineNumbers, string value)
+        {
+            StringBuilder sb = new StringBuilder();
+            int currentPosition = 0;
+            int end = 0;
+
+            while (-1 != (currentPosition = value.IndexOf('$', end)))
+            {
+                if (end < currentPosition)
+                {
+                    sb.Append(value, end, currentPosition - end);
+                }
+
+                end = currentPosition + 1;
+                string remainder = value.Substring(end);
+                if (remainder.StartsWith("$", StringComparison.Ordinal))
+                {
+                    sb.Append("$");
+                    end++;
+                }
+                else if (remainder.StartsWith("(loc.", StringComparison.Ordinal))
+                {
+                    currentPosition = remainder.IndexOf(')');
+                    if (-1 == currentPosition)
+                    {
+                        this.OnMessage(WixErrors.InvalidPreprocessorVariable(sourceLineNumbers, remainder));
+                        break;
+                    }
+
+                    sb.Append("$");   // just put the resource reference back as was
+                    sb.Append(remainder, 0, currentPosition + 1);
+
+                    end += currentPosition + 1;
+                }
+                else if (remainder.StartsWith("(", StringComparison.Ordinal))
+                {
+                    int openParenCount = 1;
+                    int closingParenCount = 0;
+                    bool isFunction = false;
+                    bool foundClosingParen = false;
+
+                    // find the closing paren
+                    int closingParenPosition;
+                    for (closingParenPosition = 1; closingParenPosition < remainder.Length; closingParenPosition++)
+                    {
+                        switch (remainder[closingParenPosition])
+                        {
+                            case '(':
+                                openParenCount++;
+                                isFunction = true;
+                                break;
+                            case ')':
+                                closingParenCount++;
+                                break;
+                        }
+                        if (openParenCount == closingParenCount)
+                        {
+                            foundClosingParen = true;
+                            break;
+                        }
+                    }
+
+                    // move the currentPosition to the closing paren
+                    currentPosition += closingParenPosition;
+
+                    if (!foundClosingParen)
+                    {
+                        if (isFunction)
+                        {
+                            this.OnMessage(WixErrors.InvalidPreprocessorFunction(sourceLineNumbers, remainder));
+                            break;
+                        }
+                        else
+                        {
+                            this.OnMessage(WixErrors.InvalidPreprocessorVariable(sourceLineNumbers, remainder));
+                            break;
+                        }
+                    }
+
+                    string subString = remainder.Substring(1, closingParenPosition - 1);
+                    string result = null;
+                    if (isFunction)
+                    {
+                        result = this.EvaluateFunction(sourceLineNumbers, subString);
+                    }
+                    else
+                    {
+                        result = this.GetVariableValue(sourceLineNumbers, subString, false);
+                    }
+
+                    if (null == result)
+                    {
+                        if (isFunction)
+                        {
+                            this.OnMessage(WixErrors.UndefinedPreprocessorFunction(sourceLineNumbers, subString));
+                            break;
+                        }
+                        else
+                        {
+                            this.OnMessage(WixErrors.UndefinedPreprocessorVariable(sourceLineNumbers, subString));
+                            break;
+                        }
+                    }
+                    else
+                    {
+                        if (!isFunction)
+                        {
+                            this.OnResolvedVariable(new ResolvedVariableEventArgs(sourceLineNumbers, subString, result));
+                        }
+                    }
+                    sb.Append(result);
+                    end += closingParenPosition + 1;
+                }
+                else   // just a floating "$" so put it in the final string (i.e. leave it alone) and keep processing
+                {
+                    sb.Append('$');
+                }
+            }
+
+            if (end < value.Length)
+            {
+                sb.Append(value.Substring(end));
+            }
+
+            return sb.ToString();
+        }
+
+        /// <summary>
+        /// Evaluate a Pragma.
+        /// </summary>
+        /// <param name="sourceLineNumbers">The source line information for the function.</param>
+        /// <param name="pragmaName">The pragma's full name (<prefix>.<pragma>).</param>
+        /// <param name="args">The arguments to the pragma.</param>
+        /// <param name="parent">The parent element of the pragma.</param>
+        public void PreprocessPragma(SourceLineNumber sourceLineNumbers, string pragmaName, string args, XContainer parent)
+        {
+            string[] prefixParts = pragmaName.Split(variableSplitter, 2);
+            // Check to make sure there are 2 parts and neither is an empty string.
+            if (2 != prefixParts.Length)
+            {
+                throw new WixException(WixErrors.InvalidPreprocessorPragma(sourceLineNumbers, pragmaName));
+            }
+            string prefix = prefixParts[0];
+            string pragma = prefixParts[1];
+
+            if (String.IsNullOrEmpty(prefix) || String.IsNullOrEmpty(pragma))
+            {
+                throw new WixException(WixErrors.InvalidPreprocessorPragma(sourceLineNumbers, pragmaName));
+            }
+
+            switch (prefix)
+            {
+                case "wix":
+                    switch (pragma)
+                    {
+                        // Add any core defined pragmas here
+                        default:
+                            this.OnMessage(WixWarnings.PreprocessorUnknownPragma(sourceLineNumbers, pragmaName));
+                            break;
+                    }
+                    break;
+                default:
+                    PreprocessorExtension extension = (PreprocessorExtension)this.extensionsByPrefix[prefix];
+                    if (null == extension || !extension.ProcessPragma(sourceLineNumbers, prefix, pragma, args, parent))
+                    {
+                        this.OnMessage(WixWarnings.PreprocessorUnknownPragma(sourceLineNumbers, pragmaName));
+                    }
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// Evaluate a function.
+        /// </summary>
+        /// <param name="sourceLineNumbers">The source line information for the function.</param>
+        /// <param name="function">The function expression including the prefix and name.</param>
+        /// <returns>The function value.</returns>
+        public string EvaluateFunction(SourceLineNumber sourceLineNumbers, string function)
+        {
+            string[] prefixParts = function.Split(variableSplitter, 2);
+            // Check to make sure there are 2 parts and neither is an empty string.
+            if (2 != prefixParts.Length || 0 >= prefixParts[0].Length || 0 >= prefixParts[1].Length)
+            {
+                throw new WixException(WixErrors.InvalidPreprocessorFunction(sourceLineNumbers, function));
+            }
+            string prefix = prefixParts[0];
+
+            string[] functionParts = prefixParts[1].Split(new char[] { '(' }, 2);
+            // Check to make sure there are 2 parts, neither is an empty string, and the second part ends with a closing paren.
+            if (2 != functionParts.Length || 0 >= functionParts[0].Length || 0 >= functionParts[1].Length || !functionParts[1].EndsWith(")", StringComparison.Ordinal))
+            {
+                throw new WixException(WixErrors.InvalidPreprocessorFunction(sourceLineNumbers, function));
+            }
+            string functionName = functionParts[0];
+
+            // Remove the trailing closing paren.
+            string allArgs = functionParts[1].Substring(0, functionParts[1].Length - 1);
+
+            // Parse the arguments and preprocess them.
+            string[] args = allArgs.Split(argumentSplitter);
+            for (int i = 0; i < args.Length; i++)
+            {
+                args[i] = this.PreprocessString(sourceLineNumbers, args[i].Trim());
+            }
+
+            string result = this.EvaluateFunction(sourceLineNumbers, prefix, functionName, args);
+
+            // If the function didn't evaluate, try to evaluate the original value as a variable to support 
+            // the use of open and closed parens inside variable names. Example: $(env.ProgramFiles(x86)) should resolve.
+            if (null == result)
+            {
+                result = this.GetVariableValue(sourceLineNumbers, function, false);
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Evaluate a function.
+        /// </summary>
+        /// <param name="sourceLineNumbers">The source line information for the function.</param>
+        /// <param name="prefix">The function prefix.</param>
+        /// <param name="function">The function name.</param>
+        /// <param name="args">The arguments for the function.</param>
+        /// <returns>The function value or null if the function is not defined.</returns>
+        public string EvaluateFunction(SourceLineNumber sourceLineNumbers, string prefix, string function, string[] args)
+        {
+            if (String.IsNullOrEmpty(prefix))
+            {
+                throw new ArgumentNullException("prefix");
+            }
+
+            if (String.IsNullOrEmpty(function))
+            {
+                throw new ArgumentNullException("function");
+            }
+
+            switch (prefix)
+            {
+                case "fun":
+                    switch (function)
+                    {
+                        case "AutoVersion":
+                            // Make sure the base version is specified
+                            if (args.Length == 0 || String.IsNullOrEmpty(args[0]))
+                            {
+                                throw new WixException(WixErrors.InvalidPreprocessorFunctionAutoVersion(sourceLineNumbers));
+                            }
+
+                            // Build = days since 1/1/2000; Revision = seconds since midnight / 2
+                            DateTime now = DateTime.UtcNow;
+                            TimeSpan build = now - new DateTime(2000, 1, 1);
+                            TimeSpan revision = now - new DateTime(now.Year, now.Month, now.Day);
+
+                            return String.Join(".", args[0], (int)build.TotalDays, (int)(revision.TotalSeconds / 2));
+
+                        default:
+                            return null;
+                    }
+                default:
+                    PreprocessorExtension extension = (PreprocessorExtension)this.extensionsByPrefix[prefix];
+                    if (null != extension)
+                    {
+                        try
+                        {
+                            return extension.EvaluateFunction(prefix, function, args);
+                        }
+                        catch (Exception e)
+                        {
+                            throw new WixException(WixErrors.PreprocessorExtensionEvaluateFunctionFailed(sourceLineNumbers, prefix, function, String.Join(",", args), e.Message));
+                        }
+                    }
+                    else
+                    {
+                        return null;
+                    }
+            }
+        }
+
+        /// <summary>
+        /// Get the value of a variable expression like var.name.
+        /// </summary>
+        /// <param name="sourceLineNumbers">The source line information for the variable.</param>
+        /// <param name="variable">The variable expression including the optional prefix and name.</param>
+        /// <param name="allowMissingPrefix">true to allow the variable prefix to be missing.</param>
+        /// <returns>The variable value.</returns>
+        public string GetVariableValue(SourceLineNumber sourceLineNumbers, string variable, bool allowMissingPrefix)
+        {
+            // Strip the "$(" off the front.
+            if (variable.StartsWith("$(", StringComparison.Ordinal))
+            {
+                variable = variable.Substring(2);
+            }
+
+            string[] parts = variable.Split(variableSplitter, 2);
+
+            if (1 == parts.Length) // missing prefix
+            {
+                if (allowMissingPrefix)
+                {
+                    return this.GetVariableValue(sourceLineNumbers, "var", parts[0]);
+                }
+                else
+                {
+                    throw new WixException(WixErrors.InvalidPreprocessorVariable(sourceLineNumbers, variable));
+                }
+            }
+            else
+            {
+                // check for empty variable name
+                if (0 < parts[1].Length)
+                {
+                    string result = this.GetVariableValue(sourceLineNumbers, parts[0], parts[1]);
+
+                    // If we didn't find it and we allow missing prefixes and the variable contains a dot, perhaps the dot isn't intended to indicate a prefix
+                    if (null == result && allowMissingPrefix && variable.Contains("."))
+                    {
+                        result = this.GetVariableValue(sourceLineNumbers, "var", variable);
+                    }
+
+                    return result;
+                }
+                else
+                {
+                    throw new WixException(WixErrors.InvalidPreprocessorVariable(sourceLineNumbers, variable));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Get the value of a variable.
+        /// </summary>
+        /// <param name="sourceLineNumbers">The source line information for the function.</param>
+        /// <param name="prefix">The variable prefix.</param>
+        /// <param name="name">The variable name.</param>
+        /// <returns>The variable value or null if the variable is not set.</returns>
+        public string GetVariableValue(SourceLineNumber sourceLineNumbers, string prefix, string name)
+        {
+            if (String.IsNullOrEmpty(prefix))
+            {
+                throw new ArgumentNullException("prefix");
+            }
+
+            if (String.IsNullOrEmpty(name))
+            {
+                throw new ArgumentNullException("name");
+            }
+
+            switch (prefix)
+            {
+                case "env":
+                    return Environment.GetEnvironmentVariable(name);
+                case "sys":
+                    switch (name)
+                    {
+                        case "CURRENTDIR":
+                            return String.Concat(Directory.GetCurrentDirectory(), Path.DirectorySeparatorChar);
+                        case "SOURCEFILEDIR":
+                            return String.Concat(Path.GetDirectoryName(sourceLineNumbers.FileName), Path.DirectorySeparatorChar);
+                        case "SOURCEFILEPATH":
+                            return sourceLineNumbers.FileName;
+                        case "PLATFORM":
+                            this.OnMessage(WixWarnings.DeprecatedPreProcVariable(sourceLineNumbers, "$(sys.PLATFORM)", "$(sys.BUILDARCH)"));
+
+                            goto case "BUILDARCH";
+
+                        case "BUILDARCH":
+                            switch (this.currentPlatform)
+                            {
+                                case Platform.X86:
+                                    return "x86";
+                                case Platform.X64:
+                                    return "x64";
+                                case Platform.IA64:
+                                    return "ia64";
+                                case Platform.ARM:
+                                    return "arm";
+                                default:
+                                    throw new ArgumentException(WixStrings.EXP_UnknownPlatformEnum, this.currentPlatform.ToString());
+                            }
+                        default:
+                            return null;
+                    }
+                case "var":
+                    string result = null;
+                    return this.variables.TryGetValue(name, out result) ? result : null;
+                default:
+                    PreprocessorExtension extension = (PreprocessorExtension)this.extensionsByPrefix[prefix];
+                    if (null != extension)
+                    {
+                        try
+                        {
+                            return extension.GetVariableValue(prefix, name);
+                        }
+                        catch (Exception e)
+                        {
+                            throw new WixException(WixErrors.PreprocessorExtensionGetVariableValueFailed(sourceLineNumbers, prefix, name, e.Message));
+                        }
+                    }
+                    else
+                    {
+                        return null;
+                    }
+            }
+        }
+
+        /// <summary>
+        /// Sends a message to the message delegate if there is one.
+        /// </summary>
+        /// <param name="mea">Message event arguments.</param>
+        public void OnMessage(MessageEventArgs e)
+        {
+            Messaging.Instance.OnMessage(e);
+        }
+
+        /// <summary>
+        /// Sends resolved variable to delegate if there is one.
+        /// </summary>
+        /// <param name="mea">Message event arguments.</param>
+        public void OnResolvedVariable(ResolvedVariableEventArgs mea)
+        {
+            if (null != this.ResolvedVariable)
+            {
+                this.ResolvedVariable(this, mea);
+            }
+        }
+
+        /// <summary>
+        /// Add a variable.
+        /// </summary>
+        /// <param name="sourceLineNumbers">The source line information of the variable.</param>
+        /// <param name="name">The variable name.</param>
+        /// <param name="value">The variable value.</param>
+        internal void AddVariable(SourceLineNumber sourceLineNumbers, string name, string value)
+        {
+            this.AddVariable(sourceLineNumbers, name, value, true);
+        }
+
+        /// <summary>
+        /// Add a variable.
+        /// </summary>
+        /// <param name="sourceLineNumbers">The source line information of the variable.</param>
+        /// <param name="name">The variable name.</param>
+        /// <param name="value">The variable value.</param>
+        /// <param name="overwrite">Set to true to show variable overwrite warning.</param>
+        internal void AddVariable(SourceLineNumber sourceLineNumbers, string name, string value, bool showWarning)
+        {
+            string currentValue = this.GetVariableValue(sourceLineNumbers, "var", name);
+
+            if (null == currentValue)
+            {
+                this.variables.Add(name, value);
+            }
+            else
+            {
+                if (showWarning)
+                {
+                    this.OnMessage(WixWarnings.VariableDeclarationCollision(sourceLineNumbers, name, value, currentValue));
+                }
+
+                this.variables[name] = value;
+            }
+        }
+
+        /// <summary>
+        /// Remove a variable.
+        /// </summary>
+        /// <param name="sourceLineNumbers">The source line information of the variable.</param>
+        /// <param name="name">The variable name.</param>
+        internal void RemoveVariable(SourceLineNumber sourceLineNumbers, string name)
+        {
+            if (!this.variables.Remove(name))
+            {
+                this.OnMessage(WixErrors.CannotReundefineVariable(sourceLineNumbers, name));
+            }
+        }
+    }
+}