1 files changed, 1598 insertions, 0 deletions

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;
+        }
+    }
+}